Добавлена инициализация из стандартных контейнеров.

Дополнена документация.
Изменён natvis.
Добавлены тесты.

Author: orefkov

CMakeLists.txt

@@ -63,7 +63,7 @@ function(Simstr)
         simstr
         GIT_REPOSITORY https://github.com/orefkov/simstr.git
         GIT_SHALLOW TRUE
-        GIT_TAG 04d253e
+        GIT_TAG fb0e2f1
         FIND_PACKAGE_ARGS
     )
     FetchContent_MakeAvailable(simstr)

for_debug/simjson.natvis

@@ -7,8 +7,8 @@
     <DisplayString Condition="type_==Json::Type::Text">text: {val_.text}</DisplayString>
     <DisplayString Condition="type_==Json::Type::Integer">int: {val_.integer}</DisplayString>
     <DisplayString Condition="type_==Json::Type::Real">real: {val_.real}</DisplayString>
-    <DisplayString Condition="type_==Json::Type::Object">obj: {*val_.object}</DisplayString>
-    <DisplayString Condition="type_==Json::Type::Array">arr: {*val_.array}</DisplayString>
+    <DisplayString Condition="type_==Json::Type::Object">obj: {val_.object}</DisplayString>
+    <DisplayString Condition="type_==Json::Type::Array">arr: {val_.array}</DisplayString>
     <DisplayString>[undefined]</DisplayString>
 	<Expand>
 		<ExpandedItem Condition="type_==Json::Type::Object">*val_.object</ExpandedItem>

include/simjson/json.h

@@ -52,6 +52,40 @@ struct StreamedJsonParserBase {
     int idxUnicode_{};
 };
 
+namespace jt {
+
+template<typename K>
+using KeyType = StoreType<K, strhash<K>>;
+
+template<typename T, typename K>
+concept JsonType = std::is_integral_v<std::remove_cvref_t<T>> ||
+    std::is_floating_point_v<std::remove_cvref_t<T>> ||
+    std::is_constructible_v<sstring<K>, T>;
+
+template<typename T, typename K>
+concept JsonKeyType = std::convertible_to<T, simple_str<K>> ||
+    std::same_as<std::remove_cvref_t<T>, KeyType<K>>;
+
+template<typename T, typename K>
+concept JsonArraySource = requires(const T& t) {
+    { t.empty() } -> std::same_as<bool>;
+    { t.size() } -> std::same_as<size_t>;
+    { *t.begin() } -> JsonType<K>;
+    { *t.end() } -> JsonType<K>;
+};
+
+template<typename T, typename K>
+concept JsonObjectSource = requires(const T& t) {
+    { t.empty() } -> std::same_as<bool>;
+    { t.size() } -> std::same_as<size_t>;
+    { t.begin()->first } -> JsonKeyType<K>;
+    { t.end()->first } -> JsonKeyType<K>;
+    { t.begin()->second } -> JsonType<K>;
+    { t.end()->second } -> JsonType<K>;
+};
+
+} // namespace jt
+
 /*!
  * @brief Класс для представления json значения
  * @tparam K - тип символов
@@ -64,19 +98,31 @@ class JsonValueTempl : public Json {
     using ssType = simple_str<K>;
 
     using json_value = JsonValueTempl<K>;
-    using json_object = std::shared_ptr<hashStrMap<K, JsonValueTempl<K>>>;
-    using json_array = std::shared_ptr<std::vector<JsonValueTempl<K>>>;
-    using obj_type = typename json_object::element_type;
-    using arr_type = typename json_array::element_type;
+    using obj_type = hashStrMap<K, JsonValueTempl<K>>;
+    using arr_type = std::vector<JsonValueTempl<K>>;
+    using json_object = std::shared_ptr<obj_type>;
+    using json_array = std::shared_ptr<arr_type>;
 
     /// Создает пустой объект с типом Undefined
     JsonValueTempl() : type_(Undefined) {}
     /// Конструктор копирования. Объекты и массивы копируются по ссылке
     JsonValueTempl(const JsonValueTempl& other);
     /// Конструктор перемещения
     JsonValueTempl(JsonValueTempl&& other) noexcept {
-        // Расчёт на то, что shared_ptr не содержит указателей на свои внутренности
-        memcpy((void*)this, &other, sizeof(*this));
+        type_ = other.type_;
+        switch (other.type_) {
+        case Json::Text:
+            new (&val_.text) strType(std::move(other.val_.text));
+            break;
+        case Json::Object:
+            new (&val_.object) json_object(std::move(other.val_.object));
+            break;
+        case Json::Array:
+            new (&val_.array) json_array(std::move(other.val_.array));
+            break;
+        default:
+            memcpy(&val_, &other.val_, sizeof(val_));
+        }
         other.type_ = Undefined;
     }
     /// Деструктор
@@ -128,21 +174,40 @@ class JsonValueTempl : public Json {
     /// Конструктор для создания дефолтного значения с типом type
     JsonValueTempl(Type type);
 
-    struct KeyInit : std::pair<const StoreType<K>, json_value> {
-        using base = std::pair<const StoreType<K>, json_value>;
-        KeyInit(const StoreType<K>& k, const json_value& v) : base(k, v){}
+    struct KeyInit : std::pair<const jt::KeyType<K>, json_value> {
+        using base = std::pair<const jt::KeyType<K>, json_value>;
+        KeyInit(const jt::KeyType<K>& k, const json_value& v) : base(k, v){}
         KeyInit(ssType k, const json_value& v) : base(obj_type::toStoreType(k), v){}
     };
     using ObjectInit = std::initializer_list<KeyInit>;
     /// Конструктор из инициализатора для создания json::object: JsonValue v = {{"key1"_h, 1}, {"key2", "text"}, {"key3"_h, false}}; -> {"key1": 10, "key2": "text", "key3": false}
     JsonValueTempl(ObjectInit&& init) : type_(Object) {
-        new (&val_.object) json_object(std::make_shared<obj_type>(std::move(reinterpret_cast<std::initializer_list<std::pair<const StoreType<K>, json_value>>&>(init))));
+        new (&val_.object) json_object(std::make_shared<obj_type>(std::move(reinterpret_cast<std::initializer_list<std::pair<const jt::KeyType<K>, json_value>>&>(init))));
     }
     using ArrayInit = std::initializer_list<json_value>;
     /// Конструктор из инициализатора для создания json::array: JsonValue json = {"key1", 12, false, Json::null, 1.25, true}; -> ["key1", 12, false, null, 1.25, true]
     JsonValueTempl(ArrayInit&& init) : type_(Array) {
         new (&val_.array) json_array(std::make_shared<arr_type>(std::move(init)));
     }
+    /// Конструктор из любого стандартного контейнера-массива, содержащего значения JSON.
+    JsonValueTempl(jt::JsonArraySource<K> auto const& obj) : JsonValueTempl(emptyArray) {
+        if (!obj.empty()) {
+            auto& arr = *as_array();
+            arr.reserve(obj.size());
+            for (const auto& e : obj) {
+                arr.emplace_back(e);
+            }
+        }
+    }
+    /// Конструктор из любого стандартного контейнера с парами, содержащими строковый ключ в first и значение JSON в second.
+    JsonValueTempl(jt::JsonObjectSource<K> auto const& obj) : JsonValueTempl(emptyObject) {
+        if (!obj.empty()) {
+            auto& me = *as_object();
+            for (const auto& [f, s] : obj) {
+                me.emplace(f, s);
+            }
+        }
+    }
 
     struct Clone {
         const json_value& from;
@@ -174,7 +239,6 @@ class JsonValueTempl : public Json {
     /// Значение object
     bool is_object() const { return type_ == Object; }
 
-
     // -----------------------------   Boolean -----------------------------------------------
 
     /// Получить значение как boolean. В отладочной версии проверяется, что значение действительно boolean
@@ -352,7 +416,7 @@ class JsonValueTempl : public Json {
     }
 
     /// Обращение к свойству константного объекта по ключу. Не создаёт новую пару при отсутствии ключа
-    template<typename T> requires (!std::is_integral_v<T>)
+    template<jt::JsonKeyType<K> T>
     const json_value& at(T&& key) const {
         if (type_ == Object) {
             if (auto it = as_object()->find(std::forward<T>(key)); it != as_object()->end())
@@ -362,13 +426,13 @@ class JsonValueTempl : public Json {
     }
 
     /// Обращение к свойству константного объекта по ключу. Не создаёт новую пару при отсутствии ключа
-    template<typename T> requires (!std::is_integral_v<T>)
+    template<jt::JsonKeyType<K> T>
     const json_value& operator[](T&& key) const {
         return at(std::forward<T>(key));
     }
 
     /// Обращение к свойству константного объекта по ключам. Не создаёт новую пару при отсутствии ключа
-    template<typename T, typename...Args> requires (!std::is_integral_v<T>)
+    template<jt::JsonKeyType<K> T, typename...Args>
     const json_value& operator()(T&& key, Args&&...args) const {
         const json_value& res = at(std::forward<T>(key));
         if constexpr (sizeof...(Args) == 0) {
@@ -380,7 +444,7 @@ class JsonValueTempl : public Json {
 
     /// Обращение к свойству объекта по ключу. Создаёт новую пару при отсутствии ключа
     /// Если значение не объект, заменят его на объект
-    template<typename T> requires (!std::is_integral_v<T>)
+    template<jt::JsonKeyType<K> T>
     json_value& operator[](T&& key) {
         if (type_ != Object) {
             assert(this != &UNDEFINED);
@@ -391,7 +455,7 @@ class JsonValueTempl : public Json {
 
     /// Установка значения свойству объекта по ключу. Создаёт новую пару при отсутствии ключа
     /// Если значение не объект, заменят его на объект
-    template<typename Key, typename ... Args> requires (!std::is_integral_v<Key>)
+    template<jt::JsonKeyType<K> Key, typename ... Args>
     json_value& set(Key&& key, Args&& ... args) {
         if (type_ != Object) {
             assert(this != &UNDEFINED);
@@ -444,10 +508,10 @@ class JsonValueTempl : public Json {
     }
 
     /// Слияние с другим JSON. Если replace == true, то другой JSON имеет приоритет, если он не undefined.
-    /// Если оба объекта массивы, то другой массив дописывается к этому массиву.
+    /// Если оба объекта массивы, то при append_arrays = true другой массив дописывается к этому массиву.
     /// Если оба JSONа объекты - то сливаются по ключам.
     /// Иначе другой JSON заменяет текущее значение.
-    void merge(const json_value& other, bool replace = true);
+    void merge(const json_value& other, bool replace = true, bool append_arrays = false);
 
     /// Распарсить текст с json.
     static std::tuple<json_value, JsonParseResult, unsigned, unsigned> parse(ssType jsonString);

readme.md

@@ -14,15 +14,19 @@
 для массивов - `std::vector<JsonValueTemp<K>>`, строки хранятся в `sstring<K>`.
 
 ## Основные возможности библиотеки
+- Работает со всеми строками simstr.
 - Поддерживает работу со строками `char`, `char16_t`, `char32_t`, `wchar_t`.
 - Удобное создание, чтение и модификация json значений.
+- Копирование таких JSON-значений, как массивы и объекты производится по ссылке (копируется только `shared_ptr`).
+- Возможно "глубокое" копирование aka клонирование, JSON-значений, в этом случае для массивов и объектов создаётся полная копия.
+- "Слияние" одного JSON объекта с другим, с возможностью задать приоритет.
 - Расширенная работа с числами - позволяет использовать int64_t и double.
 - Парсинг строки в Json, с поддержкой порционного парсинга.
 - Сериализация json в строку, с опциями - сортировка ключей, "читаемый" вывод, количество отступов и символ
   отступа при "читаемом" выводе.
 
 ## Основные объекты библиотеки
-- JsonValueTemp<K> - тип Json значения, параметр К задаёт тип используемых символов в строке. Алиасы:
+- JsonValueTempl<K> - тип Json значения, параметр К задаёт тип используемых символов в строке. Алиасы:
   - JsonValue - для строк char
   - JsonValueU - для строк char16_t
   - JsonValueUU - для строк char32_t
@@ -36,9 +40,10 @@
 можно просто включить файлы в свой проект. Для сборки также требуется [simstr](https://github.com/orefkov/simstr) (при использовании CMake
 скачивается автоматически).
 
-Для работы `simjson` требуется компилятор стандарта не ниже С++20, как того требует simstr.
+Для работы `simjson` требуется компилятор с поддержкой стандарта не ниже С++20 (используются концепты).
 
 ## Примеры использования
+### Создание, чтение
 ```cpp
     // Простой json, равный 1.
     JsonValue json = 1; // int64
@@ -74,8 +79,7 @@
       "not specified work dir");
 ```
 
-Задание дефолтных значений, чтение из файла и объединение с дефолтными значениями.
-
+### Пример: Задание дефолтных значений, чтение из файла и объединение с дефолтными значениями.
 ```cpp
 
 JsonValue json_config = {
@@ -134,6 +138,46 @@ void read_config_from_file(ssa folder, ssa file_name) {
     json_config["runtime"_h]["location"_h]["base_dir"_h] = std::move(path_checked);
 }
 ```
+### Пример - инициализация из стандартных контейнеров
+```cpp
+    // Массивы
+    std::vector<int> vals = {1, 2, 3, 4};
+    JsonValue json = vals;
+    EXPECT_EQ(json.type(), Json::Array);
+    EXPECT_EQ(json.store(), "[1,2,3,4]");
+
+    JsonValue json1 = std::array<int, 4>{4, 3, 2, 1};
+    EXPECT_EQ(json1.type(), Json::Array);
+    EXPECT_EQ(json1.store(), "[4,3,2,1]");
+
+    std::list<stringa> texts = {"one", "two", "three"};
+    JsonValue json2 = texts;
+    EXPECT_EQ(json2.type(), Json::Array);
+    EXPECT_EQ(json2.store(), "[\"one\",\"two\",\"three\"]");
+
+    // Ключ-значение
+    hashStrMapA<int> vals = {
+        {"one"_h, 1}, {"two"_h, 2}, {"three"_h, 3}, {"four"_h, 4}
+    };
+    JsonValue json = vals;
+    EXPECT_EQ(json.type(), Json::Object);
+    EXPECT_EQ(json.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+
+    std::map<stringa, int> vals1 = {
+        {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4}
+    };
+    JsonValue json1 = vals1;
+    EXPECT_EQ(json1.type(), Json::Object);
+    EXPECT_EQ(json1.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+
+    std::vector<std::pair<lstringa<20>, int>> vals2 = {
+        {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4}
+    };
+    JsonValue json2 = vals2;
+    EXPECT_EQ(json2.type(), Json::Object);
+    EXPECT_EQ(json2.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+
+```
 
 ## Сгенерированная документация
 [Находится здесь](https://snegopat.ru/simjson/docs/)

src/json.cpp

@@ -369,22 +369,31 @@ typename JsonValueTempl<K>::strType JsonValueTempl<K>::to_text() const {
 }
 
 template<typename K>
-void JsonValueTempl<K>::merge(const json_value& other, bool replace) {
+void JsonValueTempl<K>::merge(const json_value& other, bool replace, bool append_arrays) {
     if (is_object() && other.is_object()) {
         // Надо слить по ключам
         auto& self = *as_object();
         for (const auto& [key, value]: *other.as_object()) {
             auto fnd = self.find(key);
             if (fnd != self.end()) {
-                fnd->second.merge(value, replace);
+                fnd->second.merge(value, replace, append_arrays);
             } else {
                 self.try_emplace(key, value);
             }
         }
     } else if (is_array() && other.is_array()) {
-        if (other.as_array()->size()) {
+        if (append_arrays) {
+            if (other.as_array()->size()) {
+                auto& arr = *as_array();
+                arr.reserve(arr.size() + other.as_array()->size());
+                for (const auto& e : *other.as_array()) {
+                    arr.emplace_back(e);
+                }
+            }
+        } else if (replace) {
             auto& arr = *as_array();
-            arr.reserve(arr.size() + other.as_array()->size());
+            arr.clear();
+            arr.reserve(other.as_array()->size());
             for (const auto& e : *other.as_array()) {
                 arr.emplace_back(e);
             }

tests/test_json.cpp

@@ -5,6 +5,7 @@
 #include <fstream>
 #include <iostream>
 #include <memory>
+#include <array>
 
 namespace simjson::tests {
 
@@ -388,7 +389,45 @@ TEST(SimJson, JsonThrow) {
     EXPECT_EQ(err_descr, "Need boolean value");
 }
 
-/*
+TEST(SimJson, JsonStdInitArray) {
+    std::vector<int> vals = {1, 2, 3, 4};
+    JsonValue json = vals;
+    EXPECT_EQ(json.type(), Json::Array);
+    EXPECT_EQ(json.store(), "[1,2,3,4]");
+
+    JsonValue json1 = std::array<int, 4>{4, 3, 2, 1};
+    EXPECT_EQ(json1.type(), Json::Array);
+    EXPECT_EQ(json1.store(), "[4,3,2,1]");
+
+    std::list<stringa> texts = {"one", "two", "three"};
+    JsonValue json2 = texts;
+    EXPECT_EQ(json2.type(), Json::Array);
+    EXPECT_EQ(json2.store(), "[\"one\",\"two\",\"three\"]");
+}
+
+TEST(SimJson, JsonStdInitMap) {
+    hashStrMapA<int> vals = {
+        {"one"_h, 1}, {"two"_h, 2}, {"three"_h, 3}, {"four"_h, 4}
+    };
+    JsonValue json = vals;
+    EXPECT_EQ(json.type(), Json::Object);
+    EXPECT_EQ(json.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+
+    std::map<stringa, int> vals1 = {
+        {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4}
+    };
+    JsonValue json1 = vals1;
+    EXPECT_EQ(json1.type(), Json::Object);
+    EXPECT_EQ(json1.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+
+    std::vector<std::pair<lstringa<20>, int>> vals2 = {
+        {"one", 1}, {"two", 2}, {"three", 3}, {"four", 4}
+    };
+    JsonValue json2 = vals2;
+    EXPECT_EQ(json2.type(), Json::Object);
+    EXPECT_EQ(json2.store(false, true), "{\"four\":4,\"one\":1,\"three\":3,\"two\":2}");
+}
+    /*
 stringa getFileContent(stra fileName) {
     std::ifstream file(fileName, std::ios::binary | std::ios::ate);
     std::streamsize size = file.tellg();