cafJsonSerializer.h

// ##################################################################################################
//
//    Caffa
//    Copyright (C) 2021- 3D-Radar AS
//
//    GNU Lesser General Public License Usage
//    This library is free software; you can redistribute it and/or modify
//    it under the terms of the GNU Lesser General Public License as published by
//    the Free Software Foundation; either version 2.1 of the License, or
//    (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful, but WITHOUT ANY
//    WARRANTY; without even the implied warranty of MERCHANTABILITY or
//    FITNESS FOR A PARTICULAR PURPOSE.
//
//    See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
//    for more details.
//
#pragma once

#include "cafObjectHandle.h"

#include <nlohmann/json.hpp>

#include <chrono>
#include <fstream>
#include <set>
#include <string>

namespace caffa
{
class FieldHandle;
class ObjectFactory;

class JsonSerializer
{
public:
    enum class SerializationType
    {
        DATA_FULL,
        DATA_SKELETON,
        SCHEMA,
        PATH
    };

    using FieldSelector = std::function<bool( const FieldHandle* )>;

    static std::string serializationTypeLabel( SerializationType type );

public:
    JsonSerializer( ObjectFactory* objectFactory = nullptr );
    template <DerivesFromObjectHandle ObjectType>
    std::shared_ptr<ObjectType> cloneObject( const ObjectType* object ) const
    {
        auto basePointer = copyAndCastBySerialization( object, ObjectType::classKeywordStatic() );
        return std::dynamic_pointer_cast<ObjectType>( basePointer );
    }

    JsonSerializer& setFieldSelector( FieldSelector fieldSelector );

    JsonSerializer& setSerializationType( SerializationType type );

    JsonSerializer& setSerializeUuids( bool serializeUuids );

    ObjectFactory* objectFactory() const;

    FieldSelector fieldSelector() const;

    SerializationType serializationType() const;

    bool serializeUuids() const;

    JsonSerializer& setClient( bool client );
    bool            isClient() const;

    std::string readUUIDFromObjectString( const std::string& string ) const;

    void readObjectFromString( ObjectHandle* object, const std::string& string ) const;

    std::string writeObjectToString( const ObjectHandle* object ) const;

    std::shared_ptr<ObjectHandle> copyBySerialization( const ObjectHandle* object ) const;

    std::shared_ptr<ObjectHandle> copyAndCastBySerialization( const ObjectHandle* object,
                                                              const std::string&  destinationClassKeyword ) const;

    std::shared_ptr<ObjectHandle> createObjectFromString( const std::string& string ) const;

    void readStream( ObjectHandle* object, std::istream& stream ) const;

    void writeStream( const ObjectHandle* object, std::ostream& stream ) const;

    void readObjectFromJson( ObjectHandle* object, const nlohmann::json& jsonObject ) const;
    void writeObjectToJson( const ObjectHandle* object, nlohmann::json& jsonObject ) const;

protected:
    bool           m_client;
    ObjectFactory* m_objectFactory;
    FieldSelector  m_fieldSelector;

    SerializationType m_serializationType;
    bool              m_serializeUuids;
};

} // End of namespace caffa

namespace nlohmann
{
template <typename Clock, typename Duration>
struct adl_serializer<std::chrono::time_point<Clock, Duration>>
{
    static void to_json( json& j, const std::chrono::time_point<Clock, Duration>& tp )
    {
        j = std::chrono::duration_cast<Duration>( tp.time_since_epoch() ).count();
    }

    static void from_json( const json& j, std::chrono::time_point<Clock, Duration>& tp )
    {
        Duration duration( j.get<int64_t>() );
        tp = std::chrono::steady_clock::time_point( duration );
    }
};

template <typename IntType, typename Period>
struct adl_serializer<std::chrono::duration<IntType, Period>>
{
    static void to_json( json& j, const std::chrono::duration<IntType, Period>& duration )
    {
        j = static_cast<IntType>( duration.count() );
    }

    static void from_json( const json& j, std::chrono::duration<IntType, Period>& duration )
    {
        duration = std::chrono::duration<IntType, Period>( j.get<IntType>() );
    }
};

} // namespace nlohmann