DynamicSerializer.cs

Go to the documentation of this file.

using Fauna.Exceptions;
using Fauna.Mapping;
using Fauna.Types;
 
namespace Fauna.Serialization;
 
internal class DynamicSerializer : BaseSerializer<object?>
{
    public static DynamicSerializer Singleton { get; } = new();
 
    private readonly ListSerializer<object?> _list;
    private readonly PageSerializer<object?> _page;
    private readonly DictionarySerializer<object?> _dict;
    private readonly BaseRefSerializer<Dictionary<string, object>> _docref;
 
 
    private DynamicSerializer()
    {
        _list = new ListSerializer<object?>(this);
        _page = new PageSerializer<object?>(this);
        _dict = new DictionarySerializer<object?>(this);
        _docref = new BaseRefSerializer<Dictionary<string, object>>(_dict);
    }
 
    public override List<FaunaType> GetSupportedTypes() => new List<FaunaType> {
        FaunaType.Array,
        FaunaType.Boolean,
        FaunaType.Bytes,
        FaunaType.Date,
        FaunaType.Double,
        FaunaType.Document,
        FaunaType.Int,
        FaunaType.Long,
        FaunaType.Module,
        FaunaType.Null,
        FaunaType.Object,
        FaunaType.Ref,
        FaunaType.Set,
        FaunaType.Stream,
        FaunaType.String,
        FaunaType.Time
    };
 
    public override object? Deserialize(MappingContext ctx, ref Utf8FaunaReader reader) =>
        reader.CurrentTokenType switch
        {
            TokenType.StartObject => _dict.Deserialize(ctx, ref reader),
            TokenType.StartArray => _list.Deserialize(ctx, ref reader),
            TokenType.StartPage => _page.Deserialize(ctx, ref reader),
            TokenType.StartRef => _docref.Deserialize(ctx, ref reader),
            TokenType.StartDocument => DeserializeDocumentInternal(ctx, ref reader),
            TokenType.String => reader.GetString(),
            TokenType.Int => reader.GetInt(),
            TokenType.Long => reader.GetLong(),
            TokenType.Double => reader.GetDouble(),
            TokenType.Date => reader.GetDate(),
            TokenType.Time => reader.GetTime(),
            TokenType.True or TokenType.False => reader.GetBoolean(),
            TokenType.Module => reader.GetModule(),
            TokenType.Bytes => reader.GetBytes(),
            TokenType.Null => null,
            TokenType.EventSource => reader.GetEventSource(),
            _ => throw new SerializationException(
                $"Unexpected token while deserializing: {reader.CurrentTokenType}"),
        };
 
    private object DeserializeDocumentInternal(MappingContext context, ref Utf8FaunaReader reader)
    {
        var builder = new BaseRefBuilder<Dictionary<string, object>>();
        while (reader.Read() && reader.CurrentTokenType != TokenType.EndDocument)
        {
            if (reader.CurrentTokenType != TokenType.FieldName)
                throw new SerializationException(
                    $"Unexpected token while deserializing @doc: {reader.CurrentTokenType}");
 
            string fieldName = reader.GetString()!;
 
            reader.Read();
 
            switch (fieldName)
            {
                // Relies on ordering for doc fields.
                case "id":
                    builder.Id = reader.GetString();
                    break;
                case "name":
                    builder.Name = reader.GetString();
                    break;
                case "coll":
                    builder.Collection = reader.GetModule();
 
                    // if we encounter a mapped collection, jump to the class deserializer.
                    // NB this relies on the fact that docs on the wire always start with id and coll.
                    if (context.TryGetCollection(builder.Collection.Name, out var info) && info.ClassSerializer is IPartialDocumentSerializer ser)
                    {
                        return new BaseRefBuilder<object>
                        {
                            Id = builder.Id,
                            Name = builder.Name,
                            Collection = builder.Collection,
                            Doc = ser.DeserializeDocument(context, builder.Id, builder.Name, builder.Collection,
                                ref reader)
                        }.Build();
                    }
 
                    builder.Doc = (Dictionary<string, object>?)_dict.DeserializeDocument(context, builder.Id, builder.Name, builder.Collection, ref reader);
                    break;
            }
 
            // After we deserialize into a doc, we end on the EndDocument a token and do not want to read again
            if (reader.CurrentTokenType == TokenType.EndDocument) break;
        }
 
        return builder.Build();
    }
 
    public override void Serialize(MappingContext ctx, Utf8FaunaWriter w, object? o)
    {
        if (o == null)
        {
            w.WriteNullValue();
            return;
        }
 
        var ser = Serializer.Generate(ctx, o.GetType());
        ser.Serialize(ctx, w, o);
    }
}