Support for custom container types

While PojoCodec accounts for generic containers, it only
accounts for it when the PojoCodec is the one that encodes
and decodes it.

This doesn't work if you want to use Java 8 Optionals, or
other containers classes you don't have source code access to,
and can't be automatically serialized/deserialized.

To make this possible I introduced 4 changes to the public API:
- `TypeWithTypeParameters`: This is an interface that `TypeData` now
  implements that exposes the captured type parameter data. The intention
  here was to reduce the surface area of the API exposed since TypeData
  has quite a bit going on, and I don't think we want to commit to such
  an API.
- `PropertyCodecRegistry`: This is a new interface that's analogous to
  `CodecRegistry`, except instead of accepting a `Class<T>`, it accepts
  a `TypeWithTypeParameters<T>`. This is strictly for consumption by
  clients of the API - there is no expectation clients would implement
  it since it's provided through the property codec provider.
- `PropertyCodecProvider`: Similar to above, this is anologous to
  `CodecProvider` except that it accepts a `TypeWithTypeParameters<T>` and
  a `PropertyCodecRegistry`. This is the primary interface that's
  implemented to support implementing custom containers like collections,
  maps, options, etc.
- `PojoCodecProvider.Builder#register(PropertyCodecProvider...)`:
  How clients register the providers. Note that they cannot register a
  registry - this isn't as permissive as codec providers so it's
  intentionally constrained here.

Internally I shifted the implementation of enums, maps and collections to use
this new setup as well. You can see `CollectionPropertyCodecProvider`
and `MapPropertyCodecProvider` for how this looks - they're just
implicitly added to the same registration list clients use (see
`PojoCodecImpl.PropertyCodecRegistryImpl`).

In the tests I implemented `OptionalPropertyCodecProviderForTest` which
is a provider for a custom optional class, which gives an example for
people who would like to do the same, or support Java 8 optionals.

JAVA-2554

Author: jflorencio

bson/src/main/org/bson/codecs/pojo/CollectionCodec.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2017 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.bson.codecs.pojo;
+
+import org.bson.BsonReader;
+import org.bson.BsonType;
+import org.bson.BsonWriter;
+import org.bson.codecs.Codec;
+import org.bson.codecs.DecoderContext;
+import org.bson.codecs.EncoderContext;
+import org.bson.codecs.configuration.CodecConfigurationException;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+
+import static java.lang.String.format;
+
+final class CollectionPropertyCodecProvider implements PropertyCodecProvider {
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Override
+    public <T> Codec<T> get(final TypeWithTypeParameters<T> type, final PropertyCodecRegistry registry) {
+        if (Collection.class.isAssignableFrom(type.getType()) && type.getTypeParameters().size() == 1) {
+            return new CollectionCodec(type.getType(), registry.get(type.getTypeParameters().get(0)));
+        } else {
+            return null;
+        }
+    }
+
+    private static class CollectionCodec<T> implements Codec<Collection<T>> {
+        private final Class<Collection<T>> encoderClass;
+        private final Codec<T> codec;
+
+        CollectionCodec(final Class<Collection<T>> encoderClass, final Codec<T> codec) {
+            this.encoderClass = encoderClass;
+            this.codec = codec;
+        }
+
+        @Override
+        public void encode(final BsonWriter writer, final Collection<T> collection, final EncoderContext encoderContext) {
+            writer.writeStartArray();
+            for (final T value : collection) {
+                codec.encode(writer, value, encoderContext);
+            }
+            writer.writeEndArray();
+        }
+
+        @Override
+        public Collection<T> decode(final BsonReader reader, final DecoderContext context) {
+            Collection<T> collection = getInstance();
+            reader.readStartArray();
+            while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
+                collection.add(codec.decode(reader, context));
+            }
+            reader.readEndArray();
+            return collection;
+        }
+
+        @Override
+        public Class<Collection<T>> getEncoderClass() {
+            return encoderClass;
+        }
+
+        private Collection<T> getInstance() {
+            if (encoderClass.isInterface()) {
+                if (encoderClass.isAssignableFrom(ArrayList.class)) {
+                    return new ArrayList<T>();
+                } else if (encoderClass.isAssignableFrom(HashSet.class)) {
+                    return new HashSet<T>();
+                } else {
+                    throw new CodecConfigurationException(format("Unsupported Collection interface of %s!", encoderClass.getName()));
+                }
+            }
+
+            try {
+                return encoderClass.newInstance();
+            } catch (final Exception e) {
+                throw new CodecConfigurationException(e.getMessage(), e);
+            }
+        }
+    }
+}

bson/src/main/org/bson/codecs/pojo/CollectionPropertyCodecProvider.java

@@ -28,14 +28,16 @@
 class LazyPojoCodec<T> extends PojoCodec<T> {
     private final ClassModel<T> classModel;
     private final CodecRegistry registry;
+    private final PropertyCodecRegistry propertyCodecRegistry;
     private final DiscriminatorLookup discriminatorLookup;
     private final ConcurrentMap<ClassModel<?>, Codec<?>> codecCache;
     private volatile PojoCodecImpl<T> pojoCodec;
 
-    LazyPojoCodec(final ClassModel<T> classModel, final CodecRegistry registry, final DiscriminatorLookup discriminatorLookup,
-                  final ConcurrentMap<ClassModel<?>, Codec<?>> codecCache) {
+    LazyPojoCodec(final ClassModel<T> classModel, final CodecRegistry registry, final PropertyCodecRegistry propertyCodecRegistry,
+                  final DiscriminatorLookup discriminatorLookup, final ConcurrentMap<ClassModel<?>, Codec<?>> codecCache) {
         this.classModel = classModel;
         this.registry = registry;
+        this.propertyCodecRegistry = propertyCodecRegistry;
         this.discriminatorLookup = discriminatorLookup;
         this.codecCache = codecCache;
     }
@@ -57,7 +59,7 @@ public T decode(final BsonReader reader, final DecoderContext decoderContext) {
 
     private Codec<T> getPojoCodec() {
         if (pojoCodec == null) {
-            pojoCodec = new PojoCodecImpl<T>(classModel, registry, discriminatorLookup, codecCache, true);
+            pojoCodec = new PojoCodecImpl<T>(classModel, registry, null, propertyCodecRegistry, discriminatorLookup, codecCache, true);
         }
         return pojoCodec;
     }

bson/src/main/org/bson/codecs/pojo/LazyPojoCodec.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2017 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.bson.codecs.pojo;
+
+import org.bson.BsonReader;
+import org.bson.BsonType;
+import org.bson.BsonWriter;
+import org.bson.codecs.Codec;
+import org.bson.codecs.DecoderContext;
+import org.bson.codecs.EncoderContext;
+import org.bson.codecs.configuration.CodecConfigurationException;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+final class MapPropertyCodecProvider implements PropertyCodecProvider {
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Override
+    public <T> Codec<T> get(final TypeWithTypeParameters<T> type, final PropertyCodecRegistry registry) {
+        if (Map.class.isAssignableFrom(type.getType()) && type.getTypeParameters().size() == 2) {
+            return new MapCodec(type.getType(), registry.get(type.getTypeParameters().get(1)));
+        } else {
+            return null;
+        }
+    }
+
+    private static class MapCodec<T> implements Codec<Map<String, T>> {
+        private final Class<Map<String, T>> encoderClass;
+        private final Codec<T> codec;
+
+        MapCodec(final Class<Map<String, T>> encoderClass, final Codec<T> codec) {
+            this.encoderClass = encoderClass;
+            this.codec = codec;
+        }
+
+        @Override
+        public void encode(final BsonWriter writer, final Map<String, T> map, final EncoderContext encoderContext) {
+            writer.writeStartDocument();
+            for (final Entry<String, T> entry : map.entrySet()) {
+                writer.writeName(entry.getKey());
+                codec.encode(writer, entry.getValue(), encoderContext);
+            }
+            writer.writeEndDocument();
+        }
+
+        @Override
+        public Map<String, T> decode(final BsonReader reader, final DecoderContext context) {
+            reader.readStartDocument();
+            Map<String, T> map = getInstance();
+            while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
+                map.put(reader.readName(), codec.decode(reader, context));
+            }
+            reader.readEndDocument();
+            return map;
+        }
+
+        @Override
+        public Class<Map<String, T>> getEncoderClass() {
+            return encoderClass;
+        }
+
+        private Map<String, T> getInstance() {
+            if (encoderClass.isInterface()) {
+                return new HashMap<String, T>();
+            }
+            try {
+                return encoderClass.newInstance();
+            } catch (final Exception e) {
+                throw new CodecConfigurationException(e.getMessage(), e);
+            }
+        }
+    }
+}