public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, SeatType value)
{
context.Writer.WriteInt32((int)value.Type);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Guid value) => context.Writer.WriteString(value.ToString());
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
{
var bsonWriter = context.Writer;
if (value == null)
{
bsonWriter.WriteNull();
}
else
{
var actualType = value.GetType();
if (actualType == typeof(object))
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteEndDocument();
}
else
{
// certain types can be written directly as BSON value
// if we're not at the top level document, or if we're using the JsonWriter
if (bsonWriter.State == BsonWriterState.Value || bsonWriter is JsonWriter)
{
switch (Type.GetTypeCode(actualType))
{
case TypeCode.Boolean:
bsonWriter.WriteBoolean((bool)value);
return;
case TypeCode.DateTime:
// TODO: is this right? will lose precision after round trip
var bsonDateTime = new BsonDateTime(BsonUtils.ToUniversalTime((DateTime)value));
bsonWriter.WriteDateTime(bsonDateTime.MillisecondsSinceEpoch);
return;
case TypeCode.Double:
bsonWriter.WriteDouble((double)value);
return;
case TypeCode.Int16:
// TODO: is this right? will change type to Int32 after round trip
bsonWriter.WriteInt32((short)value);
return;
case TypeCode.Int32:
bsonWriter.WriteInt32((int)value);
return;
case TypeCode.Int64:
bsonWriter.WriteInt64((long)value);
return;
case TypeCode.Object:
if (actualType == typeof(Decimal128))
{
var decimal128 = (Decimal128)value;
bsonWriter.WriteDecimal128(decimal128);
return;
}
if (actualType == typeof(Guid))
{
var guid = (Guid)value;
var guidRepresentation = bsonWriter.Settings.GuidRepresentation;
var binaryData = new BsonBinaryData(guid, guidRepresentation);
bsonWriter.WriteBinaryData(binaryData);
return;
}
if (actualType == typeof(ObjectId))
{
bsonWriter.WriteObjectId((ObjectId)value);
return;
}
break;
case TypeCode.String:
bsonWriter.WriteString((string)value);
return;
}
}
SerializeDiscriminatedValue(context, args, value, actualType);
}
}
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, GeoHaystackSearchOptionsBuilder value)
{
BsonDocumentSerializer.Instance.Serialize(context, value._document);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteNull();
}
protected override void BeginProcessing()
{
FileFormat = ResolveFileFormat(FileFormat, Path);
Path = GetUnresolvedProviderPathFromPSPath(Path);
var time = Stopwatch.StartNew();
for (; ;)
{
try
{
if (FileFormat == FileFormat.Bson)
{
FileStream fileStream = null;
try
{
fileStream = File.Open(Path, (Append ? FileMode.Append : FileMode.Create));
_bsonWriter = new BsonBinaryWriter(fileStream);
}
finally
{
_dispose = () =>
{
fileStream?.Dispose();
};
}
}
else
{
StreamWriter streamWriter = null;
try
{
var settings = JsonWriterSettings.Defaults;
switch (FileFormat)
{
case FileFormat.JsonShell:
settings = settings.Clone();
settings.OutputMode = JsonOutputMode.Shell;
break;
case FileFormat.JsonStrict:
settings = settings.Clone();
#pragma warning disable 618 // obsolete JsonOutputMode.Strict
settings.OutputMode = JsonOutputMode.Strict;
#pragma warning restore 618
break;
case FileFormat.JsonCanonicalExtended:
settings = settings.Clone();
settings.OutputMode = JsonOutputMode.CanonicalExtendedJson;
break;
case FileFormat.JsonRelaxedExtended:
settings = settings.Clone();
settings.OutputMode = JsonOutputMode.RelaxedExtendedJson;
break;
}
streamWriter = new StreamWriter(Path, Append);
_bsonWriter = new JsonWriter(streamWriter, settings);
_endDocument = () =>
{
streamWriter.WriteLine();
};
}
finally
{
_dispose = () =>
{
streamWriter?.Dispose();
};
}
}
_context = BsonSerializationContext.CreateRoot(_bsonWriter);
break;
}
catch (IOException)
{
if (Retry == null || time.Elapsed > Retry[0])
{
throw;
}
if (Retry.Length < 2)
{
Thread.Sleep(50);
}
else
{
Thread.Sleep(Retry[1]);
}
WriteVerbose("Retrying to write...");
}
}
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Dictionary value)
{
BsonDocumentSerializer.Instance.Serialize(context, args, value.ToBsonDocument());
}
private void WriteQuery(BsonBinaryWriter binaryWriter, BsonDocument query)
{
var context = BsonSerializationContext.CreateRoot <BsonDocument>(binaryWriter);
BsonDocumentSerializer.Instance.Serialize(context, query);
}
private void SerializeDerivedMembers(BsonSerializationContext context, GeoJsonFeature <TCoordinates> value)
{
SerializeGeometry(context, value.Geometry);
SerializeId(context, value.Id);
SerializeProperties(context, value.Properties);
}
public void Serialize(BsonSerializationContext context, BsonSerializationArgs args, ICollection <TEntity> value)
{
Serialize(context, args, (object)value);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args,
Signature value) => context.Writer.WriteString(value?.ToString() ?? string.Empty);
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Instant value)
{
context.Writer.WriteDateTime(value.Ticks / NodaConstants.TicksPerMillisecond);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, DateTime value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteString(value.ToString("yyyy-MM-dd", DateTimeFormatInfo.InvariantInfo));
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, GeoNearResult <TDocument> value)
{
_serializer.Serialize(context, value);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, GroupByBuilder value)
{
BsonDocumentSerializer.Instance.Serialize(context, value._document);
}
private void SerializeGeometry(BsonSerializationContext context, GeoJsonGeometry <TCoordinates> geometry)
{
context.Writer.WriteName("geometry");
context.SerializeWithChildContext(_geometrySerializer, geometry);
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The object.</param>
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, BsonBoolean value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteBoolean(value.Value);
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="value">The value.</param>
protected override void SerializeValue(BsonSerializationContext context, GeoJsonFeature <TCoordinates> value)
{
_helper.SerializeMembers(context, value, SerializeDerivedMembers);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Collection value)
{
BsonArraySerializer.Instance.Serialize(context, args, value.ToBsonArray());
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The object.</param>
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, RawBsonArray value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteRawBsonArray(value.Slice);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, IndexKeysWrapper value)
{
value.SerializeWrappedObject(context);
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, CollectionOptionsWrapper value)
{
value.SerializeWrappedObject(context);
}
/*******************************************/
/**** Public Methods ****/
/*******************************************/
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Type value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteStartDocument();
var discriminator = m_DiscriminatorConvention.GetDiscriminator(typeof(object), typeof(Type));
bsonWriter.WriteName(m_DiscriminatorConvention.ElementName);
BsonValueSerializer.Instance.Serialize(context, discriminator);
if (value == null)
{
//Using context.Writer.WriteNull() leads to problem in the deserialisation.
//We think that BSON think that the types will always be types to be deserialised rather than properties of objects.
//If that type is null bson throws an exception believing that it wont be able to deserialise an object of type null, while for this case it is ment to be used as a property.
bsonWriter.WriteName("Name");
bsonWriter.WriteString("");
}
else
{
// Handle the case of generic types
Type[] generics = new Type[] { };
if (value.IsGenericType)
{
generics = value.GetGenericArguments();
value = value.GetGenericTypeDefinition();
}
// Write the name of the type
bsonWriter.WriteName("Name");
if (value.IsGenericParameter)
{
bsonWriter.WriteString("T");
Type[] constraints = value.GetGenericParameterConstraints();
if (constraints.Length > 0)
{
bsonWriter.WriteName("Constraints");
bsonWriter.WriteStartArray();
foreach (Type constraint in constraints)
{
BsonSerializer.Serialize(bsonWriter, constraint);
}
bsonWriter.WriteEndArray();
}
}
else if (value.Namespace.StartsWith("BH.oM"))
{
bsonWriter.WriteString(value.FullName);
}
else if (value.AssemblyQualifiedName != null)
{
bsonWriter.WriteString(value.AssemblyQualifiedName);
}
else
{
bsonWriter.WriteString(""); //TODO: is that even possible?
}
// Add additional information for generic types
if (generics.Length > 0)
{
bsonWriter.WriteName("GenericArguments");
bsonWriter.WriteStartArray();
foreach (Type arg in generics)
{
BsonSerializer.Serialize(bsonWriter, arg);
}
bsonWriter.WriteEndArray();
}
}
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Id id)
{
UpdateIdIfNone(id);
context.Writer.WriteObjectId(new ObjectId(id.StringId));
}
public override void Serialize(BsonSerializationContext context, FieldsWrapper value)
{
value.SerializeWrappedObject(context);
}
/// <summary>Null value is handled via [BsonIgnoreIfNull] attribute and is not expected here.</summary>
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, IsoDayOfWeek value)
{
// Extension method AsString() uses three-letter format
context.Writer.WriteString(value.AsString());
}
/***************************************************/
/**** Private Helper Methods ****/
/***************************************************/
private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonSerializationArgs args, object value, Type actualType)
{
if (actualType.Name == "RuntimeMethodInfo" || actualType.Name == "RuntimeConstructorInfo")
{
actualType = typeof(MethodBase);
}
else if (actualType.Name == "RuntimeType")
{
actualType = typeof(Type);
}
else if (value is Enum)
{
actualType = typeof(Enum);
}
if (!BsonClassMap.IsClassMapRegistered(actualType))
{
Compute.RegisterClassMap(actualType);
}
var serializer = BsonSerializer.LookupSerializer(actualType);
if (serializer.GetType().Name == "EnumerableInterfaceImplementerSerializer`2" && context.Writer.State == BsonWriterState.Initial)
{
if (!m_FallbackSerialisers.ContainsKey(actualType))
{
CreateFallbackSerialiser(actualType);
}
serializer = m_FallbackSerialisers[actualType];
}
var polymorphicSerializer = serializer as IBsonPolymorphicSerializer;
if (polymorphicSerializer != null && polymorphicSerializer.IsDiscriminatorCompatibleWithObjectSerializer)
{
serializer.Serialize(context, args, value);
}
else
{
if (context.IsDynamicType != null && context.IsDynamicType(value.GetType()))
{
args.NominalType = actualType;
serializer.Serialize(context, args, value);
}
else
{
var bsonWriter = context.Writer;
if (actualType.Name == "Dictionary`2")
{
Type keyType = actualType.GenericTypeArguments[0];
if (keyType == typeof(string))
{
serializer.Serialize(context, value);
}
else
{
var discriminator = _discriminatorConvention.GetDiscriminator(typeof(object), actualType);
bsonWriter.WriteStartDocument();
bsonWriter.WriteName(_discriminatorConvention.ElementName);
BsonValueSerializer.Instance.Serialize(context, discriminator);
bsonWriter.WriteName("_v");
serializer.Serialize(context, value);
bsonWriter.WriteEndDocument();
}
}
else
{
serializer.Serialize(context, value);
}
}
}
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, decimal value)
{
context.Writer.WriteDouble((double)value);
}
/// <summary>
/// Serializes a value of type {TValue}.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The value.</param>
protected virtual void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, TValue value)
{
throw CreateCannotBeSerializedException();
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The object.</param>
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, BsonDateTime value)
{
var bsonWriter = context.Writer;
bsonWriter.WriteDateTime(value.MillisecondsSinceEpoch);
}
