types in simple_dom

Author: lihuiba

ecosystem/simple_dom.cpp

@@ -188,14 +188,15 @@ struct JHandler : public BaseReaderHandler<UTF8<>, JHandler> {
     JNode* get_root() {
         return _root;
     }
-    void emplace_back(const char* s, size_t length) {
+    void emplace_back(const char* s, size_t length, uint8_t type) {
         str val{s, length};     // _key may be empty()
         _nodes.back().emplace_back(_key, val, _root);
+        _nodes.back().back().set_type(type);
         // LOG_DEBUG(_key, ": ", val);
         _key = {};
     }
     bool Null() {
-        emplace_back(0, 0);
+        emplace_back(0, 0, JNode::null);
         return true;
     }
     bool Key(const char* s, SizeType len, bool copy) {
@@ -205,22 +206,22 @@ struct JHandler : public BaseReaderHandler<UTF8<>, JHandler> {
     }
     bool String(const char* s, SizeType len, bool copy) {
         assert(!copy);
-        emplace_back(s, len);
+        emplace_back(s, len, JNode::STRING);
         return true;
     }
     bool RawNumber(const Ch* s, SizeType len, bool copy) {
         assert(!copy);
         // LOG_DEBUG(ALogString(s, len));
-        emplace_back(s, len);
+        emplace_back(s, len, JNode::NUMBER);
         return true;
     }
     bool RawBool(const Ch* s, SizeType len, bool copy) {
         assert(!copy);
-        emplace_back(s, len);
+        emplace_back(s, len, JNode::BOOLEAN);
         return true;
     }
     bool StartObject() {
-        emplace_back(0, 0);
+        emplace_back(0, 0, JNode::OBJECT);
         _nodes.emplace_back();
         return true;
     }
@@ -237,7 +238,7 @@ struct JHandler : public BaseReaderHandler<UTF8<>, JHandler> {
         _nodes.back().back().set_children(std::move(temp), _indexing);
     }
     bool StartArray() {
-        emplace_back(0, 0);
+        emplace_back(0, 0, JNode::ARRAY);
         _nodes.emplace_back();
         return true;
     }

ecosystem/simple_dom.h

@@ -80,6 +80,8 @@ class Node {
     const char* text_begin() const  { IF_RET(_impl->get_root()->_text_begin); }
     str key(const char* b) const    { IF_RET(_impl->get_key(b)); }
     str value(const char* b) const  { IF_RET(_impl->get_value(b)); }
+    uint8_t type() const            { IF_RET(_impl->get_type()); }
+    uint8_t get_type() const        { IF_RET(_impl->get_type()); }
     bool valid() const              { return _impl; }
     operator bool() const           { return _impl; }
     size_t num_children() const     { IF_RET(_impl->num_children()); }
@@ -97,6 +99,7 @@ class Node {
     double to_double(double def_val = NAN) const {
         return value().to_double(def_val);
     }
+    using TYPE = NodeImpl::TYPE;
 
     bool operator==(str rhs) const { return value() == rhs; }
     bool operator!=(str rhs) const { return value() != rhs; }

ecosystem/simple_dom_impl.h

@@ -48,24 +48,31 @@ class NodeImpl : public Object {
     const static size_t  MAX_VALUE_OFFSET   = 4095;
     const static size_t  MAX_VALUE_LENGTH   = MAX_KEY_OFFSET;
 
+    enum TYPE : uint8_t {STRING,  NUMBER, null, BOOLEAN, OBJECT, ARRAY};
+
+union {
+    const char* _text_begin;    // addr of the text (only for root node)
+    const NodeImpl* _root;      // root node (only for non-root nodes)
+};
 union { struct  { // for non-root nodes
-    struct {
-        uint8_t _flags;
-        uint16_t _k_len : 12;       // key length (12 bits)
-        uint16_t _v_off : 12;       // value offset (12 bits) to key end
-    }__attribute__((packed));
-    const NodeImpl* _root;          // root node
-};                                  // packed as 20 bytes
+    uint8_t _flags;
+    uint16_t _k_len : 12;       // key length (12 bits)
+    uint16_t _v_off : 12;       // value offset (12 bits) to key end
+}__attribute__((packed));
 struct {         // for the root node
     uint8_t _flags_;                // the same as _flags
     uint8_t _node_size;             // sizeof(the node implementation)
     mutable uint16_t _refcnt;       // reference counter of the document
-    const char* _text_begin;
 }; };
     uint32_t _k_off;                // key offset to _text_begin
     uint32_t _v_len;                // value length
     uint32_t _nchildren;            // for all nodes
 
+    void set_type(uint8_t type) {
+        _flags &= (1 << 5) - 1;
+        _flags |= (type & 0x7) << 5;
+    }
+
     using AT16 = std::atomic<uint16_t>;
     static_assert(sizeof(AT16) == sizeof(_refcnt), "...");
 
@@ -102,6 +109,9 @@ struct {         // for the root node
     bool is_root() const {
         return _flags & FLAG_IS_ROOT;
     }
+    uint8_t get_type() const {
+        return _flags >> 5;
+    }
     const NodeImpl* get_root() const {
         return is_root() ? this : _root;
     }
@@ -139,6 +149,7 @@ struct {         // for the root node
     int init_non_root(str key, str value, const NodeImpl* root, uint32_t flags);
 };
 
+static_assert(sizeof(NodeImpl) == 32, "");
 
 }
 }

ecosystem/test/test_simple_dom.cpp

@@ -177,6 +177,18 @@ void expect_eq_vals(Node node, const char * const (&truth)[N]) {
      expect_eq_vals(node, truth, N);
 }
 
+void expect_types(Node node, const std::pair<const char*, uint8_t>* truth, size_t n) {
+    for (size_t i = 0; i < n; ++i) {
+        auto val = node[truth[i].first];
+        EXPECT_EQ(val.type(), truth[i].second);
+    }
+}
+
+template<size_t N> inline
+void expect_types(Node node, const std::pair<const char*, uint8_t> (&truth)[N]) {
+    return expect_types(node, truth, N);
+}
+
 TEST(simple_dom, json) {
     const static char json0[] = R"({
         "hello": "world",
@@ -196,6 +208,11 @@ TEST(simple_dom, json) {
         {"i",       "-123"},
         {"pi",      "3.1416"},
     });
+    using TYPE = Node::TYPE;
+    expect_types(doc, {{"hello", TYPE::STRING}, {"t", TYPE::BOOLEAN},
+                       {"f", TYPE::BOOLEAN},    {"n", TYPE::null},
+                       {"i", TYPE::NUMBER},     {"pi", TYPE::NUMBER},
+                       {"a", TYPE::ARRAY}});
     EXPECT_EQ(doc["i"].to_int64_t(), -123);
     EXPECT_NEAR(doc["pi"].to_double(), 3.1416, 1e-5);
     expect_eq_vals(doc["a"], {"1", "2", "3", "4"});