Json.hpp

Go to the documentation of this file.

#pragma once
#include <variant>
#include <memory>
#include <vector>
#include <string>
#include <optional>
#include <expected>
#include <concepts>
#include <span>
 
#include <Thoth/NJson/Definitions.hpp>
#include <Thoth/Http/RequestError.hpp>
 
namespace Thoth::NJson {
 
    struct Json{
        using Value = std::variant<Null, String, Number, Bool, Object, Array>;
        using PredicatePointer = bool(*)(const Json&);
 
        // NOLINTBEGIN(*)
        Json();
        Json(const JsonObject& child);
        Json(JsonObject&& child);
 
        Json(const Array& child);
        Json(Array&& child);
 
        Json(Value&& newValue) noexcept;
        Json(const Value& newValue);
        Json(Json&& other) noexcept;
        Json(const Json& other);
 
        Json(bool other);
        template<class T>
            requires std::floating_point<T> || std::integral<T> && (!std::same_as<T, bool>)
        Json(T other);
        template<class T>
            requires std::constructible_from<std::string, T>
        Json(T&& other);
 
        Json& operator=(const JsonObject& other);
        Json& operator=(JsonObject&& other);
 
        Json& operator=(const Array& child);
        Json& operator=(Array&& child);
 
        Json& operator=(Value&& newValue) noexcept;
        Json& operator=(const Value& newValue);
        Json& operator=(Json&& other) noexcept;
        Json& operator=(const Json& other);
 
        Json& operator=(bool other);
        template<class T>
            requires std::floating_point<T> || std::integral<T> && (!std::same_as<T, bool>)
        Json& operator=(T other);
        template<class T>
            requires std::constructible_from<std::string, T>
        Json& operator=(T&& other);
 
 
        operator Value&();
        [[nodiscard]] operator const Value&() const;
        // NOLINTEND(*)
 
        template<class T>
        static bool IsOfType(const Json& val);
        template<class T>
        [[nodiscard]] bool IsOf() const;
 
        template<class T>
        static T& AsType(Json& val);
        template<class T>
        [[nodiscard]] T& As();
        template<class T>
        [[nodiscard]] const T& As() const;
 
        template<class T>
        [[nodiscard]] T& AsMut();
        template<class T>
        [[nodiscard]] T AsMov() &&;
        template<class T>
        [[nodiscard]] const T& AsRef() const;
 
        template<class T>
        std::optional<T*> Ensure();
        template<class T>
        std::optional<T*> Ensure() const;
 
        template<class T>
        std::optional<T*> EnsureMut();
        template<class T>
        std::optional<T> EnsureMov() &&;
        template<class T>
        std::optional<const T*> EnsureRef() const;
 
        template<class T>
        std::expected<T*, Http::RequestError> EnsureOrError();
        template<class T>
        std::expected<T*, Http::RequestError> EnsureOrError() const;
 
        template<class T>
        std::expected<T*, Http::RequestError> EnsureMutOrError();
        template<class T>
        std::expected<T, Http::RequestError> EnsureMovOrError() &&;
        template<class T>
        std::expected<const T*, Http::RequestError> EnsureRefOrError() const;
 
        [[nodiscard]] bool operator==(const Json& other) const;
 
        static std::expected<Json, Http::RequestError> Parse(std::string_view input);
 
 
        static std::expected<Json, Http::RequestError> ParseText(std::string_view input, bool copyData = true, bool checkFinal = true);
 
 
#pragma region Get Functions
 
        OptRefValWrapper Get(Key key);
        [[nodiscard]] OptCRefValWrapper Get(Key key) const;
        [[nodiscard]] OptValWrapper GetCopy(Key key) const;
        OptValWrapper GetAndMove(Key key) &&;
 
 
        [[nodiscard]] ValWrapper GetCopyOrNull(Key key) const;
        ValWrapper GetAndMoveOrNull(Key key) &&;
 
 
        ExpRefValWrapper GetOrError(Key key);
        [[nodiscard]] ExpCRefValWrapper GetOrError(Key key) const;
        [[nodiscard]] ExpValWrapper GetCopyOrError(Key key) const;
        ExpValWrapper GetAndMoveOrError(Key key) &&;
 
 
#pragma endregion
 
#pragma region Find Functions
 
        OptRefValWrapper Find(Keys keys);
        [[nodiscard]] OptCRefValWrapper Find(Keys keys) const;
        [[nodiscard]] OptValWrapper FindCopy(Keys keys) const;
        OptValWrapper FindAndMove(Keys keys) &&;
 
 
        [[nodiscard]] ValWrapper FindCopyOrNull(Keys keys) const;
        ValWrapper FindAndMoveOrNull(Keys keys) &&;
 
 
        ExpRefValWrapper FindOrError(Keys keys);
        [[nodiscard]] ExpCRefValWrapper FindOrError(Keys keys) const;
        [[nodiscard]] ExpValWrapper FindCopyOrError(Keys keys) const;
        ExpValWrapper FindAndMoveOrError(Keys keys) &&;
 
#pragma endregion
 
#pragma region Search Functions
 
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        OptRefValWrapper Search(Pred&& pred);
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        [[nodiscard]] OptCRefValWrapper Search(Pred&& pred) const;
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        [[nodiscard]] OptValWrapper SearchCopy(Pred&& pred) const;
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        OptValWrapper SearchAndMove(Pred&& pred) &&;
 
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        [[nodiscard]] ValWrapper SearchCopyOrNull(Pred&& pred) const;
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        ValWrapper SearchAndMoveOrNull(Pred&& pred);
 
 
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        ExpRefValWrapper SearchOrError(Pred&& pred);
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        [[nodiscard]] ExpCRefValWrapper SearchOrError(Pred&& pred) const;
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        [[nodiscard]] ExpValWrapper SearchCopyOrError(Pred&& pred) const;
        template<class Pred = PredicatePointer> requires std::predicate<Pred, Json>
        ExpValWrapper SearchAndMoveOrError(Pred&& pred) &&;
 
#pragma endregion
 
 
        template<class Callable>
        constexpr decltype(auto) Visit(Callable&& callable);
 
        template<class Callable>
        [[nodiscard]] constexpr decltype(auto) Visit(Callable&& callable) const;
    private:
        Value _value;
    };
 
    inline static constexpr Null NullV{};
    inline static Json NullJ{};
}
 
 
#include <Thoth/NJson/Json.tpp>