JsonWriter.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Serialization/Writer.h"
 
namespace inno
{
    extern "C"
    {
        struct inno_JsonWriterImpl;
 
        // Functions suitable for DLL interface
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteNull(inno_JsonWriterImpl* impl, const char* name);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteInt(inno_JsonWriterImpl* impl, const char* name, int value);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteString(inno_JsonWriterImpl* impl,
                                                             const char* name,
                                                             const char* value);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteUInt(inno_JsonWriterImpl* impl,
                                                           const char* name,
                                                           unsigned int value);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteDouble(inno_JsonWriterImpl* impl, const char* name, double value);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteLongInt(inno_JsonWriterImpl* impl,
                                                              const char* name,
                                                              int64_t value);
        INNO_ENROLLMENT_API void inno_JsonWriter_WriteLongUint(inno_JsonWriterImpl* impl,
                                                               const char* name,
                                                               uint64_t value);
        INNO_ENROLLMENT_API void inno_JsonWriter_StartArray(inno_JsonWriterImpl* impl, const char* name);
        INNO_ENROLLMENT_API void inno_JsonWriter_EndArray(inno_JsonWriterImpl* impl);
        INNO_ENROLLMENT_API void inno_JsonWriter_StartObject(inno_JsonWriterImpl* impl, const char* name);
        INNO_ENROLLMENT_API void inno_JsonWriter_EndObject(inno_JsonWriterImpl* impl);
        INNO_ENROLLMENT_API const char* inno_JsonWriter_Output(inno_JsonWriterImpl* impl);
        INNO_ENROLLMENT_API inno_JsonWriterImpl* inno_JsonWriter_Construct();
        INNO_ENROLLMENT_API void inno_JsonWriter_Destruct(inno_JsonWriterImpl* impl);
    }

     */
    class JsonWriter final : public Writer
    {
    public:
         */
        [[nodiscard]] const char* Output() const
        {
            return inno_JsonWriter_Output(impl.get());
        }
 
        void Write(const char* name, const Serializable& s) final
        {
            StartObject(name);
            s.WriteTo(*this);
            EndObject();
        }
 
        void WriteRoot(Serializable& s) final
        {
            StartObject("");
            s.WriteTo(*this);
            EndObject();
        }
        void WriteNull(const char* name) final
        {
            inno_JsonWriter_WriteNull(impl.get(), name);
        }
        void Write(const char* name, const char* value) final
        {
            inno_JsonWriter_WriteString(impl.get(), name, value);
        }
        void Write(const char* name, int value) final
        {
            inno_JsonWriter_WriteInt(impl.get(), name, value);
        }
        void Write(const char* name, unsigned int value) final
        {
            inno_JsonWriter_WriteUInt(impl.get(), name, value);
        }
        void Write(const char* name, double value) final
        {
            inno_JsonWriter_WriteDouble(impl.get(), name, value);
        }
        void Write(const char* name, int64_t value) final
        {
            inno_JsonWriter_WriteLongInt(impl.get(), name, value);
        }
        void Write(const char* name, uint64_t value) final
        {
            inno_JsonWriter_WriteLongUint(impl.get(), name, value);
        }
        void Write(const char* name, const std::shared_ptr<Image>& image) final
        {
            if (image != nullptr)
            {
                auto encoder = image->OriginalEncoder();
                WriteArray(name, encoder->Encode(image->AsRawImage()));
            }
            else
            {
                WriteNull(name);
            }
        }
         */
        JsonWriter()
          : impl(inno_JsonWriter_Construct(), inno_JsonWriter_Destruct)
        {
        }
        JsonWriter(const JsonWriter&) = delete;
        JsonWriter(JsonWriter&&) = delete;
        JsonWriter& operator=(const JsonWriter&) = delete;
        JsonWriter& operator=(JsonWriter&&) = delete;
        virtual ~JsonWriter() = default;
 
    private:
        std::unique_ptr<inno_JsonWriterImpl, void (*)(inno_JsonWriterImpl*)> impl;
 
        void StartObject(const char* name)
        {
            inno_JsonWriter_StartObject(impl.get(), name);
        }
        void EndObject()
        {
            inno_JsonWriter_EndObject(impl.get());
        }
        void StartArray(const char* name) final
        {
            inno_JsonWriter_StartArray(impl.get(), name);
        }
        void EndArray() final
        {
            inno_JsonWriter_EndArray(impl.get());
        }
    };
} // namespace inno