/// <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 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);
}
/// <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 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;
}
public override void OneTimeSetUp()
{
base.OneTimeSetUp();
_fieldName = "y";
_valueSerializer = new Int32Serializer();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_fieldName = "y";
_valueSerializer = new Int32Serializer();
}
// 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 void Setup()
{
_collectionNamespace = new CollectionNamespace("foo", "bar");
_fieldName = "a.b";
_messageEncoderSettings = new MessageEncoderSettings();
_valueSerializer = new Int32Serializer();
}
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;
}
public BsonMigrationSerializer(IBsonSerializer versionSerializer, IVersionDetectionStrategy versionDetectionStrategy, BsonClassMap classMap)
: base(classMap)
{
_versionSerializer = versionSerializer;
_versionDetectionStrategy = versionDetectionStrategy;
_migrations = ExtractMigrations(classMap.ClassType);
}
// 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;
}
/// <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 static IBsonSerializer CreateListSerializer(IBsonSerializer itemSerializer)
{
var implementationType = typeof(List<>).MakeGenericType(itemSerializer.ValueType);
return (IBsonSerializer)Activator.CreateInstance(
typeof(EnumerableInterfaceImplementerSerializer<>).MakeGenericType(
implementationType),
itemSerializer);
}
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;
}
// 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);
}
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);
}
// 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);
}
private IBsonSerializer ConfigureChildSerializer(IChildSerializerConfigurable configurable, IBsonSerializer childSerializer)
{
var childConfigurable = configurable.ChildSerializer as IChildSerializerConfigurable;
if (childConfigurable != null)
{
childSerializer = ConfigureChildSerializer(childConfigurable, childSerializer);
}
return configurable.WithChildSerializer(childSerializer);
}
// constructors
private BsonDeserializationContext(
IBsonReader reader,
bool allowDuplicateElementNames,
IBsonSerializer dynamicArraySerializer,
IBsonSerializer dynamicDocumentSerializer)
{
_reader = reader;
_allowDuplicateElementNames = allowDuplicateElementNames;
_dynamicArraySerializer = dynamicArraySerializer;
_dynamicDocumentSerializer = dynamicDocumentSerializer;
}
private IBsonSerializer ConfigureSerializer(IBsonSerializer serializer)
{
var dictionaryRepresentationConfigurable = serializer as IDictionaryRepresentationConfigurable;
if (dictionaryRepresentationConfigurable != null)
{
serializer = dictionaryRepresentationConfigurable.WithDictionaryRepresentation(_dictionaryRepresentation);
}
var childSerializerConfigurable = serializer as IChildSerializerConfigurable;
return childSerializerConfigurable == null
? serializer
: childSerializerConfigurable.WithChildSerializer(ConfigureSerializer(childSerializerConfigurable.ChildSerializer));
}
public override Expression Visit(Expression expression)
{
if (_serializer != null)
{
return expression;
}
var serializationExpression = expression as ISerializationExpression;
if (serializationExpression != null && serializationExpression.Serializer.ValueType == _valueType)
{
_serializer = serializationExpression.Serializer;
return expression;
}
return base.Visit(expression);
}
// 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 dateTimeSerializer = serializer as DateTimeSerializer;
if (dateTimeSerializer != null)
{
if (_dateOnly)
{
return dateTimeSerializer.WithDateOnly(_dateOnly, _representation);
}
else
{
return dateTimeSerializer.WithKind(_kind, _representation);
}
}
return base.Apply(serializer);
}
// pas vraiment util
//public void RegisterSerializer(Type type, Type serializerType)
//{
// RegisterSerializer(type, (IBsonSerializer)Activator.CreateInstance(serializerType));
//}
public void RegisterSerializer(Type type, IBsonSerializer serializer)
{
// don't allow a serializer to be registered for subclasses of BsonValue
if (typeof(BsonValue).IsAssignableFrom(type))
{
throw new PBException("A serializer cannot be registered for type {0} because it is a subclass of BsonValue.", BsonUtils.GetFriendlyTypeName(type));
}
if (_trace)
pb.Trace.WriteLine($"PBSerializationProvider_v2 : register type \"{type.zGetTypeName()}\" serializer count {_serializers.Count + 1}");
if (_serializers.ContainsKey(type))
{
_serializers[type] = serializer;
}
else
_serializers.Add(type, serializer);
}
public PipelineExpression(Expression source, SerializationExpression projector, ResultOperator resultOperator)
{
_source = Ensure.IsNotNull(source, nameof(source));
_projector = Ensure.IsNotNull(projector, nameof(projector));
_resultOperator = resultOperator;
if (_resultOperator == null)
{
_serializer = SerializerHelper.CreateEnumerableSerializer(_projector.Serializer);
_type = typeof(IEnumerable<>).MakeGenericType(_projector.Type);
}
else
{
_serializer = _resultOperator.Serializer;
_type = _resultOperator.Type;
}
}
// 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>
/// <exception cref="System.NotSupportedException"></exception>
protected virtual IBsonSerializer Apply(IBsonSerializer serializer)
{
// if none of the overrides applied the attribute to the serializer see if it can be applied to a child serializer
var childSerializerConfigurable = serializer as IChildSerializerConfigurable;
if (childSerializerConfigurable != null)
{
var childSerializer = childSerializerConfigurable.ChildSerializer;
var reconfiguredChildSerializer = Apply(childSerializer);
return childSerializerConfigurable.WithChildSerializer(reconfiguredChildSerializer);
}
var message = string.Format(
"A serializer of type '{0}' is not configurable using an attribute of type '{1}'.",
BsonUtils.GetFriendlyTypeName(serializer.GetType()),
BsonUtils.GetFriendlyTypeName(this.GetType()));
throw new NotSupportedException(message);
}
// 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 representationAttribute = attribute as BsonRepresentationAttribute;
if (representationAttribute != null)
{
_representation = representationAttribute.Representation;
return;
}
var optionsAttribute = attribute as BsonTimeSpanOptionsAttribute;
if (optionsAttribute != null)
{
_representation = optionsAttribute.Representation;
_units = optionsAttribute.Units;
return;
}
var message = string.Format("A serialization options attribute of type {0} cannot be applied to serialization options of type {1}.",
BsonUtils.GetFriendlyTypeName(attribute.GetType()), BsonUtils.GetFriendlyTypeName(GetType()));
throw new NotSupportedException(message);
}
/// <summary>
/// Initializes a new instance of the <see cref="BsonDocumentPipelineStageDefinition{TInput, TOutput}"/> class.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="outputSerializer">The output serializer.</param>
public BsonDocumentPipelineStageDefinition(BsonDocument document, IBsonSerializer <TOutput> outputSerializer = null)
{
_document = Ensure.IsNotNull(document, nameof(document));
_outputSerializer = outputSerializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderedPipelineStageDefinition{TOutput}"/> class.
/// </summary>
/// <param name="operatorName">Name of the pipeline operator.</param>
/// <param name="document">The document.</param>
/// <param name="outputSerializer">The output serializer.</param>
public RenderedPipelineStageDefinition(string operatorName, BsonDocument document, IBsonSerializer <TOutput> outputSerializer)
{
_operatorName = Ensure.IsNotNull(operatorName, nameof(operatorName));
_document = Ensure.IsNotNull(document, nameof(document));
_outputSerializer = Ensure.IsNotNull(outputSerializer, nameof(outputSerializer));
}
public override RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(_renderer(inputSerializer, serializerRegistry));
}
/// <summary>
/// Initializes a new instance of the <see cref="NullNaosDictionarySerializer"/> class.
/// </summary>
/// <param name="dictionaryRepresentation">The dictionary representation.</param>
/// <param name="keySerializer">The key serializer.</param>
/// <param name="valueSerializer">The value serializer.</param>
// ReSharper disable once InheritdocConsiderUsage
public NullNaosDictionarySerializer(DictionaryRepresentation dictionaryRepresentation, IBsonSerializer keySerializer, IBsonSerializer valueSerializer)
: base(dictionaryRepresentation, keySerializer, valueSerializer)
{
throw new NotSupportedException("The null dictionary serializer is not intended for use.");
}
/// <summary>
/// Registers a serializer for a type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="serializer">The serializer.</param>
public static void RegisterSerializer(Type type, IBsonSerializer serializer)
{
__serializerRegistry.RegisterSerializer(type, serializer);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ReplyMessageEncoderSelector{TDocument}"/> class.
/// </summary>
/// <param name="documentSerializer">The document serializer.</param>
public ReplyMessageEncoderSelector(IBsonSerializer <TDocument> documentSerializer)
{
_documentSerializer = Ensure.IsNotNull(documentSerializer, "documentSerializer");
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <param name="inputSerializer">The input serializer.</param>
/// <param name="serializerRegistry">The serializer registry.</param>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public string ToString(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedPipeline = Render(inputSerializer, serializerRegistry);
return($"[{string.Join(", ", renderedPipeline.Documents.Select(stage => stage.ToJson()))}]");
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <param name="inputSerializer">The input serializer.</param>
/// <param name="serializerRegistry">The serializer registry.</param>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public string ToString(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedStage = Render(inputSerializer, serializerRegistry);
return(renderedStage.Document.ToJson());
}
public async Task <ReplyMessage <TDocument> > ReceiveMessageAsync <TDocument>(int responseTo, IBsonSerializer <TDocument> serializer, TimeSpan timeout, CancellationToken cancellationToken)
{
Ensure.IsNotNull(serializer, "serializer");
Ensure.IsInfiniteOrGreaterThanOrEqualToZero(timeout, "timeout");
ThrowIfDisposedOrNotOpen();
var slidingTimeout = new SlidingTimeout(timeout);
try
{
if (_listener != null)
{
_listener.ConnectionBeforeReceivingMessage(_connectionId, responseTo);
}
var stopwatch = Stopwatch.StartNew();
var buffer = await _inboundDropbox.ReceiveAsync(responseTo, slidingTimeout, cancellationToken);
int length = buffer.Length;
ReplyMessage <TDocument> reply;
using (var stream = new ByteBufferStream(buffer, ownsByteBuffer: true))
{
var readerSettings = BsonBinaryReaderSettings.Defaults; // TODO: where are reader settings supposed to come from?
var binaryReader = new BsonBinaryReader(stream, readerSettings);
var encoderFactory = new BinaryMessageEncoderFactory(binaryReader);
var encoder = encoderFactory.GetReplyMessageEncoder <TDocument>(serializer);
reply = encoder.ReadMessage();
}
stopwatch.Stop();
if (_listener != null)
{
_listener.ConnectionAfterReceivingMessage <TDocument>(_connectionId, reply, length, stopwatch.Elapsed);
}
return(reply);
}
catch (Exception ex)
{
if (_listener != null)
{
_listener.ConnectionErrorReceivingMessage(_connectionId, responseTo, ex);
}
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PipelineStagePipelineDefinition{TInput, TOutput}"/> class.
/// </summary>
/// <param name="stages">The stages.</param>
/// <param name="outputSerializer">The output serializer.</param>
public PipelineStagePipelineDefinition(IEnumerable <IPipelineStageDefinition> stages, IBsonSerializer <TOutput> outputSerializer = null)
{
_stages = VerifyStages(Ensure.IsNotNull(stages, nameof(stages)).ToList());
_outputSerializer = outputSerializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderedPipelineDefinition{TOutput}"/> class.
/// </summary>
/// <param name="documents">The pipeline.</param>
/// <param name="outputSerializer">The output serializer.</param>
public RenderedPipelineDefinition(IEnumerable <BsonDocument> documents, IBsonSerializer <TOutput> outputSerializer)
{
_documents = Ensure.IsNotNull(documents, nameof(documents)).ToList();
_outputSerializer = Ensure.IsNotNull(outputSerializer, nameof(outputSerializer));
}
/// <inheritdoc />
public override RenderedPipelineDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(new RenderedPipelineDefinition <TOutput>(
_stages,
_outputSerializer ?? (inputSerializer as IBsonSerializer <TOutput>) ?? serializerRegistry.GetSerializer <TOutput>()));
}
/// <summary>
/// Initializes a new instance of the <see cref="BsonDocumentStagePipelineDefinition{TInput, TOutput}"/> class.
/// </summary>
/// <param name="stages">The stages.</param>
/// <param name="outputSerializer">The output serializer.</param>
public BsonDocumentStagePipelineDefinition(IEnumerable <BsonDocument> stages, IBsonSerializer <TOutput> outputSerializer = null)
{
_stages = Ensure.IsNotNull(stages, nameof(stages)).ToList();
_outputSerializer = outputSerializer;
}
/// <summary>
/// Creates a pipeline.
/// </summary>
/// <param name="stages">The stages.</param>
/// <param name="outputSerializer">The output serializer.</param>
/// <returns>A <see cref="PipelineDefinition{TInput, TOutput}"/>.</returns>
public static PipelineDefinition <TInput, TOutput> Create(
IEnumerable <string> stages,
IBsonSerializer <TOutput> outputSerializer = null)
{
return(Create(stages?.Select(s => BsonDocument.Parse(s)), outputSerializer));
}
/// <inheritdoc />
IRenderedPipelineStageDefinition IPipelineStageDefinition.Render(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(Render((IBsonSerializer <TInput>)inputSerializer, serializerRegistry));
}
/// <summary>
/// Initializes a new instance of the <see cref="AggregateOperation{TResult}"/> class.
/// </summary>
/// <param name="collectionNamespace">The collection namespace.</param>
/// <param name="pipeline">The pipeline.</param>
/// <param name="resultSerializer">The result value serializer.</param>
/// <param name="messageEncoderSettings">The message encoder settings.</param>
public AggregateOperation(CollectionNamespace collectionNamespace, IEnumerable <BsonDocument> pipeline, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings)
: this(pipeline, resultSerializer, messageEncoderSettings)
{
_collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace));
}
string IPipelineStageDefinition.ToString(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(ToString((IBsonSerializer <TInput>)inputSerializer, serializerRegistry));
}
/// <summary>
/// Initializes a new instance of the <see cref="NaosDictionarySerializer{T, TKey,TValue}"/> class.
/// </summary>
/// <param name="dictionaryRepresentation">The dictionary representation.</param>
/// <param name="keySerializer">The key serializer.</param>
/// <param name="valueSerializer">The value serializer.</param>
public NaosDictionarySerializer(DictionaryRepresentation dictionaryRepresentation, IBsonSerializer keySerializer, IBsonSerializer valueSerializer)
{
DeserializationConverterFuncBySerializedType.ContainsKey(typeof(TDictionary)).Named(Invariant($"{typeof(TDictionary)}-mustBeSupportedDictionaryType")).Must().BeTrue();
this.underlyingSerializer = new DictionaryInterfaceImplementerSerializer <Dictionary <TKey, TValue> >(dictionaryRepresentation, keySerializer, valueSerializer);
}
/// <summary>
/// Renders the pipeline.
/// </summary>
/// <param name="inputSerializer">The input serializer.</param>
/// <param name="serializerRegistry">The serializer registry.</param>
/// <returns>A <see cref="RenderedPipelineDefinition{TOutput}"/></returns>
public abstract RenderedPipelineDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry);
IBsonSerializer IChildSerializerConfigurable.WithChildSerializer(IBsonSerializer childSerializer)
{
return(WithSerializer((IBsonSerializer <T>)childSerializer));
}
/***************************************************/
private object DeserializeDiscriminatedValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
// First try to recover the object type
IBsonReader reader = context.Reader;
BsonReaderBookmark bookmark = reader.GetBookmark();
Type actualType = typeof(CustomObject);
try
{
actualType = _discriminatorConvention.GetActualType(reader, typeof(object));
}
catch
{
// This is were we can call the Version_Engine to return the new type string from the old one if exists
string recordedType = GetCurrentTypeValue(reader);
// If failed, return Custom object
context.Reader.ReturnToBookmark(bookmark);
Engine.Reflection.Compute.RecordWarning("The type " + recordedType + " is unknown -> data returned as custom objects.");
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
return(customSerializer.Deserialize(context, args));
}
// Handle the special case where the type is object
if (actualType == typeof(object))
{
BsonType currentBsonType = reader.GetCurrentBsonType();
if (currentBsonType == BsonType.Document && context.DynamicDocumentSerializer != null)
{
return(context.DynamicDocumentSerializer.Deserialize(context, args));
}
reader.ReadStartDocument();
reader.ReadEndDocument();
return(new object());
}
// Handle the genral case of finding the correct deserialiser and calling it
IBsonSerializer bsonSerializer = BsonSerializer.LookupSerializer(actualType);
IBsonPolymorphicSerializer bsonPolymorphicSerializer = bsonSerializer as IBsonPolymorphicSerializer;
if (bsonPolymorphicSerializer != null && bsonPolymorphicSerializer.IsDiscriminatorCompatibleWithObjectSerializer)
{
bookmark = context.Reader.GetBookmark();
try
{
return(bsonSerializer.Deserialize(context, args));
}
catch
{
context.Reader.ReturnToBookmark(bookmark);
Engine.Reflection.Compute.RecordWarning("Cannot find a definition of type " + actualType.FullName + " that matches the object to deserialise -> data returned as custom objects.");
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
CustomObject fallback = customSerializer.Deserialize(context, args) as CustomObject;
//This is where we will try to get the correct object type from the custom object using the versionning engine
// If failed, just return the custom object
return(fallback);
}
}
object result = null;
bool flag = false;
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
string text = reader.ReadName();
if (text == _discriminatorConvention.ElementName)
{
reader.SkipValue();
}
else
{
if (!(text == "_v"))
{
throw new FormatException($"Unexpected element name: '{text}'.");
}
result = bsonSerializer.Deserialize(context);
flag = true;
}
}
reader.ReadEndDocument();
if (!flag)
{
throw new FormatException("_v element missing.");
}
return(result);
}
public AverageResultOperator(Type type, IBsonSerializer serializer)
{
_type = Ensure.IsNotNull(type, nameof(type));
_serializer = Ensure.IsNotNull(serializer, nameof(serializer));
}
private AggregateOperation(IEnumerable <BsonDocument> pipeline, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings)
{
_pipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).ToList();
_resultSerializer = Ensure.IsNotNull(resultSerializer, nameof(resultSerializer));
_messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, nameof(messageEncoderSettings));
}
/// <inheritdoc />
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(_document);
}
public FindOneAndDeleteOperationTests()
{
_filter = new BsonDocument("x", 1);
_findAndModifyValueDeserializer = new FindAndModifyValueDeserializer <BsonDocument>(BsonDocumentSerializer.Instance);
}
/// <summary> /// Renders the update to a <see cref="BsonDocument"/>. /// </summary> /// <param name="documentSerializer">The document serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="BsonDocument"/>.</returns> public abstract BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
/// <inheritdoc />
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var serializer = serializerRegistry.GetSerializer(_obj.GetType());
return(new BsonDocumentWrapper(_obj, serializer));
}
/// <inheritdoc />
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
return(BsonDocument.Parse(_json));
}
// public methods
public override IFindFluent <TDocument, TResult> As <TResult>(IBsonSerializer <TResult> resultSerializer)
{
var projection = Builders <TDocument> .Projection.As <TResult>(resultSerializer);
return(Project(projection));
}
/// <summary>
/// Registers a serializer for a type.
/// </summary>
/// <typeparam name="T">The type.</typeparam>
/// <param name="serializer">The serializer.</param>
public static void RegisterSerializer <T>(IBsonSerializer <T> serializer)
{
RegisterSerializer(typeof(T), serializer);
}
