public void Serialize(ref JsonWriter writer, Routing value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
if (value.Document != null)
{
var settings = formatterResolver.GetConnectionSettings();
var documentId = settings.Inferrer.Routing(value.Document.GetType(), value.Document);
writer.WriteString(documentId);
}
else if (value.DocumentGetter != null)
{
var settings = formatterResolver.GetConnectionSettings();
var doc = value.DocumentGetter();
var documentId = settings.Inferrer.Routing(doc.GetType(), doc);
writer.WriteString(documentId);
}
else if (value.LongValue != null)
{
writer.WriteInt64(value.LongValue.Value);
}
else
{
writer.WriteString(value.StringValue);
}
}
public void Serialize(ref JsonWriter writer, JoinField value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
// ref cannot be used inside lambda expression body
switch (value.Tag)
{
case 0:
{
var relationNameFormatter = formatterResolver.GetFormatter <RelationName>();
relationNameFormatter.Serialize(ref writer, value.ParentOption.Name, formatterResolver);
break;
}
case 1:
{
var child = value.ChildOption;
writer.WriteBeginObject();
writer.WritePropertyName("name");
var relationNameFormatter = formatterResolver.GetFormatter <RelationName>();
relationNameFormatter.Serialize(ref writer, child.Name, formatterResolver);
writer.WriteValueSeparator();
writer.WritePropertyName("parent");
var id = (child.ParentId as IUrlParameter)?.GetString(formatterResolver.GetConnectionSettings());
writer.WriteString(id);
writer.WriteEndObject();
break;
}
}
}
internal bool ShouldSerialize(IJsonFormatterResolver formatterResolver)
{
var inferrer = formatterResolver.GetConnectionSettings().Inferrer;
var resolved = inferrer.Resolve(this);
return(!resolved.IsNullOrEmpty());
}
private static void Serialize(ref JsonWriter writer, Field value, IJsonFormatterResolver formatterResolver, bool serializeAsString)
{
if (value == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var fieldName = settings.Inferrer.Field(value);
if (serializeAsString || string.IsNullOrEmpty(value.Format))
{
writer.WriteString(fieldName);
}
else
{
writer.WriteBeginObject();
writer.WritePropertyName("field");
writer.WriteString(fieldName);
writer.WriteValueSeparator();
writer.WritePropertyName("format");
writer.WriteString(value.Format);
writer.WriteEndObject();
}
}
public void Serialize(ref JsonWriter writer, Children value, IJsonFormatterResolver formatterResolver)
{
if (value == null || value.Count == 0)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var resolved = value.Cast <IUrlParameter>().ToList();
if (resolved.Count == 1)
{
writer.WriteString(resolved[0].GetString(settings));
return;
}
writer.WriteBeginArray();
for (var index = 0; index < resolved.Count; index++)
{
if (index > 0)
{
writer.WriteValueSeparator();
}
var r = resolved[index];
writer.WriteString(r.GetString(settings));
}
writer.WriteEndArray();
}
public void Serialize(ref JsonWriter writer, IGeoPolygonQuery value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var written = false;
writer.WriteBeginObject();
if (!value.Name.IsNullOrEmpty())
{
writer.WritePropertyName("_name");
writer.WriteString(value.Name);
written = true;
}
if (value.Boost != null)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("boost");
writer.WriteDouble(value.Boost.Value);
written = true;
}
if (value.ValidationMethod != null)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("validation_method");
formatterResolver.GetFormatter <GeoValidationMethod>()
.Serialize(ref writer, value.ValidationMethod.Value, formatterResolver);
written = true;
}
if (written)
{
writer.WriteValueSeparator();
}
var settings = formatterResolver.GetConnectionSettings();
writer.WritePropertyName(settings.Inferrer.Field(value.Field));
writer.WriteBeginObject();
writer.WritePropertyName("points");
formatterResolver.GetFormatter <IEnumerable <GeoLocation> >()
.Serialize(ref writer, value.Points, formatterResolver);
writer.WriteEndObject();
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, Indices value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
switch (value.Tag)
{
case 0:
writer.WriteBeginArray();
writer.WriteString("_all");
writer.WriteEndArray();
break;
case 1:
var settings = formatterResolver.GetConnectionSettings();
writer.WriteBeginArray();
for (var index = 0; index < value.Item2.Indices.Count; index++)
{
if (index > 0)
{
writer.WriteValueSeparator();
}
var indexName = value.Item2.Indices[index];
writer.WriteString(indexName.GetString(settings));
}
writer.WriteEndArray();
break;
}
}
public override void Serialize(ref JsonWriter writer, TInterface value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var fieldName = value.Field;
if (fieldName == null)
{
return;
}
var settings = formatterResolver.GetConnectionSettings();
var field = settings.Inferrer.Field(fieldName);
if (field.IsNullOrEmpty())
{
return;
}
writer.WriteBeginObject();
writer.WritePropertyName(field);
base.Serialize(ref writer, value, formatterResolver);
writer.WriteEndObject();
}
private static void WriteFieldValueFactor(ref JsonWriter writer, IFieldValueFactorFunction value, IJsonFormatterResolver formatterResolver)
{
writer.WritePropertyName("field_value_factor");
writer.WriteBeginObject();
writer.WritePropertyName("field");
writer.WriteString(formatterResolver.GetConnectionSettings().Inferrer.Field(value.Field));
if (value.Factor.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("factor");
writer.WriteDouble(value.Factor.Value);
}
if (value.Modifier.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("modifier");
formatterResolver.GetFormatter <FieldValueFactorModifier>()
.Serialize(ref writer, value.Modifier.Value, formatterResolver);
}
if (value.Missing.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("missing");
writer.WriteDouble(value.Missing.Value);
}
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, IDictionary <IndexName, double> value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
writer.WriteBeginArray();
var count = 0;
foreach (var entry in value)
{
if (count > 0)
{
writer.WriteValueSeparator();
}
writer.WriteBeginObject();
var indexName = settings.Inferrer.IndexName(entry.Key);
writer.WritePropertyName(indexName);
writer.WriteDouble(entry.Value);
writer.WriteEndObject();
count++;
}
writer.WriteEndArray();
}
public TResponse Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
var response = new TResponse();
var dictionary = new Dictionary <TKey, TValue>();
var count = 0;
var keyFormatter = formatterResolver.GetFormatter <TKey>();
var valueFormatter = formatterResolver.GetFormatter <TValue>();
while (reader.ReadIsInObject(ref count))
{
var property = reader.ReadPropertyNameSegmentRaw();
if (ResponseFormatterHelpers.ServerErrorFields.TryGetValue(property, out var errorValue))
{
switch (errorValue)
{
case 0:
if (reader.GetCurrentJsonToken() == JsonToken.String)
{
response.Error = new Error {
Reason = reader.ReadString()
}
}
;
else
{
var formatter = formatterResolver.GetFormatter <Error>();
response.Error = formatter.Deserialize(ref reader, formatterResolver);
}
break;
case 1:
if (reader.GetCurrentJsonToken() == JsonToken.Number)
{
response.StatusCode = reader.ReadInt32();
}
else
{
reader.ReadNextBlock();
}
break;
}
}
else
{
// include opening string quote in reader (offset - 1)
var propertyReader = new JsonReader(property.Array, property.Offset - 1);
var key = keyFormatter.Deserialize(ref propertyReader, formatterResolver);
var value = valueFormatter.Deserialize(ref reader, formatterResolver);
dictionary.Add(key, value);
}
}
var settings = formatterResolver.GetConnectionSettings();
var resolvableDictionary = new ResolvableDictionaryProxy <TKey, TValue>(settings, dictionary);
response.BackingDictionary = resolvableDictionary;
return(response);
}
internal LazyDocument(byte[] bytes, IJsonFormatterResolver formatterResolver)
{
Bytes = bytes;
var settings = formatterResolver.GetConnectionSettings();
_sourceSerializer = settings.SourceSerializer;
_requestResponseSerializer = settings.RequestResponseSerializer;
_memoryStreamFactory = settings.MemoryStreamFactory;
}
public TDictionary Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
var formatter = formatterResolver.GetFormatter <Dictionary <TKey, TValue> >();
var d = formatter.Deserialize(ref reader, formatterResolver);
var settings = formatterResolver.GetConnectionSettings();
var dict = Create(settings, d);
return(dict);
}
public void Serialize(ref JsonWriter writer, ISort value, IJsonFormatterResolver formatterResolver)
{
if (value?.SortKey == null)
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var settings = formatterResolver.GetConnectionSettings();
switch (value.SortKey.Name ?? string.Empty)
{
case "_script":
writer.WritePropertyName("_script");
var scriptSort = (IScriptSort)value;
var scriptSortFormatter = formatterResolver.GetFormatter <IScriptSort>();
scriptSortFormatter.Serialize(ref writer, scriptSort, formatterResolver);
break;
case "_geo_distance":
var geo = value as IGeoDistanceSort;
writer.WritePropertyName(geo.SortKey.Name);
var innerWriter = new JsonWriter();
var formatter = DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <IGeoDistanceSort>();
formatter.Serialize(ref innerWriter, geo, formatterResolver);
var buffer = innerWriter.GetBuffer();
// get all the written bytes except the closing }
for (var i = buffer.Offset; i < buffer.Count - 1; i++)
{
writer.WriteRawUnsafe(buffer.Array[i]);
}
// does the IGeoDistanceSort have other properties set i.e. is it more than simply {} ?
if (buffer.Count > 2)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName(settings.Inferrer.Field(geo.Field));
var geoFormatter = formatterResolver.GetFormatter <IEnumerable <GeoLocation> >();
geoFormatter.Serialize(ref writer, geo.Points, formatterResolver);
writer.WriteEndObject();
break;
default:
writer.WritePropertyName(settings.Inferrer.Field(value.SortKey));
var sortFormatter = DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <IFieldSort>();
sortFormatter.Serialize(ref writer, value as IFieldSort, formatterResolver);
break;
}
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, TRequestInterface value, IJsonFormatterResolver formatterResolver)
{
var untypedDocumentRequest = (IProxyRequest)value;
var settings = formatterResolver.GetConnectionSettings();
var serializer = settings.SourceSerializer;
using (var ms = settings.MemoryStreamFactory.Create())
{
untypedDocumentRequest.WriteJson(serializer, ms, SerializationFormatting.None);
writer.WriteRaw(ms);
}
}
public void Serialize(ref JsonWriter writer, RelationName value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
writer.WriteString(settings.Inferrer.RelationName(value));
}
public void Serialize(ref JsonWriter writer, PropertyName value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var infer = formatterResolver.GetConnectionSettings().Inferrer;
writer.WriteString(infer.PropertyName(value));
}
private void WriteDecay(ref JsonWriter writer, IDecayFunction decay, IJsonFormatterResolver formatterResolver)
{
writer.WritePropertyName(decay.DecayType);
writer.WriteBeginObject();
writer.WritePropertyName(formatterResolver.GetConnectionSettings().Inferrer.Field(decay.Field));
writer.WriteBeginObject();
var written = false;
switch (decay)
{
case IDecayFunction <double?, double?> numericDecay:
WriteNumericDecay(ref writer, ref written, numericDecay);
break;
case IDecayFunction <DateMath, Time> dateDecay:
WriteDateDecay(ref writer, ref written, dateDecay, formatterResolver);
break;
case IDecayFunction <GeoLocation, Distance> geoDecay:
WriteGeoDecay(ref writer, ref written, geoDecay, formatterResolver);
break;
default:
throw new Exception($"Can not write decay function json for {decay.GetType().Name}");
}
if (decay.Decay.HasValue)
{
if (written)
{
writer.WriteValueSeparator();
}
writer.WritePropertyName("decay");
writer.WriteDouble(decay.Decay.Value);
}
writer.WriteEndObject();
if (decay.MultiValueMode.HasValue)
{
writer.WriteValueSeparator();
writer.WritePropertyName("multi_value_mode");
formatterResolver.GetFormatter <MultiValueMode>()
.Serialize(ref writer, decay.MultiValueMode.Value, formatterResolver);
}
writer.WriteEndObject();
}
public T Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
var settings = formatterResolver.GetConnectionSettings();
// avoid deserialization through stream when not using custom source serializer
if (ReferenceEquals(settings.SourceSerializer, settings.RequestResponseSerializer))
{
return(formatterResolver.GetFormatter <T>().Deserialize(ref reader, formatterResolver));
}
var arraySegment = reader.ReadNextBlockSegment();
using (var ms = settings.MemoryStreamFactory.Create(arraySegment.Array, arraySegment.Offset, arraySegment.Count))
return(settings.SourceSerializer.Deserialize <T>(ms));
}
public void Serialize(ref JsonWriter writer, ISpanGapQuery value, IJsonFormatterResolver formatterResolver)
{
if (value == null || SpanGapQuery.IsConditionless(value))
{
writer.WriteNull();
return;
}
writer.WriteBeginObject();
var inferrer = formatterResolver.GetConnectionSettings().Inferrer;
writer.WritePropertyName(inferrer.Field(value.Field));
writer.WriteInt32(value.Width.Value);
writer.WriteEndObject();
}
public void Serialize(ref JsonWriter writer, IPostJobDataRequest value, IJsonFormatterResolver formatterResolver)
{
if (value?.Data == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var sourceSerializer = settings.SourceSerializer;
foreach (var data in value.Data)
{
writer.WriteSerialized(data, sourceSerializer, settings, SerializationFormatting.None);
}
}
public virtual void Serialize(ref JsonWriter writer, T value, IJsonFormatterResolver formatterResolver)
{
var settings = formatterResolver.GetConnectionSettings();
var sourceSerializer = settings.SourceSerializer;
if (AttemptFastPath(sourceSerializer, out var formatter))
{
formatter.GetFormatter <T>().Serialize(ref writer, value, formatter);
return;
}
var f = ForceFormatting ?? SerializationFormatting.None;
writer.WriteSerialized(value, sourceSerializer, settings, f);
}
public T Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
var settings = formatterResolver.GetConnectionSettings();
var sourceSerializer = settings.SourceSerializer;
if (AttemptFastPath(sourceSerializer, out var formatter))
{
return(formatter.GetFormatter <T>().Deserialize(ref reader, formatter));
}
var arraySegment = reader.ReadNextBlockSegment();
using (var ms = settings.MemoryStreamFactory.Create(arraySegment.Array, arraySegment.Offset, arraySegment.Count))
return(sourceSerializer.Deserialize <T>(ms));
}
public void Serialize(ref JsonWriter writer, IMultiSearchTemplateRequest value, IJsonFormatterResolver formatterResolver)
{
if (value?.Operations == null)
{
return;
}
var settings = formatterResolver.GetConnectionSettings();
var memoryStreamFactory = settings.MemoryStreamFactory;
var serializer = settings.RequestResponseSerializer;
foreach (var operation in value.Operations.Values)
{
var p = operation.RequestParameters;
string GetString(string key)
{
return(p.GetResolvedQueryStringValue(key, settings));
}
IUrlParameter indices = value.Index == null || !value.Index.Equals(operation.Index)
? operation.Index
: null;
var searchType = GetString("search_type");
if (searchType == "query_then_fetch")
{
searchType = null;
}
var header = new
{
index = indices?.GetString(settings),
search_type = searchType,
preference = GetString("preference"),
routing = GetString("routing"),
ignore_unavailable = GetString("ignore_unavailable")
};
var headerBytes = serializer.SerializeToBytes(header, memoryStreamFactory, SerializationFormatting.None);
writer.WriteRaw(headerBytes);
writer.WriteRaw(Newline);
var bodyBytes = serializer.SerializeToBytes(operation, memoryStreamFactory, SerializationFormatting.None);
writer.WriteRaw(bodyBytes);
writer.WriteRaw(Newline);
}
}
public void Serialize(ref JsonWriter writer, IBulkRequest value, IJsonFormatterResolver formatterResolver)
{
if (value?.Operations == null)
{
return;
}
var settings = formatterResolver.GetConnectionSettings();
var memoryStreamFactory = settings.MemoryStreamFactory;
var requestResponseSerializer = settings.RequestResponseSerializer;
var sourceSerializer = settings.SourceSerializer;
var inferrer = settings.Inferrer;
var formatter = formatterResolver.GetFormatter <object>();
for (var index = 0; index < value.Operations.Count; index++)
{
var op = value.Operations[index];
op.Index = op.Index ?? value.Index ?? op.ClrType;
if (op.Index.Equals(value.Index))
{
op.Index = null;
}
op.Id = op.GetIdForOperation(inferrer);
op.Routing = op.GetRoutingForOperation(inferrer);
writer.WriteBeginObject();
writer.WritePropertyName(op.Operation);
formatter.Serialize(ref writer, op, formatterResolver);
writer.WriteEndObject();
writer.WriteRaw(Newline);
var body = op.GetBody();
if (body == null)
{
continue;
}
var bodySerializer = op.Operation == "update" || body is ILazyDocument
? requestResponseSerializer
: sourceSerializer;
var bodyBytes = bodySerializer.SerializeToBytes(body, memoryStreamFactory, SerializationFormatting.None);
writer.WriteRaw(bodyBytes);
writer.WriteRaw(Newline);
}
}
public void Serialize(ref JsonWriter writer, TRequestInterface value, IJsonFormatterResolver formatterResolver)
{
var untypedDocumentRequest = (IProxyRequest)value;
// TODO: Allow formatting
//var f = writer.Formatting == Formatting.Indented ? Indented : None;
var settings = formatterResolver.GetConnectionSettings();
var serializer = settings.SourceSerializer;
using (var ms = settings.MemoryStreamFactory.Create())
{
untypedDocumentRequest.WriteJson(serializer, ms, SerializationFormatting.None);
var v = ms.ToArray();
writer.WriteRaw(v);
}
}
public void Serialize(ref JsonWriter writer, IProperties value, IJsonFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
// HACK: Deduplicate property mappings with an instance of Properties that has access to ConnectionSettings to sanitize PropertyName keys
// TODO: Find a way to deduplicate outside of serialization
var properties = new Properties(settings);
foreach (var kv in value)
{
var clrOrigin = kv.Value as IPropertyWithClrOrigin;
var propertyInfo = clrOrigin?.ClrOrigin;
if (propertyInfo == null)
{
properties[kv.Key] = kv.Value;
continue;
}
// Check against connection settings mappings
if (settings.PropertyMappings.TryGetValue(propertyInfo, out var propertyMapping))
{
if (propertyMapping.Ignore)
{
continue;
}
properties[propertyMapping.Name] = kv.Value;
continue;
}
// Check against attribute mapping, CreatePropertyMapping caches.
// We do not have to take .Name into account from serializer PropertyName (kv.Key) already handles this
propertyMapping = settings.PropertyMappingProvider?.CreatePropertyMapping(propertyInfo);
if (propertyMapping == null || !propertyMapping.Ignore)
{
properties[kv.Key] = kv.Value;
}
}
Formatter.Serialize(ref writer, properties, formatterResolver);
}
public FieldValues Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
if (reader.GetCurrentJsonToken() != JsonToken.BeginObject)
{
return(null);
}
var count = 0;
var fields = new Dictionary <string, LazyDocument>();
while (reader.ReadIsInObject(ref count))
{
var propertyName = reader.ReadPropertyName();
var lazyDocument = LazyDocumentFormatter.Deserialize(ref reader, formatterResolver);
fields[propertyName] = lazyDocument;
}
return(new FieldValues(formatterResolver.GetConnectionSettings().Inferrer, fields));
}
public void Serialize(ref JsonWriter writer, IPostJobDataRequest value, IJsonFormatterResolver formatterResolver)
{
if (value?.Data == null)
{
writer.WriteNull();
return;
}
var settings = formatterResolver.GetConnectionSettings();
var sourceSerializer = settings.SourceSerializer;
var memoryStreamFactory = settings.MemoryStreamFactory;
foreach (var data in value.Data)
{
var bodyJson = sourceSerializer.SerializeToBytes(data, memoryStreamFactory, SerializationFormatting.None);
writer.WriteRaw(bodyJson);
writer.WriteRaw(Newline);
}
}
public TRequestInterface Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
// TODO: Look at optimizing this. It looks like this could be replaced with SourceFormatter<T> on Document and a serialization ctor
var segment = reader.ReadNextBlockSegment();
var settings = formatterResolver.GetConnectionSettings();
using (var ms = settings.MemoryStreamFactory.Create(segment.Array, segment.Offset, segment.Count))
{
//not optimized but deserializing create requests is far from common practice
var genericType = typeof(TRequest).GenericTypeArguments[0];
var o = settings.SourceSerializer.Deserialize(genericType, ms);
// TRequest might be an open or closed generic type
var request = typeof(TRequest).IsGenericTypeDefinition
? (TRequest)typeof(TRequest).CreateGenericInstance(genericType, o, null, null)
: (TRequest)typeof(TRequest).CreateInstance(o, null, null);
return(request);
}
}
