json.hpp

Go to the documentation of this file.

#pragma once
 
#include "commons/base_includes.hpp"
#include "commons/associative_containers_includes.hpp"
#include "commons/json_includes.hpp"
 
namespace corelink
{
    namespace utils
    {
        class CORELINK_EXPORT json
        {
            rapidjson::Document m_document;
        public:
            explicit json(bool root_type_array = false)
            {
                if (root_type_array)
                    m_document.SetArray();
                else
                    m_document.SetObject();
            }
 
            explicit json(in<std::string> json_str)
            {
                m_document.Parse(json_str.c_str(), json_str.size());
            }
 
            json(rvref<json> rhs) noexcept
                    : m_document(std::move(rhs.m_document))
            {}
 
            json &operator=(rvref<json> rhs) noexcept
            {
                m_document = std::move(rhs.m_document);
                return *this;
            }
 
            json &operator=(clvref<json> rhs)
            {
                m_document.CopyFrom(rhs.m_document, m_document.GetAllocator());
                return *this;
            }
 
            json(clvref<json> rhs)
            {
                (*this) = rhs; // use the copy assignment operator.
            }
 
            ~json() = default;
 
            rapidjson::Document &operator()()
            {
                return m_document;
            }
 
            clvref<rapidjson::Document> operator()() const
            {
                return m_document;
            }
 
            inline int32_t get_int(in<std::string> name, int32_t def_val = 0) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsInt()
                       ? member->value.GetInt() : def_val;
            }
 
            inline int64_t get_int64(in<std::string> name, int64_t def_val = 0) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsInt64()
                       ? member->value.GetInt64() : def_val;
            }
 
            inline std::string get_str(in<std::string> name, in<std::string> def_val = "") const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsString()
                       ? member->value.GetString() : def_val;
            }
 
            inline double get_double(in<std::string> name, double def_val = 0.0) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsDouble()
                       ? member->value.GetDouble() : def_val;
            }
 
            inline bool get_bool(in<std::string> name, bool def_val = false) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsBool()
                       ? member->value.GetBool() : def_val;
            }
 
            inline uint32_t get_uint(in<std::string> name, uint32_t def_val = false) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsUint()
                       ? member->value.GetUint() : def_val;
            }
 
            inline uint64_t get_uint64(in<std::string> name, uint64_t def_val = false) const
            {
                auto member = m_document.FindMember(name.c_str());
                return member != m_document.MemberEnd()
                       && member->value.IsUint64()
                       ? member->value.GetUint64() : def_val;
            }
 
            bool try_parse(const std::string &json_str, std::string &error) noexcept
            {
                try
                {
                    m_document.Parse(json_str.c_str(), json_str.size());
                    return true;
                }
                catch (const std::exception &e)
                {
                    error += e.what();
                }
                return false;
            }
 
            std::string to_string(bool pretty_print = false) const
            {
                rapidjson::StringBuffer sb;
                if (pretty_print)
                {
                    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
                    m_document.Accept(writer);
 
                }
                else
                {
                    rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
                    m_document.Accept(writer);
                }
                return sb.GetString();
            }
 
            template<class T>
            json &append(const std::vector<std::map<std::string, T>> &arr_items)
            {
                if (m_document.IsArray() && !arr_items.empty())
                {
                    for (auto &arr_item: arr_items)
                    {
                        if (!arr_item.empty())
                        {
                            rapidjson::Value my_value(rapidjson::kObjectType);
                            for (auto &obj_item: arr_item)
                            {
                                my_value.AddMember(
                                        rapidjson::Value(obj_item.first.c_str(), m_document.GetAllocator()),
                                        rapidjson::Value(obj_item.second),
                                        m_document.GetAllocator()
                                );
                            }
                            m_document.PushBack(my_value.Move(), m_document.GetAllocator());
                        }
                    }
                }
                return *this;
            }
 
            json &append(const std::vector<std::map<std::string, std::string>> &arr_items)
            {
                if (m_document.IsArray() && !arr_items.empty())
                {
                    for (auto &arr_item: arr_items)
                    {
                        if (arr_item.empty())
                            continue;
 
                        rapidjson::Value my_value(rapidjson::kObjectType);
                        for (auto &obj_item: arr_item)
                        {
                            my_value.AddMember(
                                    rapidjson::Value(obj_item.first.c_str(), m_document.GetAllocator()),
                                    rapidjson::Value(obj_item.second.c_str(), m_document.GetAllocator()),
                                    m_document.GetAllocator()
                            );
                        }
                        m_document.PushBack(my_value.Move(), m_document.GetAllocator());
                    }
                }
                return *this;
            }
 
            template<class T>
            json &append(const std::vector<std::map<std::string, std::vector<T>>> &arr_items)
            {
                if (m_document.IsArray() && !arr_items.empty())
                {
                    for (auto &arr_item: arr_items)
                    {
                        if (arr_item.empty())
                            continue;
 
                        rapidjson::Value my_object(rapidjson::kObjectType);
                        for (auto &map_item: arr_item)
                        {
                            if (map_item.first.empty())
                                continue;
 
                            rapidjson::Value my_arr_value(rapidjson::kArrayType);
                            for (auto &one_value: map_item.second)
                            {
                                my_arr_value.PushBack(rapidjson::Value(one_value).Move(), m_document.GetAllocator());
                            }
                            my_object.AddMember(
                                    rapidjson::Value(map_item.first.c_str(), m_document.GetAllocator()),
                                    my_arr_value,
                                    m_document.GetAllocator()
                            );
                        }
                        m_document.PushBack(my_object, m_document.GetAllocator());
                    }
                }
                return *this;
            }
 
            json &append(const std::vector<std::map<std::string, std::vector<std::string>>> &arr_items)
            {
                if (m_document.IsArray() && !arr_items.empty())
                {
                    for (auto &arr_item: arr_items)
                    {
                        if (arr_item.empty())
                            continue;
 
                        rapidjson::Value my_object(rapidjson::kObjectType);
                        for (auto &map_item: arr_item)
                        {
                            if (map_item.first.empty())
                                continue;
 
                            rapidjson::Value my_arr_value(rapidjson::kArrayType);
                            for (auto &one_value: map_item.second)
                            {
                                my_arr_value.PushBack(
                                        rapidjson::Value(one_value.c_str(), m_document.GetAllocator()).Move(),
                                        m_document.GetAllocator());
                            }
                            my_object.AddMember(
                                    rapidjson::Value(map_item.first.c_str(), m_document.GetAllocator()),
                                    my_arr_value,
                                    m_document.GetAllocator()
                            );
                        }
                        m_document.PushBack(my_object, m_document.GetAllocator());
                    }
                }
                return *this;
            }
 
            template<class T>
            json &append(const std::string &key, const T &val)
            {
                if (!key.empty())
                {
                    if (m_document.IsObject() && !m_document.HasMember(key.c_str()))
                    {
                        m_document.AddMember(
                                rapidjson::Value(key.c_str(), m_document.GetAllocator()),
                                rapidjson::Value(val),
                                m_document.GetAllocator());
                    }
                    else if (m_document.IsArray())
                    {
                        std::map<std::string, T> mp = {
                                std::make_pair(key, val)
                        };
                        std::vector<std::map<std::string, T>> vec = {mp};
                        append(vec);
                    }
                }
                return *this;
            }
 
            json &append(const std::string &key, const std::string &val)
            {
                if (!key.empty())
                {
                    if (m_document.IsObject() && !m_document.HasMember(key.c_str()))
                    {
                        m_document.AddMember(
                                rapidjson::Value(key.c_str(), m_document.GetAllocator()),
                                rapidjson::Value(val.c_str(), m_document.GetAllocator()),
                                m_document.GetAllocator()
                        );
                    }
                    else if (m_document.IsArray())
                    {
                        std::map<std::string, std::string> mp = {
                                std::make_pair(key, val)
                        };
                        append({mp});
                    }
                }
                return *this;
            }
 
            template<class T>
            json &append(const std::string &key, const std::vector<T> &val)
            {
                if (!key.empty())
                {
                    if (m_document.IsObject() && !m_document.HasMember(key.c_str()))
                    {
                        rapidjson::Value value(rapidjson::kArrayType);
                        if (!val.empty())
                        {
                            for (auto &arr_item: val)
                                value.PushBack(rapidjson::Value(arr_item).Move(), m_document.GetAllocator());
                        }
                        m_document.AddMember(
                                rapidjson::Value(key.c_str(), m_document.GetAllocator()),
                                value,
                                m_document.GetAllocator());
                    }
                    else if (m_document.IsArray())
                    {
                        std::map<std::string, std::vector<T>> mp = {
                                std::make_pair(key, val)
                        };
                        std::vector<decltype(mp)> vec = {mp};
                        append(vec);
                    }
                }
                return *this;
            }
 
            json &append(const std::string &key, const std::vector<std::string> &val)
            {
                if (!key.empty())
                {
                    if (m_document.IsObject() && !m_document.HasMember(key.c_str()))
                    {
                        rapidjson::Value value(rapidjson::kArrayType);
                        if (!val.empty())
                        {
                            for (auto &arr_item: val)
                                value.PushBack(
                                        rapidjson::Value(arr_item.c_str(), m_document.GetAllocator()),
                                        m_document.GetAllocator()
                                );
                        }
                        m_document.AddMember(
                                rapidjson::Value(key.c_str(), m_document.GetAllocator()),
                                value,
                                m_document.GetAllocator());
                    }
                    else if (m_document.IsArray())
                    {
                        std::map<std::string, std::vector<std::string>> mp = {
                                std::make_pair(key, val)
                        };
                        std::vector<decltype(mp)> vec = {mp};
                        append(vec);
                    }
                }
                return *this;
            }
 
            template<class T>
            json &append(const std::map<std::string, T> &kv_items)
            {
                if (!kv_items.empty())
                {
                    if (m_document.IsObject())
                    {
                        for (auto &item: kv_items)
                        {
                            m_document.AddMember(rapidjson::Value(item.first.c_str(), m_document.GetAllocator()),
                                                 rapidjson::Value(item.second),
                                                 m_document.GetAllocator());
                        }
                    }
                    else if (m_document.IsArray())
                    {
                        append(
                                {kv_items}
                        );
                    }
                }
                return *this;
            }
 
            json &append(const std::map<std::string, std::string> &kv_items)
            {
                if (!kv_items.empty())
                {
                    if (m_document.IsObject())
                    {
                        for (auto &item: kv_items)
                        {
                            m_document.AddMember(
                                    rapidjson::Value(item.first.c_str(), m_document.GetAllocator()),
                                    rapidjson::Value(item.second.c_str(), m_document.GetAllocator()),
                                    m_document.GetAllocator()
                            );
                        }
                    }
                    else if (m_document.IsArray())
                    {
                        std::vector<std::map<std::string, std::string>> v{kv_items};
                        append(v);
                    }
                }
                return *this;
            }
 
            template<class T>
            json &append(const std::map<std::string, std::vector<T>> &kv_items)
            {
                if (!kv_items.empty())
                {
                    if (m_document.IsObject())
                    {
                        for (auto &item: kv_items)
                        {
                            rapidjson::Value value(rapidjson::kArrayType);
                            for (const T &arr_item: item.second)
                            {
                                value.PushBack(rapidjson::Value(arr_item).Move(), m_document.GetAllocator());
                            }
 
                            m_document.AddMember(rapidjson::Value(item.first.c_str(), m_document.GetAllocator()), value,
                                                 m_document.GetAllocator());
                        }
                    }
                    else if (m_document.IsArray())
                    {
                        append({kv_items});
                    }
                }
                return *this;
            }
 
            json &append(const std::map<std::string, std::vector<std::string>> &kv_items)
            {
                if (!kv_items.empty())
                {
                    if (m_document.IsObject())
                    {
                        for (auto &item: kv_items)
                        {
                            rapidjson::Value value(rapidjson::kArrayType);
                            if (item.second.empty())
                                continue;
                            for (auto &arr_item: item.second)
                            {
                                value.PushBack(rapidjson::Value(
                                                       arr_item.c_str(),
                                                       m_document.GetAllocator()
                                               ).Move(),
                                               m_document.GetAllocator());
                            }
 
                            m_document.AddMember(rapidjson::Value(item.first.c_str(), m_document.GetAllocator()), value,
                                                 m_document.GetAllocator());
                        }
                    }
                    else if (m_document.IsArray())
                    {
                        std::vector<std::map<std::string, std::vector<std::string>>> v{kv_items};
                        append(v);
                    }
                }
                return *this;
            }
 
            CORELINK_CPP_ATTR_MAYBE_UNUSED
            json &remove(const std::string &key)
            {
                if (!key.empty() && m_document.IsObject())
                {
                    if (m_document.HasMember(key.c_str()))
                        m_document.RemoveMember(key.c_str());
                }
                return *this;
            }
 
            CORELINK_CPP_ATTR_MAYBE_UNUSED json &clear()
            {
                if (!m_document.Empty())
                    m_document.Clear();
                return *this;
            }
        };
    }
}