// public methods
        /// <summary>
        /// Gets the actual type of an object by reading the discriminator from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The reader.</param>
        /// <param name="nominalType">The nominal type.</param>
        /// <returns>The actual type.</returns>
        public Type GetActualType(IBsonReader bsonReader, Type nominalType)
        {
            // the BsonReader is sitting at the value whose actual type needs to be found
            var bsonType = bsonReader.GetCurrentBsonType();
            if (bsonType == BsonType.Document)
            {
                // ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)
                BsonSerializer.EnsureKnownTypesAreRegistered(nominalType);

                // we can skip looking for a discriminator if nominalType has no discriminated sub types
                if (BsonSerializer.IsTypeDiscriminated(nominalType))
                {
                    var bookmark = bsonReader.GetBookmark();
                    bsonReader.ReadStartDocument();
                    var actualType = nominalType;
                    if (bsonReader.FindElement(_elementName))
                    {
                        var context = BsonDeserializationContext.CreateRoot(bsonReader);
                        var discriminator = BsonValueSerializer.Instance.Deserialize(context);
                        if (discriminator.IsBsonArray)
                        {
                            discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator
                        }
                        actualType = BsonSerializer.LookupActualType(nominalType, discriminator);
                    }
                    bsonReader.ReturnToBookmark(bookmark);
                    return actualType;
                }
            }

            return nominalType;
        }

        public Type GetActualType(IBsonReader bsonReader, Type nominalType)
        {
            if (nominalType == typeof(JobTask))
            {
                var ret = nominalType;

                var bookmark = bsonReader.GetBookmark();
                bsonReader.ReadStartDocument();
                if (bsonReader.FindElement(ElementName))
                {
                    var value = bsonReader.ReadString();

                    ret = Type.GetType(value);

                    if (ret == null)
                        throw new Exception("Could not find type " + value);

                    if (!ret.IsSubclassOf(typeof(JobTask)))
                        throw new Exception("Database type does not inherit from JobTask.");
                }

                bsonReader.ReturnToBookmark(bookmark);

                return ret;
            }
            else
            {
                return nominalType;
            }
        }

        // public methods
        /// <summary>
        /// Gets the actual type of an object by reading the discriminator from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The reader.</param>
        /// <param name="nominalType">The nominal type.</param>
        /// <returns>The actual type.</returns>
        public Type GetActualType(IBsonReader bsonReader, Type nominalType)
        {
            // the BsonReader is sitting at the value whose actual type needs to be found
            var bsonType = bsonReader.GetCurrentBsonType();
            if (bsonReader.State == BsonReaderState.Value)
            {
                Type primitiveType = null;
                switch (bsonType)
                {
                    case BsonType.Boolean: primitiveType = typeof(bool); break;
                    case BsonType.Binary:
                        var bookmark = bsonReader.GetBookmark();
                        var binaryData = bsonReader.ReadBinaryData();
                        var subType = binaryData.SubType;
                        if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy)
                        {
                            primitiveType = typeof(Guid);
                        }
                        bsonReader.ReturnToBookmark(bookmark);
                        break;
                    case BsonType.DateTime: primitiveType = typeof(DateTime); break;
                    case BsonType.Decimal128: primitiveType = typeof(Decimal128); break;
                    case BsonType.Double: primitiveType = typeof(double); break;
                    case BsonType.Int32: primitiveType = typeof(int); break;
                    case BsonType.Int64: primitiveType = typeof(long); break;
                    case BsonType.ObjectId: primitiveType = typeof(ObjectId); break;
                    case BsonType.String: primitiveType = typeof(string); break;
                }

                // Type.IsAssignableFrom is extremely expensive, always perform a direct type check before calling Type.IsAssignableFrom
                if (primitiveType != null && (primitiveType == nominalType || nominalType.GetTypeInfo().IsAssignableFrom(primitiveType)))
                {
                    return primitiveType;
                }
            }

            if (bsonType == BsonType.Document)
            {
                var bookmark = bsonReader.GetBookmark();
                bsonReader.ReadStartDocument();
                var actualType = nominalType;
                if (bsonReader.FindElement(_elementName))
                {
                    var context = BsonDeserializationContext.CreateRoot(bsonReader);
                    var discriminator = BsonValueSerializer.Instance.Deserialize(context);
                    if (discriminator.IsBsonArray)
                    {
                        discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator
                    }
                    actualType = BsonSerializer.LookupActualType(nominalType, discriminator);
                }
                bsonReader.ReturnToBookmark(bookmark);
                return actualType;
            }

            return nominalType;
        }

 // constructors
 private BsonDeserializationContext(
     IBsonReader reader,
     bool allowDuplicateElementNames,
     IBsonSerializer dynamicArraySerializer,
     IBsonSerializer dynamicDocumentSerializer)
 {
     _reader = reader;
     _allowDuplicateElementNames = allowDuplicateElementNames;
     _dynamicArraySerializer = dynamicArraySerializer;
     _dynamicDocumentSerializer = dynamicDocumentSerializer;
 }

        public Type GetActualType(IBsonReader bsonReader, Type nominalType)
        {
            var bookmark = bsonReader.GetBookmark();
            bsonReader.ReadStartDocument();
            string typeValue = string.Empty;
            if (bsonReader.FindElement(ElementName))
                typeValue = bsonReader.ReadString();
            else
                throw new NotSupportedException();

            bsonReader.ReturnToBookmark(bookmark);
            var retr = Type.GetType(typeValue) ?? Type.GetType("ThreeOneThree.Proxima.Core.Entities." + typeValue);
            return retr;
        }

 public Type GetActualType(IBsonReader bsonReader, Type nominalType)
 {
     var bookmark = bsonReader.GetBookmark();
     bsonReader.ReadStartDocument();
     var actualType = nominalType;
     while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
     {
         var name = bsonReader.ReadName();
         if (name == "OnlyInB")
         {
             actualType = typeof(B);
             break;
         }
         else if (name == "OnlyInC")
         {
             actualType = typeof(C);
             break;
         }
         bsonReader.SkipValue();
     }
     bsonReader.ReturnToBookmark(bookmark);
     return actualType;
 }

 private RawBsonDocument DeserializeRawBsonDocument(IBsonReader bsonReader)
 {
     var slice = bsonReader.ReadRawBsonDocument();
     var nestedDocument = new RawBsonDocument(slice);
     _disposableItems.Add(nestedDocument);
     return nestedDocument;
 }

 private static void VerifyName(IBsonReader reader, string expectedName)
 {
     var actualName = reader.ReadName();
     if (actualName != expectedName)
     {
         var message = string.Format(
             "Expected element name to be '{0}', not '{1}'.",
             expectedName, actualName);
         throw new FormatException(message);
     }
 }

 // constructors
 public JsonReaderAdapter(IBsonReader wrappedReader)
 {
     _wrappedReader = wrappedReader;
 }

 private RawBsonArray DeserializeRawBsonArray(IBsonReader bsonReader)
 {
     var slice = bsonReader.ReadRawBsonArray();
     var nestedArray = new RawBsonArray(slice);
     _disposableItems.Add(nestedArray);
     return nestedArray;
 }

 public void TestArrayEmpty()
 {
     var json = "[]";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.Array, _bsonReader.ReadBsonType());
         _bsonReader.ReadStartArray();
         Assert.Equal(BsonType.EndOfDocument, _bsonReader.ReadBsonType());
         _bsonReader.ReadEndArray();
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<BsonArray>(json).ToJson());
 }

 public void TestStringEmpty()
 {
     var json = "\"\"";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.String, _bsonReader.ReadBsonType());
         Assert.Equal("", _bsonReader.ReadString());
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<string>(json).ToJson());
 }

 public void TestSymbol()
 {
     var json = "{ \"$symbol\" : \"symbol\" }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.Symbol, _bsonReader.ReadBsonType());
         Assert.Equal("symbol", _bsonReader.ReadSymbol());
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<BsonSymbol>(json).ToJson());
 }

 public void TestInt64ExtendedJson()
 {
     var json = "{ \"$numberLong\" : \"123\" }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.Int64, _bsonReader.ReadBsonType());
         Assert.Equal(123, _bsonReader.ReadInt64());
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     var canonicalJson = "NumberLong(123)";
     Assert.Equal(canonicalJson, BsonSerializer.Deserialize<long>(new StringReader(json)).ToJson());
 }

 public void TestRegularExpressionStrict()
 {
     var json = "{ \"$regex\" : \"pattern\", \"$options\" : \"imxs\" }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.RegularExpression, _bsonReader.ReadBsonType());
         var regex = _bsonReader.ReadRegularExpression();
         Assert.Equal("pattern", regex.Pattern);
         Assert.Equal("imxs", regex.Options);
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     Assert.Equal(json, BsonSerializer.Deserialize<BsonRegularExpression>(json).ToJson(settings));
 }

 public void TestHexData()
 {
     var expectedBytes = new byte[] { 0x01, 0x23 };
     var json = "HexData(0, \"123\")";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.Binary, _bsonReader.ReadBsonType());
         var bytes = _bsonReader.ReadBytes();
         Assert.True(expectedBytes.SequenceEqual(bytes));
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     var expectedJson = "new BinData(0, \"ASM=\")";
     Assert.Equal(expectedJson, BsonSerializer.Deserialize<byte[]>(json).ToJson());
 }

 public void TestNestedDocument()
 {
     var json = "{ \"a\" : { \"b\" : 1, \"c\" : 2 } }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.Document, _bsonReader.ReadBsonType());
         _bsonReader.ReadStartDocument();
         Assert.Equal(BsonType.Document, _bsonReader.ReadBsonType());
         Assert.Equal("a", _bsonReader.ReadName());
         _bsonReader.ReadStartDocument();
         Assert.Equal("b", _bsonReader.ReadName());
         Assert.Equal(1, _bsonReader.ReadInt32());
         Assert.Equal("c", _bsonReader.ReadName());
         Assert.Equal(2, _bsonReader.ReadInt32());
         _bsonReader.ReadEndDocument();
         _bsonReader.ReadEndDocument();
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<BsonDocument>(json).ToJson());
 }

 public void TestMinKeyExtendedJsonWithCapitalK()
 {
     var json = "{ \"$minKey\" : 1 }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.MinKey, _bsonReader.ReadBsonType());
         _bsonReader.ReadMinKey();
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     var canonicalJson = "MinKey";
     Assert.Equal(canonicalJson, BsonSerializer.Deserialize<BsonMinKey>(new StringReader(json)).ToJson());
 }

 public void TestMinKeyKeyword()
 {
     var json = "MinKey";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.MinKey, _bsonReader.ReadBsonType());
         _bsonReader.ReadMinKey();
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<BsonMinKey>(new StringReader(json)).ToJson());
 }

 public void TestJavaScriptWithScope()
 {
     string json = "{ \"$code\" : \"function f() { return n; }\", \"$scope\" : { \"n\" : 1 } }";
     using (_bsonReader = new JsonReader(json))
     {
         Assert.Equal(BsonType.JavaScriptWithScope, _bsonReader.ReadBsonType());
         Assert.Equal("function f() { return n; }", _bsonReader.ReadJavaScriptWithScope());
         _bsonReader.ReadStartDocument();
         Assert.Equal(BsonType.Int32, _bsonReader.ReadBsonType());
         Assert.Equal("n", _bsonReader.ReadName());
         Assert.Equal(1, _bsonReader.ReadInt32());
         _bsonReader.ReadEndDocument();
         Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
     }
     Assert.Equal(json, BsonSerializer.Deserialize<BsonJavaScriptWithScope>(json).ToJson());
 }