add dv::value support to json::stringify & add dv.cpp

src/data/dv.cpp

@@ -0,0 +1,180 @@
+#include "dv.hpp"
+
+#include "util/Buffer.hpp"
+
+namespace dv {
+    value::value(value_type type) : type(type) {
+        switch (type) {
+            case value_type::object:
+                val.object = std::make_shared<objects::Object>();
+                break;
+            case value_type::list:
+                val.list = std::make_shared<objects::List>();
+                break;
+            case value_type::bytes:
+                val.bytes = nullptr; // no default size
+                break;
+            case value_type::string:
+                val.string = std::make_unique<std::string>("");
+                break;
+            default:
+                break;
+        }
+    }
+
+    value& value::operator[](const key_t& key) {
+        if (type == value_type::object) {
+            return (*val.object)[key];
+        }
+        throw std::runtime_error("value is not an object");
+    }
+    const value& value::operator[](const key_t& key) const {
+        if (type == value_type::object) {
+            return (*val.object)[key];
+        }
+        throw std::runtime_error("value is not an object");
+    }
+
+    value& value::operator=(const objects::Bytes& bytes) {
+        return setBytes(std::make_shared<objects::Bytes>(bytes));
+    }
+
+    value& value::operator[](size_t index) {
+        if (type == value_type::list) {
+            return (*val.list)[index];
+        }
+        throw std::runtime_error("value is not a list");
+    }
+    const value& value::operator[](size_t index) const {
+        if (type == value_type::list) {
+            return (*val.list)[index];
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    value& value::add(value v) {
+        if (type == value_type::list) {
+            return val.list->add(std::move(v));
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    value& value::object(const key_t& key) {
+        reference ref = this->operator[](key);
+        ref = dv::object();
+        return ref;
+    }
+
+    value& value::list(const key_t& key) {
+        reference ref = this->operator[](key);
+        ref = dv::list();
+        return ref;
+    }
+
+    value& value::object() {
+        return add(dv::object());
+    }
+
+    value& value::list() {
+        return add(dv::list());
+    }
+
+    list_t::iterator value::begin() {
+        if (type == value_type::list) {
+            return val.list->begin();
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    list_t::iterator value::end() {
+        if (type == value_type::list) {
+            return val.list->end();
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    list_t::const_iterator value::begin() const {
+        if (type == value_type::list) {
+            const auto& constlist = *val.list;
+            return constlist.begin();
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    list_t::const_iterator value::end() const {
+        if (type == value_type::list) {
+            const auto& constlist = *val.list;
+            return constlist.end();
+        }
+        throw std::runtime_error("value is not a list");
+    }
+
+    const std::string& value::asString() const {
+        if (type == value_type::string) {
+            return *val.string;
+        }
+        throw std::runtime_error("type error");
+    }
+
+    integer_t value::asInteger() const {
+        if (type == value_type::integer) {
+            return val.integer;
+        } else if (type == value_type::number) {
+            return static_cast<integer_t>(val.number);
+        }
+        throw std::runtime_error("type error");
+    }
+
+    number_t value::asNumber() const {
+        if (type == value_type::number) {
+            return val.number;
+        } else if (type == value_type::integer) {
+            return static_cast<number_t>(val.integer);
+        }
+        throw std::runtime_error("type error");
+    }
+
+    boolean_t value::asBoolean() const {
+        if (type == value_type::boolean) {
+            return val.boolean;
+        } else if (type == value_type::integer) {
+            return val.integer != 0;
+        }
+        throw std::runtime_error("type error");
+    }
+
+    objects::Bytes& value::asBytes() {
+        if (type == value_type::bytes) {
+            return *val.bytes;
+        }
+        throw std::runtime_error("type error");
+    }
+
+    const objects::Bytes& value::asBytes() const {
+        if (type == value_type::bytes) {
+            return *val.bytes;
+        }
+        throw std::runtime_error("type error");
+    }
+
+    const objects::Object& value::asObject() const {
+        if (type == value_type::object) {
+            return *val.object;
+        }
+        throw std::runtime_error("type error");
+    }
+
+    const size_t value::size() const {
+        switch (type) {
+            case value_type::list:
+                return val.list->size();
+            case value_type::object:
+                return val.object->size();
+            case value_type::string:
+                return val.string->size();
+            default:
+                throw std::runtime_error("type error");
+        }
+    }
+}
+

src/data/dv.hpp

@@ -168,58 +168,60 @@ namespace dv {
             }
         }
 
-        value& operator=(int8_t v) {
+        inline value& operator=(int8_t v) {
             return setInteger(v);
         }
-        value& operator=(int16_t v) {
+        inline value& operator=(int16_t v) {
             return setInteger(v);
         }
-        value& operator=(int32_t v) {
+        inline value& operator=(int32_t v) {
             return setInteger(v);
         }
-        value& operator=(int64_t v) {
+        inline value& operator=(int64_t v) {
             return setInteger(v);
         }
-        value& operator=(uint8_t v) {
+        inline value& operator=(uint8_t v) {
             return setInteger(v);
         }
-        value& operator=(uint16_t v) {
+        inline value& operator=(uint16_t v) {
             return setInteger(v);
         }
-        value& operator=(uint32_t v) {
+        inline value& operator=(uint32_t v) {
             return setInteger(v);
         }
-        value& operator=(uint64_t v) {
+        inline value& operator=(uint64_t v) {
             return setInteger(v);
         }
-        value& operator=(float v) {
+        inline value& operator=(float v) {
             return setNumber(v);
         }
-        value& operator=(double v) {
+        inline value& operator=(double v) {
             return setNumber(v);
         }
-        value& operator=(bool v) {
+        inline value& operator=(bool v) {
             return setBoolean(v);
         }
-        value& operator=(std::string_view v) {
+        inline value& operator=(std::string_view v) {
             return setString(std::string(v));
         }
-        value& operator=(std::string v) {
+        inline value& operator=(std::string v) {
             return setString(std::move(v));
         }
-        value& operator=(const char* v) {
+        inline value& operator=(const char* v) {
             return setString(v);
         }
-        value& operator=(std::shared_ptr<objects::List> ptr) {
+        inline value& operator=(std::shared_ptr<objects::List> ptr) {
             return setList(ptr);
         }
-        value& operator=(std::shared_ptr<objects::Object> ptr) {
+        inline value& operator=(std::shared_ptr<objects::Object> ptr) {
             return setObject(ptr);
         }
-        value& operator=(std::shared_ptr<objects::Bytes> ptr) {
+        inline value& operator=(std::shared_ptr<objects::Bytes> ptr) {
             return setBytes(ptr);
         }
-        value& operator=(const value& v) {
+        value& operator=(const objects::Bytes& bytes);
+        
+        inline value& operator=(const value& v) {
             switch (v.type) {
                 case value_type::object:
                     setObject(v.val.object);
@@ -252,7 +254,7 @@ namespace dv {
         value& add(value v);
 
         template<class T>
-        value& add(T v) {
+        inline value& add(T v) {
             return add(value(v));
         }
 
@@ -292,7 +294,7 @@ namespace dv {
 
         const objects::Object& asObject() const;
 
-        value_type getType() const {
+        inline value_type getType() const {
             return type;
         }
 
@@ -301,22 +303,15 @@ namespace dv {
         const size_t length() const {
             return size();
         }
-        bool empty() const {
+        inline bool empty() const {
             return size() == 0;
         }
     };
 
     using reference = value&;
     using const_reference = const value&;
-
-    value list();
-    value object();
-
-    value list(std::initializer_list<value> values);
 }
 
-#include "util/Buffer.hpp"
-
 namespace dv::objects {
     class Object {
         map_t map;
@@ -387,185 +382,15 @@ namespace dv::objects {
 }
 
 namespace dv {
-    value::value(value_type type) : type(type) {
-        switch (type) {
-            case value_type::object:
-                val.object = std::make_shared<objects::Object>();
-                break;
-            case value_type::list:
-                val.list = std::make_shared<objects::List>();
-                break;
-            case value_type::bytes:
-                val.bytes = nullptr; // no default size
-                break;
-            case value_type::string:
-                val.string = std::make_unique<std::string>("");
-                break;
-            default:
-                break;
-        }
-    }
-
-    value& value::operator[](const key_t& key) {
-        if (type == value_type::object) {
-            return (*val.object)[key];
-        }
-        throw std::runtime_error("value is not an object");
-    }
-    const value& value::operator[](const key_t& key) const {
-        if (type == value_type::object) {
-            return (*val.object)[key];
-        }
-        throw std::runtime_error("value is not an object");
-    }
-
-    value& value::operator[](size_t index) {
-        if (type == value_type::list) {
-            return (*val.list)[index];
-        }
-        throw std::runtime_error("value is not a list");
-    }
-    const value& value::operator[](size_t index) const {
-        if (type == value_type::list) {
-            return (*val.list)[index];
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    value& value::add(value v) {
-        if (type == value_type::list) {
-            return val.list->add(std::move(v));
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    value& value::object(const key_t& key) {
-        reference ref = this->operator[](key);
-        ref = dv::object();
-        return ref;
-    }
-
-    value& value::list(const key_t& key) {
-        reference ref = this->operator[](key);
-        ref = dv::list();
-        return ref;
-    }
-
-    value& value::object() {
-        return add(dv::object());
-    }
-
-    value& value::list() {
-        return add(dv::list());
-    }
-
-    list_t::iterator value::begin() {
-        if (type == value_type::list) {
-            return val.list->begin();
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    list_t::iterator value::end() {
-        if (type == value_type::list) {
-            return val.list->end();
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    list_t::const_iterator value::begin() const {
-        if (type == value_type::list) {
-            const auto& constlist = *val.list;
-            return constlist.begin();
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    list_t::const_iterator value::end() const {
-        if (type == value_type::list) {
-            const auto& constlist = *val.list;
-            return constlist.end();
-        }
-        throw std::runtime_error("value is not a list");
-    }
-
-    const std::string& value::asString() const {
-        if (type == value_type::string) {
-            return *val.string;
-        }
-        throw std::runtime_error("type error");
-    }
-
-    integer_t value::asInteger() const {
-        if (type == value_type::integer) {
-            return val.integer;
-        } else if (type == value_type::number) {
-            return static_cast<integer_t>(val.number);
-        }
-        throw std::runtime_error("type error");
-    }
-
-    number_t value::asNumber() const {
-        if (type == value_type::number) {
-            return val.number;
-        } else if (type == value_type::integer) {
-            return static_cast<number_t>(val.integer);
-        }
-        throw std::runtime_error("type error");
-    }
-
-    boolean_t value::asBoolean() const {
-        if (type == value_type::boolean) {
-            return val.boolean;
-        } else if (type == value_type::integer) {
-            return val.integer != 0;
-        }
-        throw std::runtime_error("type error");
-    }
-
-    objects::Bytes& value::asBytes() {
-        if (type == value_type::bytes) {
-            return *val.bytes;
-        }
-        throw std::runtime_error("type error");
-    }
-
-    const objects::Bytes& value::asBytes() const {
-        if (type == value_type::bytes) {
-            return *val.bytes;
-        }
-        throw std::runtime_error("type error");
-    }
-
-    const objects::Object& value::asObject() const {
-        if (type == value_type::object) {
-            return *val.object;
-        }
-        throw std::runtime_error("type error");
-    }
-
-    const size_t value::size() const {
-        switch (type) {
-            case value_type::list:
-                return val.list->size();
-            case value_type::object:
-                return val.object->size();
-            case value_type::string:
-                return val.string->size();
-            default:
-                throw std::runtime_error("type error");
-        }
-    }
-
-    value object() {
+    inline value object() {
         return std::make_shared<objects::Object>();
     }
 
-    value list() {
+    inline value list() {
         return std::make_shared<objects::List>();
     }
 
-    value list(std::initializer_list<value> values) {
+    inline value list(std::initializer_list<value> values) {
         return std::make_shared<objects::List>(values);
     }
 }