src/org/redkale/convert/bson/BsonFactory.java

@@ -27,24 +27,60 @@ public final class BsonFactory extends ConvertFactory<BsonReader, BsonWriter> {
 
     static final Encodeable objectEncoder = instance.loadEncoder(Object.class);
 
+    static final Decodeable collectionBooleanDecoder = instance.loadDecoder(new TypeToken<Collection<Boolean>>() {
+    }.getType());
+
+    static final Decodeable collectionByteDecoder = instance.loadDecoder(new TypeToken<Collection<Byte>>() {
+    }.getType());
+
+    static final Decodeable collectionShortDecoder = instance.loadDecoder(new TypeToken<Collection<Short>>() {
+    }.getType());
+
+    static final Decodeable collectionCharacterDecoder = instance.loadDecoder(new TypeToken<Collection<Character>>() {
+    }.getType());
+
     static final Decodeable collectionIntegerDecoder = instance.loadDecoder(new TypeToken<Collection<Integer>>() {
     }.getType());
 
     static final Decodeable collectionLongDecoder = instance.loadDecoder(new TypeToken<Collection<Long>>() {
     }.getType());
 
+    static final Decodeable collectionFloatDecoder = instance.loadDecoder(new TypeToken<Collection<Float>>() {
+    }.getType());
+
+    static final Decodeable collectionDoubleDecoder = instance.loadDecoder(new TypeToken<Collection<Double>>() {
+    }.getType());
+
     static final Decodeable collectionStringDecoder = instance.loadDecoder(new TypeToken<Collection<String>>() {
     }.getType());
 
     static final Decodeable collectionObjectDecoder = instance.loadDecoder(new TypeToken<Collection<Object>>() {
     }.getType());
 
+    static final Decodeable mapStringBooleanDecoder = instance.loadDecoder(new TypeToken<Map<String, Boolean>>() {
+    }.getType());
+
+    static final Decodeable mapStringByteDecoder = instance.loadDecoder(new TypeToken<Map<String, Byte>>() {
+    }.getType());
+
+    static final Decodeable mapStringShortDecoder = instance.loadDecoder(new TypeToken<Map<String, Short>>() {
+    }.getType());
+
+    static final Decodeable mapStringCharacterDecoder = instance.loadDecoder(new TypeToken<Map<String, Character>>() {
+    }.getType());
+
     static final Decodeable mapStringIntegerDecoder = instance.loadDecoder(new TypeToken<Map<String, Integer>>() {
     }.getType());
 
     static final Decodeable mapStringLongDecoder = instance.loadDecoder(new TypeToken<Map<String, Long>>() {
     }.getType());
 
+    static final Decodeable mapStringFloatDecoder = instance.loadDecoder(new TypeToken<Map<String, Float>>() {
+    }.getType());
+
+    static final Decodeable mapStringDoubleDecoder = instance.loadDecoder(new TypeToken<Map<String, Double>>() {
+    }.getType());
+
     static final Decodeable mapStringStringDecoder = instance.loadDecoder(new TypeToken<Map<String, String>>() {
     }.getType());
 

src/org/redkale/convert/bson/BsonReader.java

@@ -111,17 +111,50 @@ public class BsonReader extends Reader {
                 break;
             case 9: readString();
                 break;
+            case 20:
+                BsonFactory.collectionObjectDecoder.convertFrom(this);
+                break;
+            case 21:
+                BsonFactory.collectionBooleanDecoder.convertFrom(this);
+                break;
+            case 22:
+                BsonFactory.collectionByteDecoder.convertFrom(this);
+                break;
+            case 23:
+                BsonFactory.collectionShortDecoder.convertFrom(this);
+                break;
+            case 24:
+                BsonFactory.collectionCharacterDecoder.convertFrom(this);
+                break;
             case 25:
                 BsonFactory.collectionIntegerDecoder.convertFrom(this);
                 break;
             case 26:
                 BsonFactory.collectionLongDecoder.convertFrom(this);
                 break;
+            case 27:
+                BsonFactory.collectionFloatDecoder.convertFrom(this);
+                break;
+            case 28:
+                BsonFactory.collectionDoubleDecoder.convertFrom(this);
+                break;
             case 29:
                 BsonFactory.collectionStringDecoder.convertFrom(this);
                 break;
-            case 30:
-                BsonFactory.collectionObjectDecoder.convertFrom(this);
+            case 40:
+                BsonFactory.mapStringObjectDecoder.convertFrom(this);
+                break;
+            case 41:
+                BsonFactory.mapStringBooleanDecoder.convertFrom(this);
+                break;
+            case 42:
+                BsonFactory.mapStringByteDecoder.convertFrom(this);
+                break;
+            case 43:
+                BsonFactory.mapStringShortDecoder.convertFrom(this);
+                break;
+            case 44:
+                BsonFactory.mapStringCharacterDecoder.convertFrom(this);
                 break;
             case 45:
                 BsonFactory.mapStringIntegerDecoder.convertFrom(this);
@@ -129,12 +162,15 @@ public class BsonReader extends Reader {
             case 46:
                 BsonFactory.mapStringLongDecoder.convertFrom(this);
                 break;
+            case 47:
+                BsonFactory.mapStringFloatDecoder.convertFrom(this);
+                break;
+            case 48:
+                BsonFactory.mapStringDoubleDecoder.convertFrom(this);
+                break;
             case 49:
                 BsonFactory.mapStringStringDecoder.convertFrom(this);
                 break;
-            case 50:
-                BsonFactory.mapStringObjectDecoder.convertFrom(this);
-                break;
             case 101:
                 BoolArraySimpledCoder.instance.convertFrom(this);
                 break;

src/org/redkale/convert/bson/BsonWriter.java

@@ -242,27 +242,54 @@ public class BsonWriter extends Writer {
         }
         if (typeval == 127 && member.getEncoder() instanceof CollectionEncoder) {
             java.lang.reflect.Type comType = ((CollectionEncoder) member.getEncoder()).getEncoder().getType();
-            if (comType == Integer.class) {
+            if (comType == Boolean.class) {
+                typeval = 21;
+            } else if (comType == Byte.class) {
+                typeval = 22;
+            } else if (comType == Short.class) {
+                typeval = 23;
+            } else if (comType == Character.class) {
+                typeval = 24;
+            } else if (comType == Integer.class) {
                 typeval = 25;
             } else if (comType == Long.class) {
                 typeval = 26;
+            } else if (comType == Float.class) {
+                typeval = 27;
+            } else if (comType == Double.class) {
+                typeval = 28;
             } else if (comType == String.class) {
                 typeval = 29;
-            } else if (!comType.toString().startsWith("java.lang")) {
-                typeval = 30;
+            } else {
+                typeval = 20;
             }
         }
+        if (typeval == 127 && member.getEncoder() instanceof ArrayEncoder) {
+            typeval = 20;
+        }
         if (typeval == 127 && member.getEncoder() instanceof MapEncoder) {
             java.lang.reflect.Type keyType = ((MapEncoder) member.getEncoder()).getKeyencoder().getType();
             java.lang.reflect.Type valType = ((MapEncoder) member.getEncoder()).getValencoder().getType();
-            if (keyType == String.class && valType == Integer.class) {
+            if (keyType == String.class && valType == Boolean.class) {
+                typeval = 41;
+            } else if (keyType == String.class && valType == Byte.class) {
+                typeval = 42;
+            } else if (keyType == String.class && valType == Short.class) {
+                typeval = 43;
+            } else if (keyType == String.class && valType == Character.class) {
+                typeval = 44;
+            } else if (keyType == String.class && valType == Integer.class) {
                 typeval = 45;
             } else if (keyType == String.class && valType == Long.class) {
                 typeval = 46;
+            } else if (keyType == String.class && valType == Float.class) {
+                typeval = 47;
+            } else if (keyType == String.class && valType == Double.class) {
+                typeval = 48;
             } else if (keyType == String.class && valType == String.class) {
                 typeval = 49;
-            } else if (keyType == String.class && !valType.toString().startsWith("java.lang")) {
-                typeval = 50;
+            } else if (keyType == String.class) {
+                typeval = 40;
             }
         }
         writeByte(typeval);