Merge branch 'main' into blocks-metadata

src/data/dynamic.cpp

@@ -9,11 +9,22 @@ std::ostream& operator<<(std::ostream& stream, const dynamic::Value& value) {
     return stream;
 }
 
+std::ostream& operator<<(std::ostream& stream, const dynamic::Map& value) {
+    stream << json::stringify(&value, false, " ");
+    return stream;
+}
+
 std::ostream& operator<<(std::ostream& stream, const dynamic::Map_sptr& value) {
     stream << json::stringify(value, false, " ");
     return stream;
 }
 
+std::ostream& operator<<(std::ostream& stream, const dynamic::List& value) {
+    stream << json::stringify(&value, false, " ");
+    return stream;
+}
+
+
 std::ostream& operator<<(
     std::ostream& stream, const dynamic::List_sptr& value
 ) {
@@ -118,6 +129,12 @@ Map& List::putMap() {
     return *map;
 }
 
+ByteBuffer& List::putBytes(size_t size) {
+    auto bytes = create_bytes(size);
+    put(bytes);
+    return *bytes;
+}
+
 void List::remove(size_t index) {
     values.erase(values.begin() + index);
 }
@@ -238,6 +255,12 @@ List_sptr Map::list(const std::string& key) const {
     return nullptr;
 }
 
+ByteBuffer_sptr Map::bytes(const std::string& key) const {
+    auto found = values.find(key);
+    if (found != values.end()) return std::get<ByteBuffer_sptr>(found->second);
+    return nullptr;
+}
+
 void Map::flag(const std::string& key, bool& dst) const {
     dst = get(key, dst);
 }
@@ -263,6 +286,12 @@ Map& Map::putMap(const std::string& key) {
     return *obj;
 }
 
+ByteBuffer& Map::putBytes(const std::string& key, size_t size) {
+    auto bytes = create_bytes(size);
+    put(key, bytes);
+    return *bytes;
+}
+
 bool Map::has(const std::string& key) const {
     return values.find(key) != values.end();
 }
@@ -295,6 +324,10 @@ Map_sptr dynamic::create_map(
     return std::make_shared<Map>(entries);
 }
 
+ByteBuffer_sptr dynamic::create_bytes(size_t size) {
+    return std::make_shared<ByteBuffer>(size);
+}
+
 number_t dynamic::get_number(const Value& value) {
     if (auto num = std::get_if<number_t>(&value)) {
         return *num;

src/data/dynamic.hpp

@@ -11,13 +11,24 @@
 #include "dynamic_fwd.hpp"
 
 namespace dynamic {
-    enum class Type { none = 0, map, list, string, number, boolean, integer };
+    enum class Type {
+        none = 0,
+        map,
+        list,
+        bytes,
+        string,
+        number,
+        boolean,
+        integer
+    };
 
     const std::string& type_name(const Value& value);
     List_sptr create_list(std::initializer_list<Value> values = {});
     Map_sptr create_map(
         std::initializer_list<std::pair<const std::string, Value>> entries = {}
     );
+    ByteBuffer_sptr create_bytes(size_t size);
+
     number_t get_number(const Value& value);
     integer_t get_integer(const Value& value);
 
@@ -59,10 +70,13 @@ namespace dynamic {
         }
 
         List& put(std::unique_ptr<Map> value) {
-            return put(Map_sptr(value.release()));
+            return put(Map_sptr(std::move(value)));
         }
         List& put(std::unique_ptr<List> value) {
-            return put(List_sptr(value.release()));
+            return put(List_sptr(std::move(value)));
+        }
+        List& put(std::unique_ptr<ByteBuffer> value) {
+            return put(ByteBuffer_sptr(std::move(value)));
         }
         List& put(const Value& value);
 
@@ -70,6 +84,7 @@ namespace dynamic {
 
         List& putList();
         Map& putMap();
+        ByteBuffer& putBytes(size_t size);
 
         void remove(size_t index);
     };
@@ -115,6 +130,7 @@ namespace dynamic {
         void num(const std::string& key, double& dst) const;
         Map_sptr map(const std::string& key) const;
         List_sptr list(const std::string& key) const;
+        ByteBuffer_sptr bytes(const std::string& key) const;
         void flag(const std::string& key, bool& dst) const;
 
         Map& put(std::string key, std::unique_ptr<Map> value) {
@@ -144,6 +160,13 @@ namespace dynamic {
         Map& put(std::string key, bool value) {
             return put(key, Value(static_cast<bool>(value)));
         }
+        Map& put(const std::string& key, const ByteBuffer* bytes) {
+            return put(key, std::make_unique<ByteBuffer>(
+                bytes->data(), bytes->size()));
+        }
+        Map& put(std::string key, const ubyte* bytes, size_t size) {
+            return put(key, std::make_unique<ByteBuffer>(bytes, size));
+        }
         Map& put(std::string key, const char* value) {
             return put(key, Value(value));
         }
@@ -153,6 +176,7 @@ namespace dynamic {
 
         List& putList(const std::string& key);
         Map& putMap(const std::string& key);
+        ByteBuffer& putBytes(const std::string& key, size_t size);
 
         bool has(const std::string& key) const;
         size_t size() const;
@@ -160,5 +184,7 @@ namespace dynamic {
 }
 
 std::ostream& operator<<(std::ostream& stream, const dynamic::Value& value);
+std::ostream& operator<<(std::ostream& stream, const dynamic::Map& value);
 std::ostream& operator<<(std::ostream& stream, const dynamic::Map_sptr& value);
+std::ostream& operator<<(std::ostream& stream, const dynamic::List& value);
 std::ostream& operator<<(std::ostream& stream, const dynamic::List_sptr& value);

src/data/dynamic_fwd.hpp

@@ -6,13 +6,16 @@
 #include <variant>
 
 #include "typedefs.hpp"
+#include "util/Buffer.hpp"
 
 namespace dynamic {
     class Map;
     class List;
 
+    using ByteBuffer = util::Buffer<ubyte>;
     using Map_sptr = std::shared_ptr<Map>;
     using List_sptr = std::shared_ptr<List>;
+    using ByteBuffer_sptr = std::shared_ptr<ByteBuffer>;
 
     struct none {};
 
@@ -22,6 +25,7 @@ namespace dynamic {
         none,
         Map_sptr,
         List_sptr,
+        ByteBuffer_sptr,
         std::string,
         number_t,
         bool,