/// <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); }