added ludbo map support

luticateutils/src/main/java/com/luticate/utils/dbo/LuDbo.java

 import java.lang.reflect.Type;
 import java.util.AbstractMap;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 import java.util.Vector;
 
 /**
         fromJson(json);
     }
 
-    public static String getFieldFromJson(String jsonName)
+    public String getFieldFromJson(String jsonName)
     {
         if (!jsonName.startsWith("_")) {
             return String.format("_%s", jsonName);
         return jsonName;
     }
 
-    public static String getJsonFromField(String fieldName)
+    public String getJsonFromField(String fieldName)
     {
         if (fieldName.startsWith("_")) {
             return fieldName.substring(1);
         return fieldName;
     }
 
-    public static Object getObjectFromJson(Class clazz, JSONObject json, String key) throws Exception {
+    public Object getObjectFromJson(Class clazz, JSONObject json, String key) throws Exception {
         if (json.isNull(key)) {
             return null;
         }
             return json.getString(key);
         }
         if (LuDbo.class.isAssignableFrom(clazz)) {
-            LuDbo dbo = (LuDbo) clazz.newInstance();
+            LuDbo dbo = (LuDbo) getInstance(clazz);
             dbo.fromJson(json.getJSONObject(key));
             return dbo;
         }
         return null;
     }
 
-    public static Object getObjectFromJson(Class clazz, JSONArray json, int key) throws Exception {
+    public Object getObjectFromJson(Class clazz, JSONArray json, int key) throws Exception {
         if (json.isNull(key)) {
             return null;
         }
             return json.getString(key);
         }
         if (LuDbo.class.isAssignableFrom(clazz)) {
-            LuDbo dbo = (LuDbo) clazz.newInstance();
+            LuDbo dbo = (LuDbo) getInstance(clazz);
             dbo.fromJson(json.getJSONObject(key));
             return dbo;
         }
         return null;
     }
 
+    public Object getInstance(Class clazz) throws Exception {
+        if (clazz == List.class) {
+            return new Vector<>();
+        }
+        if (clazz == AbstractMap.class) {
+            return new HashMap<>();
+        }
+        return clazz.newInstance();
+    }
+
     public void fromJson(JSONObject json) throws Exception
     {
         for (Field field : getClass().getDeclaredFields()) {
                 if (List.class.isAssignableFrom(clazz)) {
                     ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
                     Class type = (Class) parameterizedType.getActualTypeArguments()[0];
-                    List<Object> list = (clazz == List.class ? new Vector<>() : (List<Object>) clazz.newInstance());
+                    List<Object> list = (List<Object>) getInstance(clazz);
                     JSONArray jsonArray = json.getJSONArray(key);
                     for (int i = 0; i < jsonArray.length(); ++i) {
                         list.add(getObjectFromJson(type, jsonArray, i));
                     }
                     value = array;
                 }
-//                else if (AbstractMap.class.isAssignableFrom(clazz)) {
-//                    ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
-//                    Class type = (Class) parameterizedType.getActualTypeArguments()[0];
-//                    if (type == String.class) {
-//                        type = (Class) parameterizedType.getActualTypeArguments()[1];
-//                    }
-//                }
+                else if (AbstractMap.class.isAssignableFrom(clazz)) {
+                    ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
+                    Class type = (Class) parameterizedType.getActualTypeArguments()[0];
+                    if (type == String.class) {
+                        type = (Class) parameterizedType.getActualTypeArguments()[1];
+                        AbstractMap<String, Object> map = (AbstractMap<String, Object>) getInstance(clazz);
+                        JSONObject obj = json.getJSONObject(key);
+                        Iterator<String> it = obj.keys();
+                        while (it.hasNext()) {
+                            String k = it.next();
+                            map.put(k, getObjectFromJson(type, obj, k));
+                        }
+                        value = map;
+                    }
+                }
                 else {
                     value = getObjectFromJson(clazz, json, key);
                 }
     {
         HashMap<String, Object> map = new HashMap<>();
 
+        for (Field field : getClass().getDeclaredFields()) {
+            String key = getJsonFromField(field.getName());
+            Class clazz = field.getType();
+        }
+
         return map;
     }
 

luticateutils/src/test/java/com/luticate/utils/NameDboTest.java

 package com.luticate.utils;
 
 import com.luticate.utils.dbo.LuDbo;
+import com.luticate.utils.dbo.LuVoidDbo;
 
 import org.junit.Test;
 
     @Test
     public void jsonFromFieldTest()
     {
-        assertEquals("byte", LuDbo.getJsonFromField("_byte"));
-        assertEquals("anotherVariable", LuDbo.getJsonFromField("_anotherVariable"));
-        assertEquals("byte", LuDbo.getJsonFromField("byte"));
-        assertEquals("anotherVariable", LuDbo.getJsonFromField("anotherVariable"));
+        LuDbo dbo = new LuVoidDbo();
+        assertEquals("byte", dbo.getJsonFromField("_byte"));
+        assertEquals("anotherVariable", dbo.getJsonFromField("_anotherVariable"));
+        assertEquals("byte", dbo.getJsonFromField("byte"));
+        assertEquals("anotherVariable", dbo.getJsonFromField("anotherVariable"));
     }
 
     @Test
     public void fieldFromJsonTest()
     {
-        assertEquals("_byte", LuDbo.getFieldFromJson("byte"));
-        assertEquals("_anotherVariable", LuDbo.getFieldFromJson("anotherVariable"));
-        assertEquals("_byte", LuDbo.getFieldFromJson("_byte"));
-        assertEquals("_anotherVariable", LuDbo.getFieldFromJson("_anotherVariable"));
+        LuDbo dbo = new LuVoidDbo();
+        assertEquals("_byte", dbo.getFieldFromJson("byte"));
+        assertEquals("_anotherVariable", dbo.getFieldFromJson("anotherVariable"));
+        assertEquals("_byte", dbo.getFieldFromJson("_byte"));
+        assertEquals("_anotherVariable", dbo.getFieldFromJson("_anotherVariable"));
     }
 }

luticateutils/src/test/java/com/luticate/utils/Test2Dbo.java

     public void setaInt(int aInt) {
         _aInt = aInt;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Test2Dbo test2Dbo = (Test2Dbo) o;
+
+        if (_aInt != test2Dbo._aInt) return false;
+        return _aString != null ? _aString.equals(test2Dbo._aString) : test2Dbo._aString == null;
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = _aString != null ? _aString.hashCode() : 0;
+        result = 31 * result + _aInt;
+        return result;
+    }
 }

luticateutils/src/test/java/com/luticate/utils/TestDbo.java

 
 import com.luticate.utils.dbo.LuDbo;
 
+import java.io.Serializable;
+import java.util.AbstractMap;
 import java.util.HashMap;
 import java.util.List;
 
  * Created by robin on 10/20/16.
  */
 
-public class TestDbo extends LuDbo {
+public class TestDbo extends LuDbo implements Serializable {
     protected byte _byte;
     protected char _char;
     protected short _short;
     protected String _string;
 
     protected Test2Dbo _test2Dbo;
-
     protected Test2Dbo _test2Dbo2;
 
     protected List<Integer> _integers;
-
     protected int[] _ints;
 
     protected List<Test2Dbo> _test2Dbos;
-
     protected Test2Dbo[] _dbos;
 
+    protected HashMap<String, Integer> _hashMap;
+    protected AbstractMap<String, Test2Dbo> _hashMap2;
+
     public byte getByte() {
         return _byte;
     }
     public void setDbos(Test2Dbo[] dbos) {
         _dbos = dbos;
     }
+
+    public HashMap<String, Integer> getHashMap() {
+        return _hashMap;
+    }
+
+    public void setHashMap(HashMap<String, Integer> hashMap) {
+        _hashMap = hashMap;
+    }
+
+    public AbstractMap<String, Test2Dbo> getHashMap2() {
+        return _hashMap2;
+    }
+
+    public void setHashMap2(AbstractMap<String, Test2Dbo> hashMap2) {
+        _hashMap2 = hashMap2;
+    }
 }

luticateutils/src/test/java/com/luticate/utils/TestDboTest.java

         TestDbo test = new TestDbo();
         test.fromString("{" +
                 "\"byte\": 42," +
-                "\"byteObject\": 24," +
                 "\"char\": \"h\"," +
-                "\"charObject\": \"w\"," +
                 "\"short\": 4200," +
-                "\"shortObject\": 2400," +
                 "\"int\": 420042," +
-                "\"intObject\": 240024," +
                 "\"long\": 42004200," +
-                "\"longObject\": 24002400," +
                 "\"float\": 42.24," +
-                "\"floatObject\": 24.42," +
                 "\"double\": 4200.0024," +
-                "\"doubleObject\": 2400.0042," +
                 "\"boolean\": true," +
+
+                "\"byteObject\": 24," +
+                "\"charObject\": \"w\"," +
+                "\"shortObject\": 2400," +
+                "\"intObject\": 240024," +
+                "\"longObject\": 24002400," +
+                "\"floatObject\": 24.42," +
+                "\"doubleObject\": 2400.0042," +
                 "\"booleanObject\": false," +
+
                 "\"string\": \"Hello World!\"," +
+
                 "\"test2Dbo\": {" +
                 "\"aString\": \"a string\"," +
                 "\"aInt\": 4242" +
                 "}," +
+
                 "\"integers\": [" +
                 "0," +
                 "42," +
                 "42," +
                 "0" +
                 "]," +
+
                 "test2Dbos: [" +
                 "{" +
                 "\"aString\": \"42 42\"," +
                 "\"aString\": \"24 24\"," +
                 "\"aInt\": 2424" +
                 "}" +
-                "]" +
+                "]," +
+
+                "\"hashMap\": {" +
+                "\"forty-two\": 42," +
+                "\"twenty-four\": 24" +
+                "}," +
+
+                "\"hashMap2\": {" +
+                "\"an object\": {" +
+                "\"aString\": \"42 24\"," +
+                "\"aInt\": 4224" +
+                "}" +
+                "}" +
+
                 "}");
         assertEquals(42, test.getByte());
         assertEquals(24, test.getByteObject().byteValue());
         assertNotNull(test.getDbos()[0]);
         assertEquals("24 24", test.getDbos()[0].getaString());
         assertEquals(2424, test.getDbos()[0].getaInt());
+
+        assertNotNull(test.getHashMap());
+        assertEquals(2, test.getHashMap().size());
+        assertTrue(test.getHashMap().containsKey("forty-two"));
+        assertEquals(42, (int)test.getHashMap().get("forty-two"));
+        assertTrue(test.getHashMap().containsKey("twenty-four"));
+        assertEquals(24, (int)test.getHashMap().get("twenty-four"));
+
+        assertNotNull(test.getHashMap2());
+        assertEquals(1, test.getHashMap2().size());
+        assertTrue(test.getHashMap2().containsKey("an object"));
+        assertNotNull(test.getHashMap2().get("an object"));
+        assertEquals("42 24", test.getHashMap2().get("an object").getaString());
+        assertEquals(4224, test.getHashMap2().get("an object").getaInt());
+    }
+
+    @Test
+    public void serializeTest()
+    {
+        Test2Dbo dbo = new Test2Dbo();
+        dbo.setaInt(2442);
+        dbo.setaString("24 42");
+
     }
 }