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
}
