QJsonObject conversions are added to library

Author: shnarda

inc/taggedjsonarray.h

@@ -16,7 +16,7 @@
 
 namespace {
     template<typename T>
-    std::vector<T> extractFromQJSONArray(QJsonArray arr, const bool checkValue)
+    std::vector<T> extractFromQJSONArray(const QJsonArray& arr, const bool checkValue)
     {
         std::vector<T> out;
         out.reserve(arr.size());
@@ -45,6 +45,9 @@ template<typename T>
 class TaggedJSONArray <T, typename std::enable_if_t<TJO_JSON_COMPATIBLE>>
 {
 public:
+    //! Default constructor, which is useful if the parameters planned to be filled later
+    explicit TaggedJSONArray() {}
+
     /*!
     * \brief TaggedJSONArray constructor variant that takes QJsonArray input directly
     * \param val target JSON array data
@@ -66,11 +69,11 @@ class TaggedJSONArray <T, typename std::enable_if_t<TJO_JSON_COMPATIBLE>>
 
     //! Implicit value constructor for the tagged object constructor
     template<typename V, typename = std::enable_if_t<std::is_convertible_v<V, QJsonArray>>>
-    TaggedJSONArray(V&& val) { m_arr = std::forward<V>(val); };
+    TaggedJSONArray(V&& val) : m_arr(std::forward<V>(val)) {};
 
     //! Assignment operator setter
     template<typename V, typename = std::enable_if_t<std::is_convertible_v<V, QJsonArray>>>
-    void operator=(V&& val) { m_arr = std::forward<V>(val); };
+    TaggedJSONArray& operator=(V&& val) { m_arr = std::forward<V>(val); };
 
     //Operator overloads
     bool operator!=(const QJsonArray& other) const { return m_arr != other; };
@@ -161,6 +164,8 @@ class TaggedJSONArray <T, typename std::enable_if_t<TJO_JSON_COMPATIBLE>>
         return ret;
     }
 
+    QJsonValue toJsonValue() const {return m_arr;}
+
 private:
     QJsonArray m_arr;
 
@@ -220,6 +225,9 @@ template<typename T>
 class TaggedJSONArray<T, typename std::enable_if_t<TJO_IS_TAGGED_OBJECT>>
 {
 public:
+    //! Default constructor, which is useful if the parameters planned to be filled later
+    explicit TaggedJSONArray() : m_arr() {}
+
     /*!
      * @brief Main constructor that is intended to be used with the #TJO_DEFINE_JSON_TAGGED_OBJECT() macro.
      * @param ref QJsonValue that holds the array of predefined JSON objects.
@@ -234,11 +242,11 @@ class TaggedJSONArray<T, typename std::enable_if_t<TJO_IS_TAGGED_OBJECT>>
 
     //! Implicit value constructor for the tagged object constructor
     template<typename V, typename = std::enable_if_t<std::is_convertible_v<V, std::vector<T>>>>
-    TaggedJSONArray(V&& val) { m_arr = std::forward<V>(val); };
+    TaggedJSONArray(V&& val) : m_arr(std::forward<V>(val)) {};
 
     //!Assignment operator to get the whole container data 
     template<typename V, typename = std::enable_if_t<std::is_convertible_v<V, std::vector<T>>>>
-    void operator=(V&& val) { m_arr = std::forward<V>(val); };
+    TaggedJSONArray& operator=(V&& val) { m_arr = std::forward<V>(val); };
 
     bool operator!=(const std::vector<T>& other) const { return m_arr != other; };
     bool operator==(const std::vector<T>& other) const { return m_arr == other; };
@@ -271,7 +279,17 @@ class TaggedJSONArray<T, typename std::enable_if_t<TJO_IS_TAGGED_OBJECT>>
     };
 
     //!QVector access
-    QVector<T> toQVector() const { return QVector::fromStdVector(m_arr); }
+    QVector<T> toQVector() const { return QVector<T>::fromStdVector(m_arr); }
+
+    //!Converts the holding values back to a QJsonArray that holds each TaggedObject information
+    QJsonValue toJsonValue() const
+    {
+        QJsonArray ret;
+        for(const T& curObj : m_arr){
+            ret.append(curObj.toJsonValue());
+        }
+        return ret;
+    }
 
 private:
     std::vector<T> m_arr;

inc/taggedjsonobject.h

@@ -19,23 +19,20 @@ template <typename T, typename=std::enable_if_t<TJO_JSON_COMPATIBLE>>
 class TaggedJSONObject
 {
 public:
+    //! Default constructor, which is useful if the parameters planned to be filled later
+    explicit TaggedJSONObject() : m_value() {}
+
     /*!
      * \brief TaggedJSONObject Constructor that takes the JSON data and stores it according to the template argument.
      * \param val Target JSON value to be stored.
      * \param checkValue If set to true, invalid conversions (missing value, wrong type etc.) will throw a runtime error.
      */
-    explicit TaggedJSONObject(QJsonValue val, const bool checkValue=true)
-    {
-        //Check if there is a valid data if it's intended
-        if(checkValue && val.isUndefined())
-            throw(std::runtime_error("Invalid data has been encountered while parsing the json data for TaggedJSONObject"));
-
-        dispatchValue(std::move(val));
-    };
+    explicit TaggedJSONObject(const QJsonValue& val, const bool checkValue=true) : m_value(dispatchValue(val, checkValue))
+    {};
 
     //! Implicit value constructor for the tagged object constructor
     template<typename V, typename = std::enable_if_t<std::is_convertible_v<V, T>>>
-    TaggedJSONObject(V&& val) { m_value = std::forward<V>(val); };
+    TaggedJSONObject(V&& val) : m_value(std::forward<V>(val)) {};
 
     /*!
      * \brief l-value reference getter for the contained object
@@ -86,7 +83,7 @@ class TaggedJSONObject
      * \brief operator -> Shortcut for object values (QString, QVariant etc.) methods.
      * \return The contained object
      */
-    const T* const operator->() const {return &m_value;};
+    const T* operator->() const {return &m_value;};
 
     //! Shortcut for value operations (for QJsonValue and QJsonObjects only)
     template<typename S=T, typename=std::enable_if_t<std::is_same_v<S, QJsonValue> || std::is_same_v<S, QJsonObject>>>
@@ -106,28 +103,34 @@ class TaggedJSONObject
             return QString(m_value);
     };
 
+    QJsonValue toJsonValue() const {return QJsonValue{m_value};}
+
 private:
     T m_value;
 
     template<class TO>
     friend std::ostream& operator<< (std::ostream& stream, const TaggedJSONObject<TO>& obj);
 
     //Determine the function to be called at compile time based on the current template parameter
-    void dispatchValue(QJsonValue&& val){
+    T dispatchValue(const QJsonValue& val, const bool checkValue){
+        //Check if there is a valid data if it's intended
+        if(checkValue && val.isUndefined())
+            throw(std::runtime_error("Invalid data has been encountered while parsing the json data for TaggedJSONObject"));
+
         if constexpr(std::is_same_v<T, bool>)
-            m_value = val.toBool();
+            return val.toBool();
         else if constexpr(std::is_integral_v<T>)
-            m_value = val.toInt();
+            return val.toInt();
         else if constexpr(std::is_floating_point_v<T>)
-            m_value = val.toDouble();
+            return val.toDouble();
         else if constexpr(std::is_same_v<T, QJsonValue>)
-            m_value = std::move(val);
+            return val;
         else if constexpr(std::is_same_v<T, QJsonObject>)
-            m_value = val.toObject();
+            return val.toObject();
         else if constexpr(std::is_same_v<T, QString>)
-            m_value = val.toString();
+            return val.toString();
         else if constexpr(std::is_same_v<T, QVariant>)
-            m_value = val.toVariant();
+            return val.toVariant();
         else
             throw(std::invalid_argument("Template argument for the TaggedJSONObject is not valid"));
     }

inc/taggedjsonobjectmacros.h

@@ -7,10 +7,13 @@
 #include <QJsonObject>
 #include <QByteArray>
 
+#define TAGGEDOBJECTMACRO_PREPARE_JSON_OBJECT(type, name) ret[#name] = name.toJsonValue();
+#define TAGGEDOBJECTMACRO_PREPARE_JSON_OBJECT_UNPACK(pair) TAGGEDOBJECTMACRO_PREPARE_JSON_OBJECT pair
+
 #define TAGGEDOBJECTMACRO_DECLARE_MEMBER(type, name) type name;
 #define TAGGEDOBJECTMACRO_DECLARE_MEMBER_UNPACK(pair) TAGGEDOBJECTMACRO_DECLARE_MEMBER pair
 
-#define TAGGEDOBJECTMACRO_INITIALIZE_MEMBER(type, name) name(val.take(#name), checkValues)
+#define TAGGEDOBJECTMACRO_INITIALIZE_MEMBER(type, name) name(obj[#name], checkValues)
 #define TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_UNPACK(pair) TAGGEDOBJECTMACRO_INITIALIZE_MEMBER pair
 
 #define TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_VALUE(type, name) name(val[#name], checkValues)
@@ -49,11 +52,19 @@ respective JSON data, a runtime error will be raised.
 #define TJO_DEFINE_JSON_TAGGED_OBJECT(CLASS_NAME, ...) \
 class CLASS_NAME{\
 public:\
-    explicit CLASS_NAME(QJsonObject val, const bool checkValues=true) : MAP_LIST(TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_UNPACK, __VA_ARGS__) {}; \
-    explicit CLASS_NAME(QJsonValue val, const bool checkValues=true) : MAP_LIST(TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_VALUE_UNPACK, __VA_ARGS__) {}; \
+    explicit CLASS_NAME() {}\
+    explicit CLASS_NAME(const QJsonObject& obj, const bool checkValues=true) : MAP_LIST(TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_UNPACK, __VA_ARGS__) {}; \
+    explicit CLASS_NAME(const QJsonValue& val, const bool checkValues=true) : MAP_LIST(TAGGEDOBJECTMACRO_INITIALIZE_MEMBER_VALUE_UNPACK, __VA_ARGS__) {}; \
     explicit CLASS_NAME(const QByteArray& json, const bool checkValues=true) : CLASS_NAME(TaggedObject::getJSONObjectFromJSONText(json), checkValues) {};\
     explicit CLASS_NAME(const QString& filePath, const bool checkValues=true) : CLASS_NAME(TaggedObject::getJSONObjectFromFile(filePath), checkValues) {};\
     explicit CLASS_NAME(MAP_LIST(TAGGEDOBJECTMACRO_LIST_MEMBERS_UNPACK, __VA_ARGS__), const bool checkValues=true) : MAP_LIST(TAGGEDOBJECTMACRO_MOVE_PARAMETERS_UNPACK, __VA_ARGS__) {};\
+    QJsonObject toJsonObject() const\
+    {\
+        QJsonObject ret;\
+        MAP(TAGGEDOBJECTMACRO_PREPARE_JSON_OBJECT_UNPACK, __VA_ARGS__)\
+        return ret;\
+    }\
+    QJsonValue toJsonValue() const { return toJsonObject(); }\
     MAP(TAGGEDOBJECTMACRO_DECLARE_MEMBER_UNPACK, __VA_ARGS__)\
 };