public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
		{
			if (IsRelationalAssociation(bsonWriter, value))
				RelationSerializer.Instance.Serialize(bsonWriter, nominalType, value, options);
			else
				CustomBsonClassMapSerializer.Instance.Serialize(bsonWriter, nominalType, value, options);
		}

        public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
        {
            IDictionary<string, object> obj = value as IDictionary<string, object>;
            if (obj == null)
            {
                bsonWriter.WriteNull();
                return;
            }

            bsonWriter.WriteStartDocument();
            foreach (var member in obj)
            {
                bsonWriter.WriteName(member.Key);
                object memberValue = member.Value;

                if (memberValue == null)
                {
                    bsonWriter.WriteNull();
                }
                else
                {
                    nominalType = memberValue.GetType();
                    var serializer = BsonSerializer.LookupSerializer(nominalType);
                    serializer.Serialize(bsonWriter, nominalType, memberValue, options);
                }
            }
            bsonWriter.WriteEndDocument();
        }

        public override void Serialize(
			BsonWriter bsonWriter,
			Type nominalType,
			object value,
			IBsonSerializationOptions options
			)
        {
            if (value == null)
            {
                bsonWriter.WriteNull();
                return;
            }

            var nvc = (NameValueCollection)value;

            bsonWriter.WriteStartArray();
            foreach (var key in nvc.AllKeys)
            {
                foreach (var val in nvc.GetValues(key))
                {
                    bsonWriter.WriteStartArray();
                    StringSerializer.Instance.Serialize(bsonWriter, typeof(string), key, options);
                    StringSerializer.Instance.Serialize(bsonWriter, typeof(string), val, options);
                    bsonWriter.WriteEndArray();
                }
            }
            bsonWriter.WriteEndArray();
        }

		private static bool IsRelationalAssociation(BsonWriter bsonWriter, object value)
		{
			if (value == null || bsonWriter.State != BsonWriterState.Value)
				return false;

			return IsRelationalType(value.GetType());
		}

		private void WriteBson(BsonWriter writer, Regex regex)
		{
			// Regular expression - The first cstring is the regex pattern, the second
			// is the regex options string. Options are identified by characters, which 
			// must be stored in alphabetical order. Valid options are 'i' for case 
			// insensitive matching, 'm' for multiline matching, 'x' for verbose mode, 
			// 'l' to make \w, \W, etc. locale dependent, 's' for dotall mode 
			// ('.' matches everything), and 'u' to make \w, \W, etc. match unicode.

			string options = null;

			if (HasFlag(regex.Options, RegexOptions.IgnoreCase))
				options += "i";

			if (HasFlag(regex.Options, RegexOptions.Multiline))
				options += "m";

			if (HasFlag(regex.Options, RegexOptions.Singleline))
				options += "s";

			options += "u";

			if (HasFlag(regex.Options, RegexOptions.ExplicitCapture))
				options += "x";

			writer.WriteRegex(regex.ToString(), options);
		}

		public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
		{
			var idPropertyInfo = value.GetType().GetProperty("ID");
			var id = (ObjectId) idPropertyInfo.GetValue(value, null);
			if (id == ObjectId.Empty)
				throw new Exception("Relational associations must be saved before saving the parent relation");
			ObjectIdSerializer.Instance.Serialize(bsonWriter, id.GetType(), id, options);
		}

 void IBsonSerializable.Serialize(
     BsonWriter bsonWriter,
     Type nominalType,
     bool serializeIdFirst
 )
 {
     Serialize(bsonWriter, nominalType, serializeIdFirst);
 }

 protected override void WriteBody(BsonWriter writer)
 {
     writer.WriteValue(BsonDataType.Integer,0);
     writer.WriteString(this.FullCollectionName);
     writer.WriteValue(BsonDataType.Integer,this.Flags);
     writer.Write(selector);
     writer.Write(Document);
 }

 public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
 {
     var c = (C)value;
     bsonWriter.WriteStartDocument();
     bsonWriter.WriteString("nominalType", nominalType.Name);
     bsonWriter.WriteInt32("X", c.X);
     bsonWriter.WriteEndDocument();
 }

 protected override void Serialize(
     BsonWriter bsonWriter,
     Type nominalType,
     bool serializeIdFirst
 )
 {
     document.Serialize(bsonWriter, nominalType, serializeIdFirst);
 }

        public void TestCalculateSizeOfEmptyDoc()
        {
            Document doc = new Document();
            MemoryStream ms = new MemoryStream();
            BsonWriter writer = new BsonWriter(ms);

            Assert.AreEqual(5,writer.CalculateSize(doc));
        }

 public void Serialize(
     BsonWriter bsonWriter,
     Type nominalType, // ignored
     bool serializeIdFirst
 )
 {
     BsonSerializer.Serialize(bsonWriter, this.nominalType, obj, serializeIdFirst); // use wrapped nominalType
 }

 void IBsonSerializable.Serialize(
     BsonWriter bsonWriter,
     Type nominalType,
     IBsonSerializationOptions options
 )
 {
     Serialize(bsonWriter, nominalType, options);
 }

 public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
 {
     int intValue;
     if (value is string && int.TryParse((string)value, out intValue))
         bsonWriter.WriteInt32(intValue);
     else
         throw new InvalidOperationException();
 }

 public void Serialize(
     BsonWriter bsonWriter,
     Type nominalType, // ignored
     IBsonSerializationOptions options
 )
 {
     BsonSerializer.Serialize(bsonWriter, this.nominalType, obj, options); // use wrapped nominalType
 }

 public override void Serialize(
     BsonWriter bsonWriter,
     Type nominalType,
     object value,
     IBsonSerializationOptions options
 ) {
     var dateTime = (DateTime) value;
     bsonWriter.WriteString(dateTime.ToString("yyyy-MM-dd"));
 }

 protected override void WriteBody(Stream stream)
 {
     BsonWriter writer = new BsonWriter(stream);
     writer.Write((int)0);
     writer.Write(this.FullCollectionName);
     writer.Write(this.Upsert);
     selector.Write(writer);
     document.Write(writer);
 }

 public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
 {
     var timeOfDay = (TimeOfDay)value;
     bsonWriter.WriteStartDocument();
     bsonWriter.WriteInt32("Hour", timeOfDay.Hour);
     bsonWriter.WriteInt32("Minute", timeOfDay.Minute);
     bsonWriter.WriteInt32("Second", timeOfDay.Second);
     bsonWriter.WriteEndDocument();
 }

 protected override int CalculateBodySize(BsonWriter writer)
 {
     int size = 4; //first int32
     size += writer.CalculateSize(this.FullCollectionName,false);
     size += 4; //flags
     size += writer.CalculateSize(this.Selector);
     size += writer.CalculateSize(this.Document);
     return size;
 }

 public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
 {
     if (value == null)
     {
         bsonWriter.WriteNull();
     }
     else
     {
         ObjectIdSerializer.Instance.Serialize(bsonWriter, nominalType, IdentifierFinder.GetId(value), options);
     }
 }