// constructors
 /// <summary>
 /// Initializes a new instance of the BsonSerializationInfo class.
 /// </summary>
 /// <param name="elementName">The element name.</param>
 /// <param name="serializer">The serializer.</param>
 /// <param name="nominalType">The nominal type.</param>
 /// <param name="serializationOptions">The serialization options.</param>
 public BsonSerializationInfo(string elementName, IBsonSerializer serializer, Type nominalType, IBsonSerializationOptions serializationOptions)
 {
     _elementName = elementName;
     _serializer = serializer;
     _nominalType = nominalType;
     _serializationOptions = serializationOptions;
 }

 protected BaseBsonSerializer(Type documentType, IBsonSerializer serializer, IMongoDbProvider mongoDbProvider, IIdentifierFinder identifierFinder)
 {
     IdentifierFinder = identifierFinder;
     DocumentType = documentType;
     Serializer = serializer;
     MongoDbProvider = mongoDbProvider;
 }

 public BsonMigrationSerializer(IBsonSerializer versionSerializer, IVersionDetectionStrategy versionDetectionStrategy, BsonClassMap classMap)
     : base(classMap)
 {
     _versionSerializer = versionSerializer;
     _versionDetectionStrategy = versionDetectionStrategy;
     _migrations = ExtractMigrations(classMap.ClassType);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="InsertRequest" /> class.
 /// </summary>
 /// <param name="nominalType">Type nominal type.</param>
 /// <param name="document">The document.</param>
 /// <param name="serializer">The serializer.</param>
 public InsertRequest(Type nominalType, object document, IBsonSerializer serializer)
     : base(WriteRequestType.Insert)
 {
     _nominalType = nominalType;
     _document = document;
     _serializer = serializer;
 }

 public FieldExpression(Expression document, string fieldName, IBsonSerializer serializer, Expression original)
 {
     _document = document;
     _fieldName = Ensure.IsNotNull(fieldName, nameof(fieldName));
     _serializer = Ensure.IsNotNull(serializer, nameof(serializer));
     _original = original;
 }

        // protected methods
        /// <summary>
        /// Reconfigures the specified serializer by applying this attribute to it.
        /// </summary>
        /// <param name="serializer">The serializer.</param>
        /// <returns>A reconfigured serializer.</returns>
        protected override IBsonSerializer Apply(IBsonSerializer serializer)
        {
            var representationConfigurable = serializer as IRepresentationConfigurable;
            if (representationConfigurable != null)
            {
                var reconfiguredSerializer = representationConfigurable.WithRepresentation(_representation);

                var converterConfigurable = reconfiguredSerializer as IRepresentationConverterConfigurable;
                if (converterConfigurable != null)
                {
                    var converter = new RepresentationConverter(_allowOverflow, _allowTruncation);
                    reconfiguredSerializer = converterConfigurable.WithConverter(converter);
                }

                return reconfiguredSerializer;
            }

            // for backward compatibility representations of Array and Document are mapped to DictionaryRepresentations if possible
            var dictionaryRepresentationConfigurable = serializer as IDictionaryRepresentationConfigurable;
            if (dictionaryRepresentationConfigurable != null)
            {
                if (_representation == BsonType.Array || _representation == BsonType.Document)
                {
                    var dictionaryRepresentation = (_representation == BsonType.Array) ? DictionaryRepresentation.ArrayOfArrays: DictionaryRepresentation.Document;
                    return dictionaryRepresentationConfigurable.WithDictionaryRepresentation(dictionaryRepresentation);
                }
            }

            return base.Apply(serializer);
        }

 public ArrayIndexExpression(Expression array, Expression index, IBsonSerializer serializer, Expression original)
 {
     _array = Ensure.IsNotNull(array, nameof(array));
     _index = Ensure.IsNotNull(index, nameof(index));
     _serializer = Ensure.IsNotNull(serializer, nameof(serializer));
     _original = original;
 }

 /// <summary>
 /// Registers a serializer with the given expression.
 /// </summary>
 /// <param name="node">The expression.</param>
 /// <param name="serializer">The serializer.</param>
 public void RegisterExpressionSerializer(Expression node, IBsonSerializer serializer)
 {
     _serializationInfoCache[node] = new BsonSerializationInfo(
         null,
         serializer,
         node.Type);
 }

        // public methods
        /// <summary>
        /// Apply an attribute to these serialization options and modify the options accordingly.
        /// </summary>
        /// <param name="serializer">The serializer that these serialization options are for.</param>
        /// <param name="attribute">The serialization options attribute.</param>
        public override void ApplyAttribute(IBsonSerializer serializer, Attribute attribute)
        {
            EnsureNotFrozen();
            var itemSerializer = serializer.GetItemSerializationInfo().Serializer;
            if (_itemSerializationOptions == null)
            {
                var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();

                // special case for legacy collections: allow BsonRepresentation on object
                if (itemDefaultSerializationOptions == null &&
                    (serializer.GetType() == typeof(EnumerableSerializer) || serializer.GetType() == typeof(QueueSerializer) || serializer.GetType() == typeof(StackSerializer)) &&
                    attribute.GetType() == typeof(BsonRepresentationAttribute))
                {
                    itemDefaultSerializationOptions = new RepresentationSerializationOptions(BsonType.Null); // will be modified later by ApplyAttribute
                }

                if (itemDefaultSerializationOptions == null)
                {
                    var message = string.Format(
                        "A serialization options attribute of type {0} cannot be used when the serializer is of type {1} and the item serializer is of type {2}.",
                        BsonUtils.GetFriendlyTypeName(attribute.GetType()),
                        BsonUtils.GetFriendlyTypeName(serializer.GetType()),
                        BsonUtils.GetFriendlyTypeName(itemSerializer.GetType()));
                    throw new NotSupportedException(message);
                }

                _itemSerializationOptions = itemDefaultSerializationOptions.Clone();
            }
            _itemSerializationOptions.ApplyAttribute(itemSerializer, attribute);
        }

 public static IBsonSerializer CreateListSerializer(IBsonSerializer itemSerializer)
 {
     var implementationType = typeof(List<>).MakeGenericType(itemSerializer.ValueType);
     return (IBsonSerializer)Activator.CreateInstance(
         typeof(EnumerableInterfaceImplementerSerializer<>).MakeGenericType(
             implementationType),
         itemSerializer);
 }

 /// <summary>
 /// Registers a serializer with the given expression.
 /// </summary>
 /// <param name="node">The expression.</param>
 /// <param name="serializer">The serializer.</param>
 public void RegisterExpressionSerializer(Expression node, IBsonSerializer serializer)
 {
     _serializationInfoCache[node] = new BsonSerializationInfo(
         null,
         serializer,
         node.Type,
         serializer.GetDefaultSerializationOptions());
 }

 public AccumulatorExpression(Type type, string fieldName, IBsonSerializer serializer, AccumulatorType accumulatorType, Expression argument)
 {
     _type = Ensure.IsNotNull(type, nameof(type));
     _fieldName = Ensure.IsNotNull(fieldName, nameof(fieldName));
     _serializer = Ensure.IsNotNull(serializer, nameof(serializer));
     _accumulatorType = accumulatorType;
     _argument = Ensure.IsNotNull(argument, nameof(argument));
 }

        public static bool TryFindSerializer(Expression node, Type type, out IBsonSerializer serializer)
        {
            var finder = new PreviouslyUsedSerializerFinder(type);
            finder.Visit(node);

            serializer = finder._serializer;
            return serializer != null;
        }

        public AggregateResultOperator(Expression seed, Expression reducer, Expression finalizer, string itemName, IBsonSerializer serializer)
        {
            _seed = Ensure.IsNotNull(seed, nameof(seed));
            _reducer = Ensure.IsNotNull(reducer, nameof(reducer));
            _serializer = Ensure.IsNotNull(serializer, nameof(serializer));

            _finalizer = finalizer;
            _itemName = itemName;
        }

        private IBsonSerializer ConfigureChildSerializer(IChildSerializerConfigurable configurable, IBsonSerializer childSerializer)
        {
            var childConfigurable = configurable.ChildSerializer as IChildSerializerConfigurable;
            if (childConfigurable != null)
            {
                childSerializer = ConfigureChildSerializer(childConfigurable, childSerializer);
            }

            return configurable.WithChildSerializer(childSerializer);
        }

        // protected methods
        /// <summary>
        /// Reconfigures the specified serializer by applying this attribute to it.
        /// </summary>
        /// <param name="serializer">The serializer.</param>
        /// <returns>A reconfigured serializer.</returns>
        protected override IBsonSerializer Apply(IBsonSerializer serializer)
        {
            var dictionaryRepresentationConfigurable = serializer as IDictionaryRepresentationConfigurable;
            if (dictionaryRepresentationConfigurable != null)
            {
                return dictionaryRepresentationConfigurable.WithDictionaryRepresentation(_representation);
            }

            return base.Apply(serializer);
        }

        // protected methods
        /// <summary>
        /// Reconfigures the specified serializer by applying this attribute to it.
        /// </summary>
        /// <param name="serializer">The serializer.</param>
        /// <returns>A reconfigured serializer.</returns>
        protected override IBsonSerializer Apply(IBsonSerializer serializer)
        {
            var timeSpanSerializer = serializer as TimeSpanSerializer;
            if (timeSpanSerializer != null)
            {
                return timeSpanSerializer.WithRepresentation(_representation, _units);
            }

            return base.Apply(serializer);
        }

        public static IBsonSerializer RecursiveConfigureChildSerializer(IChildSerializerConfigurable configurable, IBsonSerializer childSerializer)
        {
            var childConfigurable = configurable.ChildSerializer as IChildSerializerConfigurable;
            if (childConfigurable != null)
            {
                childSerializer = RecursiveConfigureChildSerializer(childConfigurable, childSerializer);
            }

            return configurable.WithChildSerializer(childSerializer);
        }

        public static IBsonSerializer CreateEnumerableSerializer(IBsonSerializer itemSerializer)
        {
            var listSerializer = CreateListSerializer(itemSerializer);

            return (IBsonSerializer)Activator.CreateInstance(
                typeof(ImpliedImplementationInterfaceSerializer<,>).MakeGenericType(
                    typeof(IEnumerable<>).MakeGenericType(itemSerializer.ValueType),
                    listSerializer.ValueType),
                listSerializer);
        }

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