SerializationJson.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Strings/StringFormat.h" //StringFormatOutput
#include "Internal/SerializationTextReadVersioned.h"
#include "Internal/SerializationTextReadWriteExact.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT SerializationJson;
} // namespace SC
 
 
 
struct SC::SerializationJson
{
    struct SC_COMPILER_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};
        StringFormatOutput output(StringEncoding::Ascii, gb);
 
        Writer stream(output, options);
        if (not stream.onSerializationStart())
            return false;
        if (not Serialization::SerializationTextReadWriteExact<Writer, T>::serialize(0, object, stream))
            return false;
        return stream.onSerializationEnd();
    }
 
    template <typename T>
    [[nodiscard]] static bool loadExact(T& object, StringView text)
    {
        Reader stream(text);
        return Serialization::SerializationTextReadWriteExact<Reader, T>::serialize(0, object, stream);
    }
 
    template <typename T>
    [[nodiscard]] static bool loadVersioned(T& object, StringView text)
    {
        Reader stream(text);
        return Serialization::SerializationTextReadVersioned<Reader, T>::loadVersioned(0, object, stream);
    }
 
  private:
    struct SC_COMPILER_EXPORT Writer
    {
        StringFormatOutput& output;
 
        Writer(StringFormatOutput& 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("["_a8);
        }
 
        template <typename Container>
        [[nodiscard]] bool endArrayItem(Container&, uint32_t&)
        {
            return true;
        }
 
        [[nodiscard]] bool startObjectField(uint32_t index, StringView text);
 
        template <typename T>
        [[nodiscard]] bool serialize(uint32_t index, T& text)
        {
            return serializeStringView(index, text.view());
        }
 
        [[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 serializeStringView(uint32_t index, StringView text);
 
        bool eventuallyAddComma(uint32_t index);
 
        char       floatFormatStorage[5];
        StringSpan floatFormat;
        Options    options;
    };
 
    struct SC_COMPILER_EXPORT Reader
    {
        Reader(StringView text) : iteratorText(text), iterator(text.getIterator<StringIteratorASCII>()) {}
 
        [[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, StringView 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);
 
        template <typename T>
        [[nodiscard]] bool serialize(uint32_t index, T& text)
        {
            bool succeeded;
            auto result = serializeInternal(index, succeeded);
            return succeeded and text.assign(result);
        }
 
      private:
        [[nodiscard]] StringView serializeInternal(uint32_t index, bool& succeeded);
 
        [[nodiscard]] bool tokenizeArrayStart(uint32_t index);
        [[nodiscard]] bool tokenizeArrayEnd(uint32_t& size);
        [[nodiscard]] bool eventuallyExpectComma(uint32_t index);
 
        StringView          iteratorText;
        StringIteratorASCII iterator;
    };
};