AJson.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/IO/IOutputStream.h>
#include "AUI/Common/AException.h"
#include "AUI/Common/AOptional.h"
#include "AUI/Common/SharedPtr.h"
#include "AUI/IO/IInputStream.h"
#include "AJson.h"
#include "AUI/Common/AByteBufferView.h"
 
#include <AUI/Common/AUuid.h>
#include <AUI/Common/AMap.h>
#include <AUI/Json/AJson.h>
#include <AUI/Json/Exception.h>
#include <AUI/Traits/callables.h>
#include <variant>

 
class AJson;
namespace aui::impl {
   struct JsonObject: AVector<std::pair<AString, AJson>> {
   public:
       using AVector<std::pair<AString, AJson>>::AVector;

       [[nodiscard]]
       API_AUI_JSON std::pair<AString, AJson>* contains(const AString& key) noexcept;

       [[nodiscard]]
       const std::pair<AString, AJson>* contains(const AString& key) const noexcept {
           // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
           return const_cast<JsonObject&>(*this).contains(key);
       }
 
       [[nodiscard]] API_AUI_JSON AJson& operator[](const AString& key);
 
       [[nodiscard]] const AJson& operator[](const AString& key) const {
           return at(key);
       }

       [[nodiscard]] API_AUI_JSON AJson& at(const AString& key);

       [[nodiscard]] const AJson& at(const AString& key) const {
           // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
           return const_cast<JsonObject&>(*this).at(key);
       }
   };
   using JsonArray = AVector<AJson>;
   using JsonVariant = std::variant<std::nullopt_t, std::nullptr_t, int, int64_t, double, bool, AString, aui::impl::JsonArray, aui::impl::JsonObject>;
}

class AJson: public aui::impl::JsonVariant {
private:
   using super = aui::impl::JsonVariant;
 
   template<typename T>
   [[nodiscard]]
   bool is() const noexcept {
       return std::holds_alternative<T>(*this);
   }
   template<typename T>
   [[nodiscard]]
   T& as() {
       if (isEmpty()) {
           *this = T();
       }
 
       if (auto p = std::get_if<T>(this)) {
           return *p;
       }
       throw AJsonTypeMismatchException("not a " + AClass<T>::name());
   }
 
   template<typename T>
   [[nodiscard]]
   const T& as() const {
       if (auto p = std::get_if<T>(this)) {
           return *p;
       }
       if constexpr(std::is_same_v<T, aui::impl::JsonObject>) {
           throw AJsonTypeMismatchException("not an object");
       } else if constexpr(std::is_same_v<T, aui::impl::JsonArray>) {
           throw AJsonTypeMismatchException("not an array");
       } else {
           throw AJsonTypeMismatchException("not a " + AClass<T>::name());
       }
   }
public:
   using aui::impl::JsonVariant::variant;
 
   using Array = aui::impl::JsonArray;
   using Object = aui::impl::JsonObject;
 
   AJson(std::initializer_list<std::pair<AString, AJson>> elems): aui::impl::JsonVariant(aui::impl::JsonObject(std::move(elems))) {
 
   }
 
   AJson(const char* name): aui::impl::JsonVariant(AString(name)) {}
   AJson(const AJson& json) = default;
   AJson(AJson&&) noexcept = default;
   AJson& operator=(const AJson&) = default;
   AJson& operator=(AJson&&) noexcept = default;
 
   AJson() noexcept: aui::impl::JsonVariant(std::nullopt) {}
 
   [[nodiscard]]
   bool isInt() const noexcept {
       return is<int>();
   }
 
   [[nodiscard]]
   bool isLongInt() const noexcept {
       return isInt() || is<int64_t>();
   }
 
   [[nodiscard]]
   bool isEmpty() const noexcept {
       return is<std::nullopt_t>();
   }
 
   [[nodiscard]]
   bool isNumber() const noexcept {
       return isInt() || is<double>();
   }
 
   [[nodiscard]]
   bool isBool() const noexcept {
       return is<bool>();
   }
 
   [[nodiscard]]
   bool isNull() const noexcept {
       return is<std::nullptr_t>();
   }
 
   [[nodiscard]]
   bool isString() const noexcept {
       return is<AString>();
   }
 
   [[nodiscard]]
   bool isArray() const noexcept {
       return is<aui::impl::JsonArray>();
   }
 
   [[nodiscard]]
   bool isObject() const noexcept {
       return is<aui::impl::JsonObject>();
   }
 
   [[nodiscard]]
   int asInt() const {
       return as<int>();
   }
 
   [[nodiscard]]
   int64_t asLongInt() const {
       return std::visit(aui::lambda_overloaded{
           [](auto&& e) -> std::int64_t {
               throw AJsonTypeMismatchException("not a long int");
           },
           [](std::int64_t v) -> std::int64_t {
               return v;
           },
           [](int v) -> std::int64_t {
               return v;
           },
       }, (super)const_cast<AJson&>(*this));
   }
 
   [[nodiscard]]
   double asNumber() const {
       return std::visit(aui::lambda_overloaded{
               [](auto&& e) -> double {
                   throw AJsonTypeMismatchException("not a number");
               },
               [](double v) -> double {
                   return v;
               },
               [](int v) -> double {
                   return v;
               },
               [](int64_t v) -> double {
                   return v;
               },
       }, (super)const_cast<AJson&>(*this));
   }
 
   [[nodiscard]]
   bool asBool() const {
       return as<bool>();
   }
 
   [[nodiscard]]
   const AString& asString() const {
       return as<AString>();
   }
 
   [[nodiscard]]
   const aui::impl::JsonArray& asArray() const {
       return as<aui::impl::JsonArray>();
   }
 
   [[nodiscard]]
   const aui::impl::JsonObject& asObject() const {
       return as<aui::impl::JsonObject>();
   }
 
 
   [[nodiscard]]
   aui::impl::JsonArray& asArray() {
       return as<aui::impl::JsonArray>();
   }
 
   [[nodiscard]]
   aui::impl::JsonObject& asObject() {
       return as<Object>();
   }
 
   [[nodiscard]]
   bool contains(const AString& mapKey) const {
       return as<Object>().contains(mapKey);
   }
 
   [[nodiscard]]
   AOptional<AJson> containsOpt(const AString& mapKey) const {
       if (auto c = as<Object>().contains(mapKey)) {
           return c->second;
       }
       return std::nullopt;
   }
 
   AJson& operator[](const AString& mapKey) {
       return asObject()[mapKey];
   }
 
   const AJson& operator[](const AString& mapKey) const {
       // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
       return const_cast<AJson&>(*this)[mapKey];
   }
 
 
   AJson& operator[](int arrayIndex) {
       return as<Array>().at(arrayIndex);
   }
 
   const AJson& operator[](int arrayIndex) const {
       return const_cast<AJson&>(*this)[arrayIndex];
   }
 
   void push_back(AJson elem) {
       asArray().push_back(std::move(elem));
   }
 

   API_AUI_JSON AJson mergedWith(const AJson& other);
 
   [[nodiscard]] static API_AUI_JSON AString toString(const AJson& json);
   [[nodiscard]] static API_AUI_JSON AJson fromString(const AString& json);
   [[nodiscard]] static AJson fromStream(aui::no_escape<IInputStream> stream) {
       return aui::deserialize<AJson>(stream);
   }
   [[nodiscard]] static API_AUI_JSON AJson fromBuffer(AByteBufferView buffer);
};
 
 
#include <AUI/Json/Conversion.h>
#include <AUI/Json/Serialization.h>

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.