public void AddBodyObject <T>(T p_data, Serialization.Serializer p_customSerializer = null) { if (p_data != null) { Serialization.Data v_data; if (p_customSerializer == null) { p_customSerializer = SerializationUtils.DefaultSerializer; } p_customSerializer.TrySerialize(typeof(T), p_data, out v_data, null); var v_dataDict = v_data.AsDictionary; var v_sucess = false; foreach (var v_pair in v_dataDict) { v_sucess = true; m_bodyData[v_pair.Key] = v_pair.Value; } if (v_sucess) { _bodyDataJson = null; _bodyDataBytes = null; } } }
/// <summary> /// Constructs this deserializer from the given parameters. /// </summary> /// <param name="serializer"></param> /// <param name="tag"><see cref="IStorageDeserializer.Tag"/>.</param> public OrleansStorageDefaultBinaryDeserializer(Serialization.Serializer serializer, string tag) { this.serializer = serializer; if (string.IsNullOrWhiteSpace(tag)) { throw new ArgumentException("The parameter should contain characters.", nameof(tag)); } Tag = tag; }
public GeneratorAdapterFactory(string providerName, HashRingStreamQueueMapperOptions queueMapperOptions, StreamStatisticOptions statisticOptions, IServiceProvider serviceProvider, Serialization.Serializer serializer, ITelemetryProducer telemetryProducer, ILoggerFactory loggerFactory) { this.Name = providerName; this.queueMapperOptions = queueMapperOptions ?? throw new ArgumentNullException(nameof(queueMapperOptions)); this.statisticOptions = statisticOptions ?? throw new ArgumentNullException(nameof(statisticOptions)); this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)); this.serializer = serializer ?? throw new ArgumentNullException(nameof(serializer)); this.telemetryProducer = telemetryProducer ?? throw new ArgumentNullException(nameof(telemetryProducer)); this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); this.logger = loggerFactory.CreateLogger <GeneratorAdapterFactory>(); }
/// <summary> /// Pooled cache for generator stream provider. /// </summary> /// <param name="bufferPool">The buffer pool.</param> /// <param name="logger">The logger.</param> /// <param name="serializer">The serializer.</param> /// <param name="cacheMonitor">The cache monitor.</param> /// <param name="monitorWriteInterval">The monitor write interval. Only triggered for active caches</param> public GeneratorPooledCache(IObjectPool <FixedSizeBuffer> bufferPool, ILogger logger, Serialization.Serializer serializer, ICacheMonitor cacheMonitor, TimeSpan?monitorWriteInterval) { this.bufferPool = bufferPool; this.serializer = serializer; cache = new PooledQueueCache(this, logger, cacheMonitor, monitorWriteInterval); TimePurgePredicate purgePredicate = new TimePurgePredicate(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10)); this.evictionStrategy = new ChronologicalEvictionStrategy(logger, purgePredicate, cacheMonitor, monitorWriteInterval) { PurgeObservable = cache }; }
/// <summary> /// Duplicate of EventHub's EventData class. /// </summary> public EventHubMessage(CachedMessage cachedMessage, Serialization.Serializer serializer) { int readOffset = 0; StreamId = cachedMessage.StreamId; Offset = SegmentBuilder.ReadNextString(cachedMessage.Segment, ref readOffset); PartitionKey = SegmentBuilder.ReadNextString(cachedMessage.Segment, ref readOffset); SequenceNumber = cachedMessage.SequenceNumber; EnqueueTimeUtc = cachedMessage.EnqueueTimeUtc; DequeueTimeUtc = cachedMessage.DequeueTimeUtc; Properties = SegmentBuilder.ReadNextBytes(cachedMessage.Segment, ref readOffset).DeserializeProperties(serializer); Payload = SegmentBuilder.ReadNextBytes(cachedMessage.Segment, ref readOffset).ToArray(); }
public override string PresentContent(Node node, Serialization.Serializer serializer) { if (node.GetType() != typeof(Sequence) && !node.GetType().IsSubclassOf(typeof(Sequence))) { throw new InvalidOperationException("TagSequence can only be applied to Sequence nodes."); } Sequence sequence = (Sequence)node; StringBuilder sb = new StringBuilder(); foreach (Node n in sequence) { sb.Append("- "); sb.Append(serializer.GetCharacterStream(n).IndentContent(serializer.IndentWidth)); sb.AppendLine(); } return(sb.ToString()); }
public void AddParamObject <T>(T p_data, Serialization.Serializer p_customSerializer = null) { if (p_data != null) { Serialization.Data v_data; if (p_customSerializer == null) { p_customSerializer = SerializationUtils.DefaultSerializer; } p_customSerializer.TrySerialize(typeof(T), p_data, out v_data, null); var v_dataDict = v_data.AsDictionary; //var v_sucess = false; foreach (var v_pair in v_dataDict) { //v_sucess = true; m_paramsData[v_pair.Key] = v_pair.Value; } } }
/// <summary> /// Cache data adapter that adapts EventHub's EventData to CachedEventHubMessage used in cache /// </summary> public EventHubDataAdapter(Serialization.Serializer serializer) { this.serializer = serializer; }
public override string PresentContent(Node node, Serialization.Serializer serializer) { if (node.GetType() != typeof(Mapping) && !node.GetType().IsSubclassOf(typeof(Mapping))) { throw new InvalidOperationException("TagMapping can only be applied to Mapping nodes. This node is of " + node.GetType().ToString()); } Mapping mapping = (Mapping)node; int maxKeyLength = 0; // check if keys are scalar (therefore sortable) bool isShortKeys = true; foreach (Node key in mapping.Keys) { if (!key.IsAlias() && !key.IsScalar()) { isShortKeys = false; break; } string keyContent; if (key.IsAlias()) { keyContent = "*" + key.AnchorHandle; } else { keyContent = key.CanonicalContent; } if (keyContent.Contains("\n")) { isShortKeys = false; break; } int keyLength = keyContent.Length; if (keyLength > maxKeyLength) { maxKeyLength = keyLength; } } IEnumerable <Node> keys; if (isShortKeys) { keys = OrderKeys(mapping); } else { keys = mapping.Keys; } StringBuilder sb = new StringBuilder(); foreach (Node key in keys) { Node value = mapping[key]; if (!isShortKeys) { sb.Append("? "); } string keyName = serializer.GetCharacterStream(key).IndentContent(serializer.IndentWidth); /* todo check if key has : symbol */ if (serializer.MappingAlignColons) { keyName = keyName.PadRight(maxKeyLength); } sb.Append(keyName); if (!isShortKeys) { sb.AppendLine(); } sb.Append(": "); if (!value.IsScalar() && !value.IsAlias()) { sb.AppendLine(); } sb.Append(serializer.GetCharacterStream(value).IndentContent(serializer.IndentWidth)); sb.AppendLine(); } return(sb.ToString()); }
public override string PresentContent(Node node, Serialization.Serializer serializer) { return(node.CanonicalContent); }
/// <summary> /// Deserializes event data properties /// </summary> public static IDictionary <string, object> DeserializeProperties(this ArraySegment <byte> bytes, Serialization.Serializer serializer) { return(serializer.Deserialize <List <KeyValuePair <string, object> > >(bytes.AsSpan()).ToDictionary(kvp => kvp.Key, kvp => kvp.Value)); }
/// <summary> /// Serializes event data properties /// </summary> public static byte[] SerializeProperties(this EventData eventData, Serialization.Serializer serializer) { var result = serializer.SerializeToArray(eventData.Properties.Where(kvp => !string.Equals(kvp.Key, EventDataPropertyStreamNamespaceKey, StringComparison.Ordinal)).ToList()); return(result); }
/// <summary> /// Returns a formatted string for content. Performed during Serialize.GetChearacterStream() /// </summary> /// <param name="indentWidth"></param> public abstract string PresentContent(Node node, Serialization.Serializer serializer);
/// <summary> /// uses Tag.PresentContent() to convert a event tree directly to string. /// </summary> public virtual string PresentContent(Serialization.Serializer serializer) { return(Tag.PresentContent(this, serializer)); // Tag determines how the node is outputted to string }