Merge pull request #10 from tukl-msd/feat/CollapsingVector

implemented collapsing vector

Author: lsteiner-tukl

include/DRAMUtils/DRAMUtils/util/collapsingvector.h

@@ -0,0 +1,95 @@
+#ifndef DRAMUTILS_UTIL_COLLAPSINGVECTOR
+#define DRAMUTILS_UTIL_COLLAPSINGVECTOR
+
+#include "json.h"
+
+#include <vector>
+
+
+namespace DRAMUtils::util
+{
+
+    template <typename T, typename Alloc = std::allocator<T>>
+    class CollapsingVector : public std::vector<T, Alloc>
+    {
+    public:
+        enum class Type
+        {
+            SINGLE,
+            ARRAY
+        };
+        
+        using std::vector<T>::vector;
+    
+        // Forward constructor
+        // Single element represented as the element type in serialization
+        template <typename... Ts, typename = decltype(std::vector<T>{std::declval<Ts>()...})>
+        CollapsingVector(Ts&&... ts) : std::vector<T> {std::forward<Ts>(ts)...} {
+            if (this->size() == 1) {
+                set_type(Type::SINGLE);
+            } else {
+                set_type(Type::ARRAY);
+            }
+        }
+    
+        // Forward constructor with type
+        // This constructor allows a single element to be represented as an array in serialization
+        template <typename... Ts, typename = decltype(std::vector<T>{std::declval<Ts>()...})>
+        explicit CollapsingVector(Type type, Ts&&... ts) : std::vector<T> {std::forward<Ts>(ts)...} {
+            // Overwrite type for multiple elements
+            if (this->size() > 1) {
+                set_type(Type::ARRAY);
+            } else {
+                set_type(type);
+            }
+        }
+    
+    private:
+        void set_type(Type type)
+        {
+            this->type = type;
+        }
+    
+    public:
+        Type get_type() const
+        {
+            return type;
+        }
+    
+        void from_json(const json_t& j)
+        {
+            this->clear();
+            if (!j.is_array()) {
+                // Single element
+                this->emplace_back(j.get<T>());
+                set_type(Type::SINGLE);
+            } else {
+                // Array
+                for (const auto& element : j) {
+                    this->emplace_back(element.get<T>());
+                }
+                set_type(Type::ARRAY);
+            }
+        }
+    
+        void to_json(json_t& j) const
+        {
+            if (get_type() == Type::SINGLE && this->size() == 1) {
+                // Single element
+                j = this->operator[](0);
+            } else {
+                // Array
+                j = json_t::array();
+                for (const auto& element : *this) {
+                    j.emplace_back(element);
+                }
+            }
+        }
+    
+    private:
+        Type type = Type::ARRAY;
+    };
+
+} // namespace DRAMUtils::util
+
+#endif /* DRAMUTILS_UTIL_COLLAPSINGVECTOR */

include/DRAMUtils/DRAMUtils/util/json_utils.h

@@ -41,10 +41,12 @@
 #include "json.h"
 
 #include "id_variant.h"
+#include "collapsingvector.h"
 
 #include <optional>
 #include <variant>
 #include <string>
+#include <string_view>
 
 
 
@@ -71,6 +73,32 @@ void variant_to_json(json_t& j, const std::variant<Ts...> &data)
 }
 
 
+template <typename T>
+void collapsingvector_to_json(json_t& j, const CollapsingVector<T>& data, std::optional<std::string_view> key)
+{
+    if (key) {
+        data.to_json(j[*key]);
+    } else {
+        data.to_json(j);
+    }
+}
+
+template <typename T>
+void collapsing_from_json(const json_t& j, CollapsingVector<T>& data, std::optional<std::string_view> key)
+{
+    if (key) {
+        const auto it = j.find(*key);
+        if (it == j.end()) {
+            // Key not in json
+            throw std::runtime_error("Key " + std::string(*key) + " not found in json");
+        }
+        data.from_json(*it);
+    } else {
+        data.from_json(j);
+    }
+}
+
+
 template <typename T>
 void optional_to_json(json_t& j, const std::optional<T>& data, std::optional<std::string_view> key)
 {
@@ -149,13 +177,20 @@ constexpr bool is_id_variant = false;
 template <char const * id_field_name, typename Seq>
 constexpr bool is_id_variant<IdVariant<id_field_name, Seq>> = true;
 
+template <typename>
+constexpr bool is_collapsing_vector = false;
+template <typename T>
+constexpr bool is_collapsing_vector<CollapsingVector<T>> = true;
+
 
 template <typename T> void extended_to_json(const char* key, json_t& j, const T& value)
 {
     if constexpr (is_optional<T>)
         optional_to_json(j, value, key);
     else if constexpr (is_id_variant<T>)
         id_variant_to_json(j, value, key);
+    else if constexpr (is_collapsing_vector<T>)
+        collapsingvector_to_json(j, value, key);
     else if constexpr (is_variant<T>)
         variant_to_json(j, value);
     else
@@ -168,6 +203,8 @@ template <typename T> void extended_from_json(const char* key, const json_t& j,
         optional_from_json(j, value, key);
     else if constexpr (is_id_variant<T>)
         id_variant_from_json(j, value, key);
+    else if constexpr (is_collapsing_vector<T>)
+        collapsing_from_json(j, value, key);
     else if constexpr (is_variant<T>)
         variant_from_json<T>(j, value);
     else
@@ -220,6 +257,20 @@ template <typename... Ts> struct adl_serializer<std::variant<Ts...>>
 };
 
 
+template <typename T> struct adl_serializer<DRAMUtils::util::CollapsingVector<T>>
+{
+    static void to_json(json_t& j, const DRAMUtils::util::CollapsingVector<T>& data)
+    {
+        DRAMUtils::util::collapsingvector_to_json<T>(j, data, std::nullopt);
+    }
+
+    static void from_json(const json_t& j, DRAMUtils::util::CollapsingVector<T>& data)
+    {
+        (DRAMUtils::util::collapsing_from_json<T>(j, data, std::nullopt));
+    }
+};
+
+
 template <const char * id_field_name, typename Seq> struct adl_serializer<DRAMUtils::util::IdVariant<id_field_name, Seq>>
 {
     static void to_json(json_t& j, const DRAMUtils::util::IdVariant<id_field_name, Seq>& data)