UUID specification implementation updates

jyemin · jyemin · commit ff0386ed65be · 2019-12-09T12:50:00.000-05:00
* Implement required behavior in MapCodec and IterableCodec * Implement required behavior in DBCollection JAVA-3516
diff --git a/bson/src/main/org/bson/LazyBSONObject.java b/bson/src/main/org/bson/LazyBSONObject.java
@@ -177,7 +177,7 @@ Object readValue(final BsonBinaryReader reader) {
             case BINARY:
                 byte binarySubType = reader.peekBinarySubType();
                 if (BsonBinarySubType.isUuid(binarySubType) && reader.peekBinarySize() == 16) {
-                    return new UuidCodec().decode(reader, DecoderContext.builder().build());
+                    return new UuidCodec(UuidRepresentation.JAVA_LEGACY).decode(reader, DecoderContext.builder().build());
                 }
                 BsonBinary binary = reader.readBinaryData();
                 if (binarySubType == BINARY.getValue() || binarySubType == OLD_BINARY.getValue()) {
diff --git a/bson/src/main/org/bson/codecs/IterableCodec.java b/bson/src/main/org/bson/codecs/IterableCodec.java
@@ -16,11 +16,11 @@
 
 package org.bson.codecs;
 
-import org.bson.BsonBinarySubType;
 import org.bson.BsonReader;
 import org.bson.BsonType;
 import org.bson.BsonWriter;
 import org.bson.Transformer;
+import org.bson.UuidRepresentation;
 import org.bson.codecs.configuration.CodecRegistry;
 
 import java.util.ArrayList;
@@ -35,11 +35,12 @@
  * @since 3.3
  */
 @SuppressWarnings("rawtypes")
-public class IterableCodec implements Codec<Iterable> {
+public class IterableCodec implements Codec<Iterable>, OverridableUuidRepresentationCodec<Iterable> {
 
     private final CodecRegistry registry;
     private final BsonTypeCodecMap bsonTypeCodecMap;
     private final Transformer valueTransformer;
+    private final UuidRepresentation uuidRepresentation;
 
     /**
      * Construct a new instance with the given {@code CodecRegistry} and {@code BsonTypeClassMap}.
@@ -59,14 +60,27 @@ public IterableCodec(final CodecRegistry registry, final BsonTypeClassMap bsonTy
      * @param valueTransformer the value Transformer
      */
     public IterableCodec(final CodecRegistry registry, final BsonTypeClassMap bsonTypeClassMap, final Transformer valueTransformer) {
+        this(registry, new BsonTypeCodecMap(notNull("bsonTypeClassMap", bsonTypeClassMap), registry), valueTransformer,
+                UuidRepresentation.JAVA_LEGACY);
+    }
+
+    private IterableCodec(final CodecRegistry registry, final BsonTypeCodecMap bsonTypeCodecMap, final Transformer valueTransformer,
+                         final UuidRepresentation uuidRepresentation) {
         this.registry = notNull("registry", registry);
-        this.bsonTypeCodecMap = new BsonTypeCodecMap(notNull("bsonTypeClassMap", bsonTypeClassMap), registry);
+        this.bsonTypeCodecMap = bsonTypeCodecMap;
         this.valueTransformer = valueTransformer != null ? valueTransformer : new Transformer() {
             @Override
             public Object transform(final Object objectToTransform) {
                 return objectToTransform;
             }
         };
+        this.uuidRepresentation = uuidRepresentation;
+    }
+
+
+    @Override
+    public Codec<Iterable> withUuidRepresentation(final UuidRepresentation uuidRepresentation) {
+        return new IterableCodec(registry, bsonTypeCodecMap, valueTransformer, uuidRepresentation);
     }
 
     @Override
@@ -112,9 +126,27 @@ private Object readValue(final BsonReader reader, final DecoderContext decoderCo
         if (bsonType == BsonType.NULL) {
             reader.readNull();
             return null;
-        } else if (bsonType == BsonType.BINARY && BsonBinarySubType.isUuid(reader.peekBinarySubType()) && reader.peekBinarySize() == 16) {
-            return registry.get(UUID.class).decode(reader, decoderContext);
+        } else {
+            Codec<?> codec = bsonTypeCodecMap.get(bsonType);
+            if (bsonType == BsonType.BINARY && reader.peekBinarySize() == 16) {
+                switch (reader.peekBinarySubType()) {
+                    case 3:
+                        if (uuidRepresentation == UuidRepresentation.JAVA_LEGACY
+                                || uuidRepresentation == UuidRepresentation.C_SHARP_LEGACY
+                                || uuidRepresentation == UuidRepresentation.PYTHON_LEGACY) {
+                            codec = registry.get(UUID.class);
+                        }
+                        break;
+                    case 4:
+                        if (uuidRepresentation == UuidRepresentation.JAVA_LEGACY || uuidRepresentation == UuidRepresentation.STANDARD) {
+                            codec = registry.get(UUID.class);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+            return valueTransformer.transform(codec.decode(reader, decoderContext));
         }
-        return valueTransformer.transform(bsonTypeCodecMap.get(bsonType).decode(reader, decoderContext));
     }
 }
diff --git a/bson/src/main/org/bson/codecs/MapCodec.java b/bson/src/main/org/bson/codecs/MapCodec.java
@@ -16,11 +16,11 @@
 
 package org.bson.codecs;
 
-import org.bson.BsonBinarySubType;
 import org.bson.BsonReader;
 import org.bson.BsonType;
 import org.bson.BsonWriter;
 import org.bson.Transformer;
+import org.bson.UuidRepresentation;
 import org.bson.codecs.configuration.CodecRegistry;
 
 import java.util.HashMap;
@@ -37,14 +37,15 @@
  *
  * @since 3.5
  */
-public class MapCodec implements Codec<Map<String, Object>> {
+public class MapCodec implements Codec<Map<String, Object>>, OverridableUuidRepresentationCodec<Map<String, Object>> {
 
     private static final CodecRegistry DEFAULT_REGISTRY = fromProviders(asList(new ValueCodecProvider(), new BsonValueCodecProvider(),
             new DocumentCodecProvider(), new IterableCodecProvider(), new MapCodecProvider()));
     private static final BsonTypeClassMap DEFAULT_BSON_TYPE_CLASS_MAP = new BsonTypeClassMap();
     private final BsonTypeCodecMap bsonTypeCodecMap;
     private final CodecRegistry registry;
     private final Transformer valueTransformer;
+    private final UuidRepresentation uuidRepresentation;
 
     /**
      * Construct a new instance with a default {@code CodecRegistry}
@@ -82,14 +83,26 @@ public MapCodec(final CodecRegistry registry, final BsonTypeClassMap bsonTypeCla
      * @param valueTransformer the value transformer to use as a final step when decoding the value of any field in the map
      */
     public MapCodec(final CodecRegistry registry, final BsonTypeClassMap bsonTypeClassMap, final Transformer valueTransformer) {
+        this(registry, new BsonTypeCodecMap(notNull("bsonTypeClassMap", bsonTypeClassMap), registry), valueTransformer,
+                UuidRepresentation.JAVA_LEGACY);
+    }
+
+    private MapCodec(final CodecRegistry registry, final BsonTypeCodecMap bsonTypeCodecMap, final Transformer valueTransformer,
+               final UuidRepresentation uuidRepresentation) {
         this.registry = notNull("registry", registry);
-        this.bsonTypeCodecMap = new BsonTypeCodecMap(notNull("bsonTypeClassMap", bsonTypeClassMap), registry);
+        this.bsonTypeCodecMap = bsonTypeCodecMap;
         this.valueTransformer = valueTransformer != null ? valueTransformer : new Transformer() {
             @Override
             public Object transform(final Object value) {
                 return value;
             }
         };
+        this.uuidRepresentation = uuidRepresentation;
+    }
+
+    @Override
+    public Codec<Map<String, Object>> withUuidRepresentation(final UuidRepresentation uuidRepresentation) {
+        return new MapCodec(registry, bsonTypeCodecMap, valueTransformer, uuidRepresentation);
     }
 
     @Override
@@ -129,8 +142,26 @@ private Object readValue(final BsonReader reader, final DecoderContext decoderCo
             return null;
         } else if (bsonType == BsonType.ARRAY) {
             return decoderContext.decodeWithChildContext(registry.get(List.class), reader);
-        } else if (bsonType == BsonType.BINARY && BsonBinarySubType.isUuid(reader.peekBinarySubType()) && reader.peekBinarySize() == 16) {
-            return decoderContext.decodeWithChildContext(registry.get(UUID.class), reader);
+        } else if (bsonType == BsonType.BINARY && reader.peekBinarySize() == 16) {
+            Codec<?> codec = bsonTypeCodecMap.get(bsonType);
+            switch (reader.peekBinarySubType()) {
+                case 3:
+                    if (uuidRepresentation == UuidRepresentation.JAVA_LEGACY
+                            || uuidRepresentation == UuidRepresentation.C_SHARP_LEGACY
+                            || uuidRepresentation == UuidRepresentation.PYTHON_LEGACY) {
+                        codec = registry.get(UUID.class);
+                    }
+                    break;
+                case 4:
+                    if (uuidRepresentation == UuidRepresentation.JAVA_LEGACY || uuidRepresentation == UuidRepresentation.STANDARD) {
+                        codec = registry.get(UUID.class);
+                    }
+                    break;
+                default:
+                    break;
+            }
+
+            return decoderContext.decodeWithChildContext(codec, reader);
         }
         return valueTransformer.transform(bsonTypeCodecMap.get(bsonType).decode(reader, decoderContext));
     }
diff --git a/bson/src/test/unit/org/bson/codecs/IterableCodecSpecification.groovy b/bson/src/test/unit/org/bson/codecs/IterableCodecSpecification.groovy
@@ -16,13 +16,21 @@
 
 package org.bson.codecs
 
+
 import org.bson.BsonDocument
 import org.bson.BsonDocumentReader
 import org.bson.BsonDocumentWriter
 import org.bson.types.Binary
 import spock.lang.Specification
+import spock.lang.Unroll
 
 import static org.bson.BsonDocument.parse
+import static org.bson.UuidRepresentation.C_SHARP_LEGACY
+import static org.bson.UuidRepresentation.JAVA_LEGACY
+import static org.bson.UuidRepresentation.PYTHON_LEGACY
+import static org.bson.UuidRepresentation.STANDARD
+import static org.bson.UuidRepresentation.UNSPECIFIED
+import static org.bson.codecs.configuration.CodecRegistries.fromCodecs
 import static org.bson.codecs.configuration.CodecRegistries.fromProviders
 
 class IterableCodecSpecification extends Specification {
@@ -122,4 +130,55 @@ class IterableCodecSpecification extends Specification {
         '{"array": [{ "$binary" : "CAcGBQQDAgEQDw4NDAsKCQ==", "$type" : "3" }]}' | [UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10')]
     }
 
+    @SuppressWarnings(['LineLength'])
+    @Unroll
+    def 'should decode binary subtype 3 for UUID'() {
+        given:
+        def reader = new BsonDocumentReader(parse(document))
+        def codec = new IterableCodec(fromCodecs(new UuidCodec(representation), new BinaryCodec()), new BsonTypeClassMap())
+                .withUuidRepresentation(representation)
+
+        when:
+        reader.readStartDocument()
+        reader.readName('array')
+        def iterable = codec.decode(reader, DecoderContext.builder().build())
+        reader.readEndDocument()
+
+        then:
+        value == iterable
+
+        where:
+        representation | value                                                     | document
+        JAVA_LEGACY    | [UUID.fromString('08070605-0403-0201-100f-0e0d0c0b0a09')] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "3" }]}'
+        C_SHARP_LEGACY | [UUID.fromString('04030201-0605-0807-090a-0b0c0d0e0f10')] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "3" }]}'
+        PYTHON_LEGACY  | [UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10')] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "3" }]}'
+        STANDARD       | [new Binary((byte) 3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[])] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "3" }]}'
+        UNSPECIFIED    | [new Binary((byte) 3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[])] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "3" }]}'
+    }
+
+    @SuppressWarnings(['LineLength'])
+    @Unroll
+    def 'should decode binary subtype 4 for UUID'() {
+        given:
+        def reader = new BsonDocumentReader(parse(document))
+        def codec = new IterableCodec(fromCodecs(new UuidCodec(representation), new BinaryCodec()), new BsonTypeClassMap())
+                .withUuidRepresentation(representation)
+
+        when:
+        reader.readStartDocument()
+        reader.readName('array')
+        def iterable = codec.decode(reader, DecoderContext.builder().build())
+        reader.readEndDocument()
+
+        then:
+        value == iterable
+
+        where:
+        representation | value                                                     | document
+        STANDARD       | [UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10')] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "4" }]}'
+        JAVA_LEGACY    | [UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10')] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "4" }]}'
+        C_SHARP_LEGACY | [new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[])] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "4" }]}'
+        PYTHON_LEGACY  | [new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[])] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "4" }]}'
+        UNSPECIFIED    | [new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[])] | '{"array": [{ "$binary" : "AQIDBAUGBwgJCgsMDQ4PEA==", "$type" : "4" }]}'
+    }
 }
diff --git a/bson/src/test/unit/org/bson/codecs/MapCodecSpecification.groovy b/bson/src/test/unit/org/bson/codecs/MapCodecSpecification.groovy
@@ -42,13 +42,20 @@ import org.bson.types.ObjectId
 import org.bson.types.Symbol
 import spock.lang.Shared
 import spock.lang.Specification
+import spock.lang.Unroll
 
 import java.nio.ByteBuffer
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 
 import static java.util.Arrays.asList
+import static org.bson.UuidRepresentation.C_SHARP_LEGACY
+import static org.bson.UuidRepresentation.JAVA_LEGACY
+import static org.bson.UuidRepresentation.PYTHON_LEGACY
+import static org.bson.UuidRepresentation.STANDARD
+import static org.bson.UuidRepresentation.UNSPECIFIED
+import static org.bson.codecs.configuration.CodecRegistries.fromCodecs
 import static org.bson.codecs.configuration.CodecRegistries.fromProviders
 
 class MapCodecSpecification extends Specification {
@@ -139,22 +146,48 @@ class MapCodecSpecification extends Specification {
     }
 
     @SuppressWarnings(['LineLength'])
-    def 'should decode binary subtypes for UUID'() {
+    @Unroll
+    def 'should decode binary subtype 3 for UUID'() {
         given:
         def reader = new BsonBinaryReader(ByteBuffer.wrap(bytes as byte[]))
 
         when:
-        def document = new MapCodec().decode(reader, DecoderContext.builder().build())
+        def map = new MapCodec(fromCodecs(new UuidCodec(representation), new BinaryCodec()))
+                .withUuidRepresentation(representation)
+                .decode(reader, DecoderContext.builder().build())
 
         then:
-        value == document.get('f')
+        value == map.get('f')
 
         where:
-        value                                                   | bytes
-        new Binary((byte) 0x03, (byte[]) [115, 116, 11])        | [16, 0, 0, 0, 5, 102, 0, 3, 0, 0, 0, 3, 115, 116, 11, 0]
-        new Binary((byte) 0x04, (byte[]) [115, 116, 11])        | [16, 0, 0, 0, 5, 102, 0, 3, 0, 0, 0, 4, 115, 116, 11, 0]
-        UUID.fromString('08070605-0403-0201-100f-0e0d0c0b0a09') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
-        UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        representation | value                                                   | bytes
+        JAVA_LEGACY    | UUID.fromString('08070605-0403-0201-100f-0e0d0c0b0a09') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        C_SHARP_LEGACY | UUID.fromString('04030201-0605-0807-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        PYTHON_LEGACY  | UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        STANDARD       | new Binary((byte) 3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[]) | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        UNSPECIFIED    | new Binary((byte) 3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[]) | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+    }
+
+    @SuppressWarnings(['LineLength'])
+    @Unroll
+    def 'should decode binary subtype 4 for UUID'() {
+        given:
+        def reader = new BsonBinaryReader(ByteBuffer.wrap(bytes as byte[]))
+
+        when:
+        def map = new MapCodec().withUuidRepresentation(representation)
+                .decode(reader, DecoderContext.builder().build())
+
+        then:
+        value == map.get('f')
+
+        where:
+        representation | value                                                   | bytes
+        STANDARD       | UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        JAVA_LEGACY    | UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        C_SHARP_LEGACY | new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[]) | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        PYTHON_LEGACY  | new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[]) | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        UNSPECIFIED    | new Binary((byte) 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as byte[]) | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
     }
 
     def 'should apply transformer to decoded values'() {
diff --git a/driver-legacy/src/main/com/mongodb/DBCollection.java b/driver-legacy/src/main/com/mongodb/DBCollection.java
@@ -2447,10 +2447,11 @@ private List<com.mongodb.bulk.WriteRequest> translateWriteRequestsToNew(final Li
         return retVal;
     }
 
-    DBObjectCodec getDefaultDBObjectCodec() {
-        return new DBObjectCodec(MongoClient.getDefaultCodecRegistry(),
+    Codec<DBObject> getDefaultDBObjectCodec() {
+        return new DBObjectCodec(getDB().getMongoClient().getCodecRegistry(),
                                  DBObjectCodec.getDefaultBsonTypeClassMap(),
-                                 getObjectFactory());
+                                 getObjectFactory())
+                .withUuidRepresentation(getDB().getMongoClient().getMongoClientOptions().getUuidRepresentation());
     }
 
     private <T> T convertOptionsToType(final DBObject options, final String field, final Class<T> clazz) {
diff --git a/driver-legacy/src/main/com/mongodb/GroupCommand.java b/driver-legacy/src/main/com/mongodb/GroupCommand.java
@@ -21,6 +21,7 @@
 import com.mongodb.operation.GroupOperation;
 import org.bson.BsonDocumentWrapper;
 import org.bson.BsonJavaScript;
+import org.bson.codecs.Codec;
 
 import static com.mongodb.assertions.Assertions.notNull;
 
@@ -149,7 +150,7 @@ public DBObject toDBObject() {
         return new BasicDBObject("group", args);
     }
 
-    GroupOperation<DBObject> toOperation(final MongoNamespace namespace, final DBObjectCodec codec, final boolean retryReads) {
+    GroupOperation<DBObject> toOperation(final MongoNamespace namespace, final Codec<DBObject> codec, final boolean retryReads) {
         if (initial == null) {
             throw new IllegalArgumentException("Group command requires an initial document for the aggregate result");
         }
diff --git a/driver-legacy/src/test/functional/com/mongodb/DBCollectionSpecification.groovy b/driver-legacy/src/test/functional/com/mongodb/DBCollectionSpecification.groovy
diff --git a/driver-legacy/src/test/unit/com/mongodb/DBSpecification.groovy b/driver-legacy/src/test/unit/com/mongodb/DBSpecification.groovy

Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ Object readValue(final BsonBinaryReader reader) {`
`177`	`177`	`case BINARY:`
`178`	`178`	`byte binarySubType = reader.peekBinarySubType();`
`179`	`179`	`if (BsonBinarySubType.isUuid(binarySubType) && reader.peekBinarySize() == 16) {`
`180`		`- return new UuidCodec().decode(reader, DecoderContext.builder().build());`
	`180`	`+ return new UuidCodec(UuidRepresentation.JAVA_LEGACY).decode(reader, DecoderContext.builder().build());`
`181`	`181`	`}`
`182`	`182`	`BsonBinary binary = reader.readBinaryData();`
`183`	`183`	`if (binarySubType == BINARY.getValue() \|\| binarySubType == OLD_BINARY.getValue()) {`
Original file line number	Diff line number	Diff line change
`@@ -2447,10 +2447,11 @@ private List<com.mongodb.bulk.WriteRequest> translateWriteRequestsToNew(final Li`
`2447`	`2447`	`return retVal;`
`2448`	`2448`	`}`
`2449`	`2449`
`2450`		`- DBObjectCodec getDefaultDBObjectCodec() {`
`2451`		`- return new DBObjectCodec(MongoClient.getDefaultCodecRegistry(),`
	`2450`	`+ Codec<DBObject> getDefaultDBObjectCodec() {`
	`2451`	`+ return new DBObjectCodec(getDB().getMongoClient().getCodecRegistry(),`
`2452`	`2452`	`DBObjectCodec.getDefaultBsonTypeClassMap(),`
`2453`		`- getObjectFactory());`
	`2453`	`+ getObjectFactory())`
	`2454`	`+ .withUuidRepresentation(getDB().getMongoClient().getMongoClientOptions().getUuidRepresentation());`
`2454`	`2455`	`}`
`2455`	`2456`
`2456`	`2457`	`private <T> T convertOptionsToType(final DBObject options, final String field, final Class<T> clazz) {`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`import com.mongodb.operation.GroupOperation;`
`22`	`22`	`import org.bson.BsonDocumentWrapper;`
`23`	`23`	`import org.bson.BsonJavaScript;`
	`24`	`+import org.bson.codecs.Codec;`
`24`	`25`
`25`	`26`	`import static com.mongodb.assertions.Assertions.notNull;`
`26`	`27`
`@@ -149,7 +150,7 @@ public DBObject toDBObject() {`
`149`	`150`	`return new BasicDBObject("group", args);`
`150`	`151`	`}`
`151`	`152`
`152`		`- GroupOperation<DBObject> toOperation(final MongoNamespace namespace, final DBObjectCodec codec, final boolean retryReads) {`
	`153`	`+ GroupOperation<DBObject> toOperation(final MongoNamespace namespace, final Codec<DBObject> codec, final boolean retryReads) {`
`153`	`154`	`if (initial == null) {`
`154`	`155`	`throw new IllegalArgumentException("Group command requires an initial document for the aggregate result");`
`155`	`156`	`}`