SerializationJson.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_SERIALIZATION_TEXT
#define SC_EXPORT_LIBRARY_SERIALIZATION_TEXT 0
#endif
#define SC_SERIALIZATION_TEXT_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_SERIALIZATION_TEXT)
 
#include "Internal/JsonTokenizer.h"
#include "Internal/SerializationTextOutput.h"
#include "Internal/SerializationTextReadVersioned.h"
#include "Internal/SerializationTextReadWriteExact.h"
 
namespace SC
{
struct SC_SERIALIZATION_TEXT_EXPORT SerializationJson;
} // namespace SC
 
 
 
struct SC::SerializationJson
{
    struct SC_SERIALIZATION_TEXT_EXPORT Options
    {
        uint8_t floatDigits; 
        Options() { floatDigits = 2; }
    };
 
    template <typename T, typename B>
    [[nodiscard]] static bool write(T& object, B& buffer, Options options = Options())
    {
        GrowableBuffer<B>       gb = {buffer};
        SerializationTextOutput output(gb);
 
        Writer stream(output, options);
        if (not stream.onSerializationStart())
        {
            output.onFormatFailed();
            return false;
        }
        if (not Serialization::SerializationTextReadWriteExact<Writer, T>::serialize(0, object, stream))
        {
            output.onFormatFailed();
            return false;
        }
        return stream.onSerializationEnd();
    }
 
    template <typename T>
    [[nodiscard]] static bool loadExact(T& object, StringSpan text)
    {
        Reader stream(text);
        return Serialization::SerializationTextReadWriteExact<Reader, T>::serialize(0, object, stream);
    }
 
    template <typename T>
    [[nodiscard]] static bool loadVersioned(T& object, StringSpan text)
    {
        Reader stream(text);
        return Serialization::SerializationTextReadVersioned<Reader, T, void>::loadVersioned(0, object, stream);
    }
 
  private:
    struct SC_SERIALIZATION_TEXT_EXPORT Writer
    {
        SerializationTextOutput& output;
 
        Writer(SerializationTextOutput& output, Options options) : output(output), options(options) {}
 
        [[nodiscard]] bool onSerializationStart();
        [[nodiscard]] bool onSerializationEnd();
 
        [[nodiscard]] bool setOptions(Options opt);
 
        [[nodiscard]] bool startObject(uint32_t index);
        [[nodiscard]] bool endObject();
 
        [[nodiscard]] bool startArray(uint32_t index);
        [[nodiscard]] bool endArray();
 
        template <typename Container>
        [[nodiscard]] bool startArray(uint32_t index, Container& container, uint32_t& size)
        {
            if (not eventuallyAddComma(index))
                return false;
            size = static_cast<uint32_t>(container.size());
            return output.append("[");
        }
 
        template <typename Container>
        [[nodiscard]] bool endArrayItem(Container&, uint32_t&)
        {
            return true;
        }
 
        [[nodiscard]] bool startObjectField(uint32_t index, StringSpan text);
 
        template <typename T>
        [[nodiscard]]
        typename TypeTraits::EnableIf<not Serialization::SerializationTextIsBaseOf<StringSpan, T>::value,
                                      bool>::type serialize(uint32_t index, T& text)
        {
            return serializeStringSpan(index, text.view());
        }
 
        [[nodiscard]] bool serialize(uint32_t index, StringSpan text);
        [[nodiscard]] bool serialize(uint32_t index, float value);
        [[nodiscard]] bool serialize(uint32_t index, double value);
        [[nodiscard]] bool serialize(uint32_t index, int value);
 
      private:
        [[nodiscard]] bool serializeStringSpan(uint32_t index, StringSpan text);
 
        bool eventuallyAddComma(uint32_t index);
 
        Options options;
    };
 
    struct SC_SERIALIZATION_TEXT_EXPORT Reader
    {
        Reader(StringSpan text) : iteratorText(text), iterator(text) {}
 
        [[nodiscard]] bool onSerializationStart() { return true; }
        [[nodiscard]] bool onSerializationEnd() { return true; }
 
        [[nodiscard]] bool startObject(uint32_t index);
        [[nodiscard]] bool endObject();
 
        [[nodiscard]] bool startArray(uint32_t index);
        [[nodiscard]] bool endArray();
 
        template <typename Container>
        [[nodiscard]] bool startArray(uint32_t index, Container& container, uint32_t& size)
        {
            if (not tokenizeArrayStart(index))
                return false;
            return endArrayItem(container, size);
        }
 
        template <typename Container>
        [[nodiscard]] bool endArrayItem(Container& container, uint32_t& size)
        {
            auto oldSize = size;
            if (not tokenizeArrayEnd(size))
                return false;
            if (oldSize != size)
                return Reflection::ExtendedTypeInfo<Container>::resize(container, size);
            return true;
        }
 
        [[nodiscard]] bool startObjectField(uint32_t index, StringSpan text);
        [[nodiscard]] bool getNextField(uint32_t index, StringSpan& text, bool& hasMore);
 
        [[nodiscard]] bool serialize(uint32_t index, bool& value);
        [[nodiscard]] bool serialize(uint32_t index, float& value);
        [[nodiscard]] bool serialize(uint32_t index, int32_t& value);
        [[nodiscard]] bool serialize(uint32_t index, StringSpan& value);
 
        template <typename T>
        [[nodiscard]]
        typename TypeTraits::EnableIf<not Serialization::SerializationTextIsBaseOf<StringSpan, T>::value,
                                      bool>::type serialize(uint32_t index, T& text)
        {
            bool succeeded;
            auto escaped = serializeInternal(index, succeeded);
            if (not succeeded)
                return false;
 
            GrowableBuffer<T>       gb = {text};
            SerializationTextOutput output(gb);
            gb.clear();
            output.onFormatBegin();
            if (not appendJSONStringUnescaped(escaped, output))
            {
                output.onFormatFailed();
                return false;
            }
            return output.onFormatSucceeded();
        }
 
      private:
        [[nodiscard]] static bool appendJSONStringUnescaped(StringSpan escaped, SerializationTextOutput& output);
        [[nodiscard]] StringSpan  serializeInternal(uint32_t index, bool& succeeded);
 
        [[nodiscard]] bool tokenizeArrayStart(uint32_t index);
        [[nodiscard]] bool tokenizeArrayEnd(uint32_t& size);
        [[nodiscard]] bool eventuallyExpectComma(uint32_t index);
 
        StringSpan            iteratorText;
        JsonTokenizer::Cursor iterator;
    };
};