Merge pull request #14 from PANFACTORY/feature/token

Feature/token

Author: PANFACTORY

src/node.h

@@ -16,6 +16,15 @@
 #include <iostream>
 
 namespace JsonParser {
+    enum class ValueType {
+        Default,
+        String,
+        Number,
+        BoolNull,
+        Object,
+        Array,
+    };
+
     /**
      * @brief   Node of AST
      *
@@ -28,108 +37,116 @@ namespace JsonParser {
          *
          * @param[in]   std::string _key    JSON key this node contains
          */
-        Node(std::string _key) : children(0), children_array(0) {
+        Node(std::string _key) : object(0), array(0) {
             this->key = _key;
             this->value = "";
-            this->isvalueset = false;
-            this->ischildrenset = false;
-            this->isarrayset = false;
+            this->valuetype = ValueType::Default;
         }
-        Node(const Node& node) : children(0), children_array(0) {
+        Node(const Node& node) : object(0), array(0) {
             this->key = node.key;
             this->value = node.value;
-            this->isvalueset = node.isvalueset;
-            this->ischildrenset = node.ischildrenset;
-            this->isarrayset = node.isarrayset;
-            for (auto node_child : node.children) {
-                this->children.push_back(new Node(*node_child));
+            this->valuetype = node.valuetype;
+            for (auto child : node.object) {
+                this->object.push_back(new Node(*child));
             }
-            for (auto node_child : node.children_array) {
-                this->children_array.push_back(new Node(*node_child));
+            for (auto child : node.array) {
+                this->array.push_back(new Node(*child));
             }
         }
         ~Node() {
-            for (auto child : this->children) {
+            for (auto child : this->object) {
                 delete child;
             }
-            for (auto child : this->children_array) {
+            for (auto child : this->array) {
                 delete child;
             }
         }
         Node& operator=(const Node& node) {
-            for (auto child : this->children) {
+            for (auto child : this->object) {
                 delete child;
             }
-            for (auto child : this->children_array) {
+            for (auto child : this->array) {
                 delete child;
             }
             this->key = node.key;
             this->value = node.value;
-            this->isvalueset = node.isvalueset;
-            this->ischildrenset = node.ischildrenset;
-            this->isarrayset = node.isarrayset;
-            for (auto node_child : node.children) {
-                this->children.push_back(new Node(*node_child));
+            this->valuetype = node.valuetype;
+            for (auto child : node.object) {
+                this->object.push_back(new Node(*child));
             }
-            for (auto node_child : node.children_array) {
-                this->children_array.push_back(new Node(*node_child));
+            for (auto child : node.array) {
+                this->array.push_back(new Node(*child));
             }
             return *this;
         }
 
         /**
-         * @brief       Set value to this node
+         * @brief       Set value to this node as String
          *
          * @param[in]   std::string _value  JSON value this node contains
          */
-        void SetValue(std::string _value) {
+        void SetString(std::string _value) {
             this->value = _value;
-            if (this->isvalueset) {
-                throw std::runtime_error("At SetValue() in Node class: Value is set to node set value.");
-            }
-            this->isvalueset = true;
-            if (this->ischildrenset) {
-                throw std::runtime_error("At SetValue() in Node class: Value is set to node set object.");
+            if (this->valuetype != ValueType::Default) {
+                throw std::runtime_error("At SetString() in Node class: Some value is already set.");
             }
-            if (this->isarrayset) {
-                throw std::runtime_error("At SetValue() in Node class: Value is set to node set array.");
+            this->valuetype = ValueType::String;
+        }
+
+        /**
+         * @brief       Set value to this node as Number
+         *
+         * @param[in]   std::string _value  JSON value this node contains
+         */
+        void SetNumber(std::string _value) {
+            this->value = _value;
+            if (this->valuetype != ValueType::Default) {
+                throw std::runtime_error("At SetNumber() in Node class: Some value is already set.");
             }
+            this->valuetype = ValueType::Number;
         }
 
         /**
-         * @brief       Append a child node
+         * @brief       Set value to this node as Boolean or Null
          *
-         * @param[in]   JsonParser::Node* _node Pointer indicating a child node appended in this node
+         * @param[in]   std::string _value  JSON value this node contains
          */
-        void AppendChild(Node* _node = nullptr) {
-            if (_node != nullptr) {
-                this->children.push_back(_node);
+        void SetBoolNull(std::string _value) {
+            this->value = _value;
+            if (this->valuetype != ValueType::Default) {
+                throw std::runtime_error("At SetBoolNull() in Node class: Some value is already set.");
             }
-            this->ischildrenset = true;
-            if (this->isvalueset) {
-                throw std::runtime_error("At AppendChild() in Node class: Object is set to node set value.");
+            this->valuetype = ValueType::BoolNull;
+        }
+
+        /**
+         * @brief       Append a child node as object
+         *
+         * @param[in]   JsonParser::Node* child Pointer indicating a child node appended as object in this node
+         */
+        void AppendObject(Node* child = nullptr) {
+            if (child != nullptr) {
+                this->object.push_back(child);
             }
-            if (this->isarrayset) {
-                throw std::runtime_error("At AppendChild() in Node class: Object is set to node set array.");
+            if (this->valuetype != ValueType::Default && this->valuetype != ValueType::Object) {
+                throw std::runtime_error("At AppendObject() in Node class: Some value not Object is alreadey set.");
             }
+            this->valuetype = ValueType::Object;
         }
 
         /**
          * @brief       Append a child node as array
          *
-         * @param[in]   JsonParser::Node* _node Pointer indicating a child node appended as array in this node
+         * @param[in]   JsonParser::Node* child Pointer indicating a child node appended as array in this node
          */
-        void AppendArray(Node* _node = nullptr) {
-            if (_node != nullptr) {
-                this->children_array.push_back(_node);
+        void AppendArray(Node* child = nullptr) {
+            if (child != nullptr) {
+                this->array.push_back(child);
             }
-            this->isarrayset = true;
-            if (this->isvalueset) {
-                throw std::runtime_error("At AppendArray() in Node class: Array is set to node set value.");
-            }
-            if (this->ischildrenset) {
-                throw std::runtime_error("At AppendArray() in Node class: Array is set to node set object.");
+            if (this->valuetype != ValueType::Default && this->valuetype != ValueType::Array) {
+                throw std::runtime_error("At AppendArray() in Node class: Some value not Array is alreadey set.");
             }
+            this->valuetype = ValueType::Array;
         }
 
         /**
@@ -139,7 +156,7 @@ namespace JsonParser {
          * @return      Json::Parser Node*  Reference indicating a child node corresponding to the key
          */
         Node& operator[](std::string _key) {
-            for (auto child : this->children) {
+            for (auto child : this->object) {
                 if (child->key == _key) {
                     return *child;
                 }
@@ -154,8 +171,8 @@ namespace JsonParser {
          * @return      JsonParser::Node&       Reference indicating a node corresponding to the index of array
          */
         Node& operator[](unsigned int _index) {
-            if (_index < this->children_array.size()) {
-                return *this->children_array[_index];
+            if (_index < this->array.size()) {
+                return *this->array[_index];
             }
             throw std::range_error("\"index\" is over length of Array.");
         }
@@ -166,7 +183,7 @@ namespace JsonParser {
          * @return  std::string&    Reference indicating the value of node
          */
         std::string& Value() {
-            if (this-isvalueset) {
+            if (this->valuetype == ValueType::String || this->valuetype == ValueType::Number || this->valuetype == ValueType::BoolNull) {
                 return this->value;
             }
             throw std::runtime_error("Value doesn't exist.");
@@ -180,36 +197,44 @@ namespace JsonParser {
         std::string Str() {
             std::string str("");
             if (this->key != "") {
-                str += this->key + ":";
-            }
-            if (this->isvalueset) {
+                str += "\"" + this->key + "\":";
+            }
+            switch (this->valuetype) {
+            case ValueType::String:
+                str += "\"" + this->value + "\"";
+                break;
+            case ValueType::Number:
+            case ValueType::BoolNull:
                 str += this->value;
-            } else if (this->ischildrenset) {
+                break;
+            case ValueType::Object:
                 str += "{";
-                if (this->children.size() > 0) {
-                    str += this->children[0]->Str();
+                if (this->object.size() > 0) {
+                    str += this->object[0]->Str();
                 }
-                for (int i = 1; i < this->children.size(); ++i) {
-                    str += "," + this->children[i]->Str();
+                for (int i = 1; i < this->object.size(); ++i) {
+                    str += "," + this->object[i]->Str();
                 }
                 str += "}";
-            } else if (this->isarrayset) {
+                break;
+            case ValueType::Array:
                 str += "[";
-                if (this->children_array.size() > 0) {
-                    str += this->children_array[0]->Str();
+                if (this->array.size() > 0) {
+                    str += this->array[0]->Str();
                 }
-                for (int i = 1; i < this->children_array.size(); ++i) {
-                    str += "," + this->children_array[i]->Str();
+                for (int i = 1; i < this->array.size(); ++i) {
+                    str += "," + this->array[i]->Str();
                 }
                 str += "]";
-            } else {
-                throw std::runtime_error("At operator<< of Node class: \"node\" is set neither value, object nor array.");
+                break;
+            default:
+                throw std::runtime_error("At Str() in Node class: This node has no content.");
             }
             return str;
         }
 private:
         std::string key, value;
-        bool isvalueset, ischildrenset, isarrayset;
-        std::vector<Node*> children, children_array;
+        ValueType valuetype;
+        std::vector<Node*> object, array;
     };
 }

src/parser.h

@@ -92,13 +92,13 @@ namespace JsonParser {
             // std::cout << "Object() is called and index is " << index << std::endl;
             switch (chs[index][0]) {
             case '}':
-                parent->AppendChild();
+                parent->AppendObject();
                 return index + 1;
             case '"':
                 {
-                Node* child = new Node(chs[index]);
+                Node* child = new Node(chs[index].substr(1, chs[index].size() - 2));
                 int index_current = Grammar::Value(index + 2, chs, child);
-                parent->AppendChild(child);
+                parent->AppendObject(child);
 
                 while (index_current < chs.size() && chs[index_current][0] == ',') {
                     // Check exists "key" of next object.
@@ -119,7 +119,7 @@ namespace JsonParser {
                     }
 
                     index_current = Grammar::Value(index_current + 3, chs, child);
-                    parent->AppendChild(child);
+                    parent->AppendObject(child);
                 }
 
                 return index_current + 1;
@@ -145,6 +145,8 @@ namespace JsonParser {
             // std::cout << "Value() is called and index is " << index << std::endl;
             switch (chs[index][0]) {
             case '"':
+                node->SetString(chs[index].substr(1, chs[index].size() - 2));
+                return index + 1;
             case '-':
             case '0':
             case '1':
@@ -156,10 +158,12 @@ namespace JsonParser {
             case '7':
             case '8':
             case '9':
+                node->SetNumber(chs[index]);
+                return index + 1;
             case 'n':
             case 't':
             case 'f':
-                node->SetValue(chs[index]);
+                node->SetBoolNull(chs[index]);
                 return index + 1;
             case '{':
                 return Grammar::Object(index + 1, chs, node);