jsonfilebase.h

Go to the documentation of this file.

 
#ifndef JSONFILEBASE_H
#define JSONFILEBASE_H
 
#include <filesystem>
#include <mutex>
#include <string>
#include <boost/json.hpp>
#include "events/event.h"
#include "ijsonserializable.h"
 
namespace Nickvision::Helpers
{
    class JsonFileBase : public IJsonSerializable
    {
    public:
        JsonFileBase(const std::filesystem::path& path);
        virtual ~JsonFileBase() noexcept = default;
        const std::filesystem::path& getPath() const noexcept;
        Events::Event<Events::EventArgs>& saved() noexcept;
        bool save() noexcept;
        boost::json::value toJson() const noexcept override;
 
    protected:
        bool contains(const std::string& key) const noexcept;
        template<SupportedJsonValue T>
        T get(const std::string& key, const T& defaultValue) const noexcept
        {
            std::lock_guard lock{ m_mutex };
            if constexpr (std::is_same_v<T, int>)
            {
                if(!m_json.contains(key) || !m_json[key].is_int64())
                {
                    return defaultValue;
                }
                return static_cast<int>(m_json[key].as_int64());
            }
            else if constexpr (std::is_same_v<T, std::int64_t>)
            {
                if(!m_json.contains(key) || !m_json[key].is_int64())
                {
                    return defaultValue;
                }
                return m_json[key].as_int64();
            }
            else if constexpr (std::is_same_v<T, double>)
            {
                if(!m_json.contains(key) || !m_json[key].is_double())
                {
                    return defaultValue;
                }
                return m_json[key].as_double();
            }
            else if constexpr (std::is_same_v<T, bool>)
            {
                if(!m_json.contains(key) || !m_json[key].is_bool())
                {
                    return defaultValue;
                }
                return m_json[key].as_bool();
            }
            else if constexpr (std::is_same_v<T, std::string>)
            {
                if(!m_json.contains(key) || !m_json[key].is_string())
                {
                    return defaultValue;
                }
                return std::string(m_json[key].as_string());
            }
            else if constexpr (std::is_same_v<T, boost::json::array>)
            {
                if(!m_json.contains(key) || !m_json[key].is_array())
                {
                    return defaultValue;
                }
                return m_json[key].as_array();
            }
            else if constexpr (std::is_same_v<T, boost::json::object>)
            {
                if(!m_json.contains(key) || !m_json[key].is_object())
                {
                    return defaultValue;
                }
                return m_json[key].as_object();
            }
        }

        template<SupportedJsonValue T>
        void set(const std::string& key, const T& value) noexcept
        {
            std::lock_guard lock{ m_mutex };
            m_json[key] = value;
        }
 
    private:
        mutable std::mutex m_mutex;
        std::filesystem::path m_path;
        mutable boost::json::object m_json;
        Events::Event<Events::EventArgs> m_saved;
    };
}
 
#endif //JSONFILEBASE_H