Writer.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <memory>
#include <optional>
#include <type_traits>
#include <vector>
 
namespace inno
{
    class Writer;
    class Image;

     */
    class Serializable
    {
    public:
        virtual void WriteTo(Writer& writer) const = 0;
 
        Serializable(const Serializable&) = default;
        Serializable(Serializable&&) = default;
        Serializable& operator=(const Serializable&) = default;
        Serializable& operator=(Serializable&&) = default;
        Serializable() = default;
        virtual ~Serializable() = default;
    };

     */
    class BytesWriterStrategy
    {
    public:
        virtual void WriteBytes(Writer& writer, const char* name, const std::vector<uint8_t>& value) = 0;
 
        BytesWriterStrategy(const BytesWriterStrategy&) = default;
        BytesWriterStrategy(BytesWriterStrategy&&) = default;
        BytesWriterStrategy& operator=(const BytesWriterStrategy&) = default;
        BytesWriterStrategy& operator=(BytesWriterStrategy&&) = default;
        BytesWriterStrategy() = default;
        virtual ~BytesWriterStrategy() = default;
    };
 
#ifndef SWIG
    template<typename T>
    concept IsIterable = requires(T a) {
        begin(a); // Requires 'begin' function
        end(a);   // Requires 'end' function
    };
    template<typename T>
    concept IsNotIterable = !IsIterable<T>;
#endif

     */
    class Writer
    {
    public:
        virtual void Write(const char* name, const Serializable& s) = 0;
        virtual void WriteRoot(Serializable& s) = 0;

        virtual void Write(const char* name, const char* value) = 0;
        virtual void Write(const char* name, int value) = 0;
        virtual void Write(const char* name, unsigned int value) = 0;
        virtual void Write(const char* name, double value) = 0;
        virtual void Write(const char* name, int64_t value) = 0;
        virtual void Write(const char* name, uint64_t value) = 0;
        virtual void Write(const char* name, const std::shared_ptr<Image>& value) = 0;
        virtual void WriteNull(const char* name) = 0;
         */
        void WriteArray(const char* name, const std::vector<uint8_t>& value)
        {
            bytesStrategy->WriteBytes(*this, name, value);
        }
         */
        void SetBytesStrategy(BytesWriterStrategy& s)
        {
            bytesStrategy = &s;
        }
        template<typename T>
        void WriteArray(const char* name, const T& array);

         */
        void Write(const char* name, const std::shared_ptr<const Serializable>& s)
        {
            if (s != nullptr)
            {
                Write(name, *s);
            }
            else
            {
                WriteNull(name);
            }
        }

        template<typename T>
        void Write(const char* name, const std::optional<T>& s)
        {
            if (s.has_value())
            {
                Write(name, s.value());
            }
            else
            {
                WriteNull(name);
            }
        }
 
        Writer(const Writer&) = default;
        Writer(Writer&&) = default;
        Writer& operator=(const Writer&) = default;
        Writer& operator=(Writer&&) = default;
        Writer()
          : bytesStrategy(&defaultBytesStrategy)
        {
        }
        virtual ~Writer() = default;
 
    protected:
        virtual void StartArray(const char* name) = 0;
        virtual void EndArray() = 0;
 
    private:
#ifndef SWIG
        template<typename T>
            requires IsIterable<T>
        void WriteInWriter(T& value)
        {
            WriteArray("", value);
        }
        template<typename T>
            requires IsNotIterable<T>
        void WriteInWriter(T& value)
        {
            Write("", value);
        }
#endif
 
        class DefaultBytesStrategy : public BytesWriterStrategy
        {
        public:
            void WriteBytes(Writer& writer, const char* name, const std::vector<uint8_t>& value) final
            {
                writer.WriteArray<>(name, value);
            }
 
            DefaultBytesStrategy(const DefaultBytesStrategy&) = default;
            DefaultBytesStrategy(DefaultBytesStrategy&&) = default;
            DefaultBytesStrategy& operator=(const DefaultBytesStrategy&) = default;
            DefaultBytesStrategy& operator=(DefaultBytesStrategy&&) = default;
            DefaultBytesStrategy() = default;
            virtual ~DefaultBytesStrategy() = default;
        };
 
        DefaultBytesStrategy defaultBytesStrategy;
        BytesWriterStrategy* bytesStrategy;
    };
 
    // MUST be here to be possible to override it with non template function
    template<typename T>
    void Writer::WriteArray(const char* name, const T& array)
    {
        StartArray(name);
        for (auto& e : array)
        {
            WriteInWriter(e);
        }
        EndArray();
    }
} // namespace inno