GoJson.h

Go to the documentation of this file.

#ifndef GO_PXL_SDK_JSON_H
#define GO_PXL_SDK_JSON_H

#include <GoPxLSdk/GoJsonPointer.h>
#include <GoPxLSdk/GoJsonIterator.h>

#define GoJsonTypeSpec(type) \
                        template GoPxLSdkClass type GoJson::Get<type>(); \
                        template GoPxLSdkClass const type GoJson::Get<type>() const; \
                        template GoPxLSdkClass type GoJson::Get<type>(const std::string&); \
                        template GoPxLSdkClass const type GoJson::Get<type>(const std::string&) const; \
                        template GoPxLSdkClass type GoJson::Get<type>(const GoJsonPointer&); \
                        template GoPxLSdkClass const type GoJson::Get<type>(const GoJsonPointer&) const; \
                        template GoPxLSdkClass bool operator==<type>(const GoJson&, const type&); \
                        template GoPxLSdkClass void GoJson::operator=<type>(const type&); \
                        template GoPxLSdkClass void GoJson::Set<type>(const std::string&, const type&); \
                        template GoPxLSdkClass void GoJson::Set<type>(const GoJsonPointer&, const type&); \
                        template GoPxLSdkClass void GoJson::Add<type>(const std::string&, const type&); \
                        template GoPxLSdkClass void GoJson::Replace<type>(const std::string&, const type&);

namespace GoPxLSdk
{
class GoPxLSdkClass GoJson
{
public:
    GoJson();

    explicit GoJson(std::shared_ptr<nlohmann::json> json);

    GoJson(const GoJson& json);

    explicit GoJson(const std::string& data);

    ~GoJson();

    GoJsonIterator Begin();

    const GoJsonIterator Begin() const;

    const GoJsonIterator End() const;

    template<typename T>
    T Get(const std::string& path);

    template<typename T>
    T Get();

    template<typename T>
    const T Get(const std::string& path) const;

    template<typename T>
    T Get(const GoJsonPointer& pointer);

    template<typename T>
    const T Get(const GoJsonPointer& pointer) const;

    template<typename T>
    const T Get() const;

    ByteArray GetBinary();

    template <typename T>
    void Set(const std::string& path, const T& val);

    template <std::size_t N>
    void Set(const std::string& path, const char(&val)[N])
    {
        Set(path, std::string(val));
    }

    template <typename T>
    void Set(const GoJsonPointer& ptr, const T& val);

    template <std::size_t N>
    void Set(const GoJsonPointer& ptr, const char(&val)[N])
    {
        Set(ptr, std::string(val));
    }

    void Set(const std::string& path, const GoJson& val);

    void Set(const GoJsonPointer& ptr, const GoJson& val);

    void Set(const std::string& path, const std::vector<k8u>& val);

    void Set(const GoJsonPointer& ptr, const std::vector<k8u>& val);

    template<typename T>
    void Add(const std::string& path, const T& val);

    template <std::size_t N>
    void Add(const std::string& path, const char(&val)[N])
    {
        Add(path, std::string(val));
    }

    template<typename T>
    void Replace(const std::string& path, const T& val);

    template <std::size_t N>
    void Replace(const std::string& path, const char(&val)[N])
    {
        Replace(path, std::string(val));
    }

    bool HasKey(const std::string& key) const;

    void Copy(const std::string& source, const std::string& destination);

    void Move(const std::string& source, const std::string& destination);

    void Remove(const std::string& path);

    void Patch(const GoJson& obj);

    void Merge(const GoJson& obj);

    const bool Empty() const;

    GoJsonIterator Find(const std::string& key);

    GoJsonIterator Find(const GoJsonPointer& pointer);

    const GoJsonIterator Find(const std::string& key) const;

    const GoJsonIterator Find(const GoJsonPointer& pointer) const;

    GoJson At(int index);

    const GoJson At(int index) const;

    GoJson At(const std::string& path);

    const GoJson At(const std::string& path) const;

    GoJson At(const GoJsonPointer& pointer);

    const GoJson At(const GoJsonPointer& pointer) const;

    const bool Contains(const GoJsonPointer& pointer) const;

    const size_t Size() const;

    const bool IsObject() const;

    const bool IsNumber() const;

    const bool IsFloat() const;

    const bool IsInteger() const;

    const bool IsUnsigned() const;

    const bool IsBoolean() const;

    const bool IsString() const;

    const bool IsArray() const;

    const bool IsPrimitive() const;

    const bool IsBinary() const;

    const bool IsDiscarded() const;

    const bool IsNull() const;

    const bool IsStructured() const;

    const bool IsObject(const std::string& path) const;

    const bool IsNumber(const std::string& path) const;

    const bool IsFloat(const std::string& path) const;

    const bool IsInteger(const std::string& path) const;

    const bool IsUnsigned(const std::string& path) const;

    const bool IsBoolean(const std::string& path) const;

    const bool IsString(const std::string& path) const;

    const bool IsArray(const std::string& path) const;

    const bool IsPrimitive(const std::string& path) const;

    const bool IsBinary(const std::string& path) const;

    const bool IsDiscarded(const std::string& path) const;

    const bool IsNull(const std::string& path) const;

    const bool IsStructured(const std::string& path) const;

    void Flatten();

    void Unflatten();

    const std::string ToString();

    const std::string ToString() const;

    const ByteArray ToBinary();

    static GoJson ParseString(const std::string& data);

    static GoJson ParseMsgPack(const ByteArray& data);

    template<typename T>
    friend bool operator==(const GoJson& left, const T& right);

    template <std::size_t N>
    friend bool operator==(const GoJson& left, const char(&val)[N])
    {
        return left == std::string(val);
    }

    friend std::ostream& operator<<(std::ostream& os, const GoJson& json)
    {
        os << json.ToString();

        return os;
    }

    template<typename T>
    void operator=(const T& left);

    template <std::size_t N>
    void operator=(const char(&val)[N])
    {
        return *this = std::string(val);
    }

protected:
    const std::shared_ptr<nlohmann::json> GetHandle(const std::string& path) const;

    const std::shared_ptr<nlohmann::json>& GetHandle() const;

    std::shared_ptr<nlohmann::json> GetHandle(const std::string& path);

    std::shared_ptr<nlohmann::json>& GetHandle();

    friend class GoRequest;
    friend class GoJsonIterator;

private:
    mutable std::shared_ptr<nlohmann::json> jsonHandle;
};

}

#endif