Prepare version 0.0.1

Author: sea5kg

.gitignore

@@ -1,5 +1,8 @@
 .wsjcpp/*
 tmp/*
+wsjcpp-obj-tree
+.logs/*
+.vscode/*
 
 # Prerequisites
 *.d

.travis.yml

@@ -0,0 +1,23 @@
+language: cpp
+
+branches:
+  only:
+    - master
+
+dist: bionic
+
+addons:
+  apt:
+    packages:
+    - cmake
+    - make
+    - g++
+    - pkg-config
+
+# Build steps
+script:
+  - ./build_simple.sh
+  - cd unit-tests.wsjcpp
+  - ./build_simple.sh
+  - ./unit-tests
+

CMakeLists.txt

@@ -10,6 +10,8 @@ set(EXECUTABLE_OUTPUT_PATH ${wsjcpp-obj-tree_SOURCE_DIR})
 # include header dirs
 list (APPEND WSJCPP_INCLUDE_DIRS "src")
 
+list (APPEND WSJCPP_SOURCES "./src/wsjcpp_obj_tree.h")
+list (APPEND WSJCPP_SOURCES "./src/wsjcpp_obj_tree.cpp")
 list (APPEND WSJCPP_SOURCES "src/main.cpp")
 
 #### BEGIN_WSJCPP_APPEND
@@ -28,3 +30,4 @@ install(
         /usr/bin
 )
 
+

README.md

@@ -1,2 +1,5 @@
 # wsjcpp-obj-tree
+[![Build Status](https://api.travis-ci.com/wsjcpp/wsjcpp-obj-tree.svg?branch=master)](https://travis-ci.com/wsjcpp/wsjcpp-obj-tree)
+
 Multi Object Tree
+

src.wsjcpp/CMakeLists.txt

@@ -2,7 +2,7 @@
 cmake_minimum_required(VERSION 3.0)
 
 add_definitions(-DWSJCPP_APP_VERSION="v0.0.1")
-add_definitions(-DWSJCPP_APP_NAME="wsjcpp-obj-tree.git")
+add_definitions(-DWSJCPP_APP_NAME="wsjcpp-obj-tree")
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(MACOSX TRUE)

src/main.cpp

@@ -1,7 +1,8 @@
-#include <string.h>
+#include <string>
 #include <iostream>
 #include <algorithm>
 #include <wsjcpp_core.h>
+#include <wsjcpp_obj_tree.h>
 
 int main(int argc, const char* argv[]) {
     std::string TAG = "MAIN";
@@ -12,7 +13,36 @@ int main(int argc, const char* argv[]) {
     }
     WsjcppLog::setPrefixLogFile("wsjcpp");
     WsjcppLog::setLogDirectory(".logs");
-    // TODO your code here
+    
+    WsjcppObjTree tree;
+    tree.addSupportType<WsjcppObjTreeNodeString>();
+    tree.addSupportType<WsjcppObjTreeNodeInteger>();
+    tree.addSupportType<WsjcppObjTreeNodeFloat>();
+    tree.addSupportType<WsjcppObjTreeNodeDouble>();
+
+    WsjcppObjTreeChainDeclare chain(&tree);
+
+    chain
+        .add("Motherboard")
+            .add("CPU_SOCKET")
+                .add("count")
+                    .add(1).up()
+                .up()
+                .add("frequency")
+                    .add(3.2).up()
+                .up()
+            .add("GPU_SOCKET")
+                .add(1).up()
+            .add("USB-A")
+                .add(4).up()
+            .add("PCI")
+                .add(3).up()
+            .add("PCI_EXPRESS")
+                .add(1).up()
+            .up()
+        .up()
+    ;
+
     return 0;
 }
 

src/wsjcpp_obj_tree.cpp

@@ -0,0 +1,385 @@
+
+#include "wsjcpp_obj_tree.h"
+#include <wsjcpp_core.h>
+#include <algorithm>
+#include <fstream>
+
+// ---------------------------------------------------------------------
+// WsjcppObjTreeNode
+
+WsjcppObjTreeNode::WsjcppObjTreeNode(WsjcppObjTree *pTree, uint16_t nType) {
+    m_pTree = pTree;
+    m_pParent = nullptr;
+    m_nType = nType;
+    // TODO regestry in global factory
+}
+
+// ---------------------------------------------------------------------
+
+uint16_t WsjcppObjTreeNode::getType() {
+    return m_nType;
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTreeNode::~WsjcppObjTreeNode() {
+    // std::cout << "TreeNode destroyed" << std::endl;
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTreeNode *WsjcppObjTreeNode::getParent() {
+    return m_pParent;
+}
+
+// ---------------------------------------------------------------------
+
+uint32_t WsjcppObjTreeNode::getId() {
+    return m_nId;
+}
+
+// ---------------------------------------------------------------------
+
+const std::vector<WsjcppObjTreeNode *> &WsjcppObjTreeNode::getChilds() {
+    return m_vChilds;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNode::setParent(WsjcppObjTreeNode *pParent) {
+    m_pParent = pParent;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNode::addChild(WsjcppObjTreeNode *pChild) {
+    m_vChilds.push_back(pChild);
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNode::setId(uint32_t nId) {
+    m_nId = nId;
+}
+
+// ---------------------------------------------------------------------
+// WsjcppObjTree
+
+WsjcppObjTree::WsjcppObjTree() {
+    m_nLastId = 0;
+    TAG = "WsjcppObjTree";
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTree::~WsjcppObjTree() {
+    clearNodes();
+    std::map<uint16_t, IFabricWsjcppObjTreeNode*>::iterator it;
+    for (it = m_mapFabricTreeNode.begin(); it != m_mapFabricTreeNode.end(); ++it) {
+        delete it->second;
+    }
+    m_mapFabricTreeNode.clear();
+
+}
+
+// ---------------------------------------------------------------------
+
+bool WsjcppObjTree::readTreeFromFile(const std::string &sFilename, std::string &sError) {
+    if (!WsjcppCore::fileExists(sFilename)) {
+        return false;
+    }
+    return true;
+}
+
+// ---------------------------------------------------------------------
+
+bool WsjcppObjTree::writeTreeToFile(const std::string &sFilename, std::string &sError) {
+    std::ofstream f(sFilename.c_str(), std::ios::out | std::ios::binary);
+    if (!f) {
+        std::cout << "FAILED could not create file to write " << sFilename << std::endl;
+        return false;
+    }
+
+    // m_nLastId
+    int nTreeSize = m_vNodes.size();
+    this->writeUInt32(f, nTreeSize);
+    this->writeUInt32(f, m_nLastId);
+
+    unsigned char arrShort[4];
+
+    for (int i = 0; i < nTreeSize; i++) {
+        WsjcppObjTreeNode *pNode = m_vNodes[i];
+
+        // write type
+        this->writeUInt16(f, pNode->getType());
+
+        // write parent id
+        if (pNode->getParent() != nullptr) {
+            this->writeUInt32(f, pNode->getParent()->getId());
+        } else {
+            this->writeUInt32(f, 0);
+        }
+        
+        // write id
+        this->writeUInt32(f, pNode->getId());
+
+        // write data size
+        int nDataSize = pNode->getDataSize();
+        this->writeUInt32(f, nDataSize);
+
+        // write data
+        f.write(pNode->getData(), nDataSize);
+    }
+    f.close();
+    return true;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTree::clearNodes() {
+    int nSize = m_vNodes.size();
+    for (int i = nSize - 1; i >=0; i--) {
+        delete m_vNodes[i];
+    }
+    m_vNodes.clear();
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTree::addNode(WsjcppObjTreeNode *pParent, WsjcppObjTreeNode *pChild) {
+    if (pChild == nullptr) {
+        WsjcppLog::throw_err(TAG, "::addNode - Child could not be null");
+    }
+    // check type of node
+    if (!this->isSupportType(pChild->getType())) {
+        WsjcppLog::throw_err(TAG, "::addNode - Not supported type");
+    }
+
+    std::vector<WsjcppObjTreeNode *>::iterator it;
+
+    // check that parent node already exists in a list
+    if (pParent != nullptr && !this->hasNode(pParent)) {
+        WsjcppLog::throw_err(TAG, "::addNode - Not found parent node in the tree");
+    }
+
+    // check child node - exclude circles
+    if (this->hasNode(pChild)) {
+        WsjcppLog::throw_err(TAG, "::addNode - Child already added in the tree");
+    }
+
+    pChild->setParent(pParent);
+    if (pParent != nullptr) {
+        pParent->addChild(pChild);
+    }
+    m_nLastId++;
+    pChild->setId(m_nLastId);
+    m_vNodes.push_back(pChild);
+}
+
+// ---------------------------------------------------------------------
+
+bool WsjcppObjTree::isSupportType(uint16_t nType) {
+    std::map<uint16_t, IFabricWsjcppObjTreeNode*>::iterator it;
+    it = m_mapFabricTreeNode.find(nType);
+    return it != m_mapFabricTreeNode.end();
+}
+
+// ---------------------------------------------------------------------
+
+bool WsjcppObjTree::hasNode(WsjcppObjTreeNode *pNode) {
+    std::vector<WsjcppObjTreeNode *>::iterator it;
+    it = std::find(m_vNodes.begin(), m_vNodes.end(), pNode);
+    return it != m_vNodes.end();
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTree::writeUInt32(std::ofstream &f, uint32_t nVal) {
+    // not for multithreading
+    // TODO redesign to reinterpret_cast<const char *>(&m_nValue);
+    static unsigned char arrInteger[4];
+    arrInteger[0] = (nVal >> 24) & 0xFF;
+    arrInteger[1] = (nVal >> 16) & 0xFF;
+    arrInteger[2] = (nVal >> 8) & 0xFF;
+    arrInteger[3] = nVal & 0xFF;
+    f.write((const char *)arrInteger, 4);
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTree::writeUInt16(std::ofstream &f, uint16_t nVal) {
+    // not for multithreading
+    static unsigned char arrShort[2];
+    arrShort[0] = (nVal >> 8) & 0xFF;
+    arrShort[1] = nVal & 0xFF;
+    f.write((const char *)arrShort, 2);
+}
+
+// ---------------------------------------------------------------------
+//WsjcppObjTreeChainDeclare
+
+WsjcppObjTreeChainDeclare::WsjcppObjTreeChainDeclare(WsjcppObjTree *pTree) {
+    TAG = "WsjcppObjTreeChainDeclare";
+    m_pTree = pTree;
+    m_pCurrentNode = nullptr;
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTreeChainDeclare &WsjcppObjTreeChainDeclare::addNode(WsjcppObjTreeNode *pNode) {
+    m_pTree->addNode(m_pCurrentNode, pNode);
+    m_pCurrentNode = pNode;
+    return *this;
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTreeChainDeclare &WsjcppObjTreeChainDeclare::up() {
+    if (m_pCurrentNode != nullptr) {
+        m_pCurrentNode = m_pCurrentNode->getParent();
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------
+
+WsjcppObjTreeChainDeclare &WsjcppObjTreeChainDeclare::switchTo(WsjcppObjTreeNode *pNode) {
+    if (!m_pTree->hasNode(pNode)) {
+        WsjcppLog::throw_err(TAG, "::switchTo Not existed node in tree");
+    }
+    m_pCurrentNode = pNode;
+    return *this;
+}
+
+// ---------------------------------------------------------------------
+// WsjcppObjTreeNodeString
+
+WsjcppObjTreeNodeString::WsjcppObjTreeNodeString(WsjcppObjTree *pTree, const std::string &sValue) 
+: WsjcppObjTreeNode(pTree, WsjcppObjTreeNodeString::staticType()) {
+    m_sValue = sValue;
+}
+
+// ---------------------------------------------------------------------
+
+std::string WsjcppObjTreeNodeString::getValue() {
+    return m_sValue;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNodeString::setValue(const std::string &sValue) {
+    m_sValue = sValue;
+}
+
+// ---------------------------------------------------------------------
+
+int WsjcppObjTreeNodeString::getDataSize() {
+    return m_sValue.size();
+}
+
+// ---------------------------------------------------------------------
+
+const char *WsjcppObjTreeNodeString::getData() {
+    return m_sValue.c_str();
+}
+
+// ---------------------------------------------------------------------
+// WsjcppObjTreeNodeInteger
+
+WsjcppObjTreeNodeInteger::WsjcppObjTreeNodeInteger(WsjcppObjTree *pTree, const int32_t &nValue)
+: WsjcppObjTreeNode(pTree, WsjcppObjTreeNodeInteger::staticType()) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+int32_t WsjcppObjTreeNodeInteger::getValue() {
+    return m_nValue;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNodeInteger::setValue(int32_t nValue) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+int WsjcppObjTreeNodeInteger::getDataSize() {
+    return sizeof(uint32_t);
+}
+
+// ---------------------------------------------------------------------
+
+const char *WsjcppObjTreeNodeInteger::getData() {
+    const char *p = reinterpret_cast<const char *>(&m_nValue);
+    return p;
+}
+
+// ---------------------------------------------------------------------
+// WsjcppObjTreeNodeFloat
+
+WsjcppObjTreeNodeFloat::WsjcppObjTreeNodeFloat(WsjcppObjTree *pTree, const float &nValue)
+: WsjcppObjTreeNode(pTree, WsjcppObjTreeNodeFloat::staticType()) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+float WsjcppObjTreeNodeFloat::getValue() {
+    return m_nValue;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNodeFloat::setValue(float nValue) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+int WsjcppObjTreeNodeFloat::getDataSize() {
+    static_assert(sizeof(float) == 4, "Expected sizeof(float) == 4");
+    return sizeof(float);
+}
+
+// ---------------------------------------------------------------------
+
+const char *WsjcppObjTreeNodeFloat::getData() {
+    return reinterpret_cast<const char *>(&m_nValue);
+}
+
+
+// ---------------------------------------------------------------------
+// WsjcppObjTreeNodeDouble
+
+WsjcppObjTreeNodeDouble::WsjcppObjTreeNodeDouble(WsjcppObjTree *pTree, const double &nValue)
+: WsjcppObjTreeNode(pTree, WsjcppObjTreeNodeDouble::staticType()) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+float WsjcppObjTreeNodeDouble::getValue() {
+    return m_nValue;
+}
+
+// ---------------------------------------------------------------------
+
+void WsjcppObjTreeNodeDouble::setValue(float nValue) {
+    m_nValue = nValue;
+}
+
+// ---------------------------------------------------------------------
+
+int WsjcppObjTreeNodeDouble::getDataSize() {
+    static_assert(sizeof(double) == 8, "Expected sizeof(double) == 8");
+    return sizeof(double);
+}
+
+// ---------------------------------------------------------------------
+
+const char *WsjcppObjTreeNodeDouble::getData() {
+    return reinterpret_cast<const char *>(&m_nValue);
+}
+

src/wsjcpp_obj_tree.h

@@ -0,0 +1,230 @@
+#ifndef WSJCPP_OBJ_TREE_H
+#define WSJCPP_OBJ_TREE_H
+
+#include <wsjcpp_core.h>
+#include <string>
+#include <map>
+
+// not enum - because need more extendable from different modules
+
+static uint16_t WSJCPP_OBJ_TREE_NODE_NONE = 0;
+static uint16_t WSJCPP_OBJ_TREE_NODE_STRING = 1;
+static uint16_t WSJCPP_OBJ_TREE_NODE_INTEGER = 2;
+static uint16_t WSJCPP_OBJ_TREE_NODE_FLOAT = 3;
+static uint16_t WSJCPP_OBJ_TREE_NODE_DOUBLE = 4;
+
+class WsjcppObjTree;
+
+class WsjcppObjTreeNode {
+    friend class WsjcppObjTree;
+
+    public:
+        WsjcppObjTreeNode(WsjcppObjTree *pTree, uint16_t nType);
+        virtual ~WsjcppObjTreeNode();
+        uint16_t getType();
+
+        // virtual zero methods will be deny create basic class
+        virtual int getDataSize() = 0;
+        virtual const char *getData() = 0;
+
+        WsjcppObjTreeNode *getParent();
+        uint32_t getId();
+        const std::vector<WsjcppObjTreeNode *> &getChilds();
+
+    protected:
+        void setParent(WsjcppObjTreeNode *pParent);
+        void addChild(WsjcppObjTreeNode *pChild);
+        void setId(uint32_t id);
+
+    private:
+        WsjcppObjTree *m_pTree;
+        WsjcppObjTreeNode *m_pParent;
+        uint32_t m_nId;
+        std::vector<WsjcppObjTreeNode *> m_vChilds;
+        uint16_t m_nType;  
+};
+
+class IFabricWsjcppObjTreeNode {
+    public:
+        virtual ~IFabricWsjcppObjTreeNode() {};
+        virtual WsjcppObjTreeNode *create() = 0;
+};
+
+
+template<class T>
+class FabricWsjcppObjTreeNode : public IFabricWsjcppObjTreeNode {
+    public:
+        FabricWsjcppObjTreeNode(WsjcppObjTree *pTree) : m_pTree(pTree) { };
+        ~FabricWsjcppObjTreeNode() {};
+        virtual WsjcppObjTreeNode *create() override {
+            return new T(m_pTree);
+        };
+    private:
+        WsjcppObjTree *m_pTree;
+};
+
+
+class WsjcppObjTree {
+    friend class WsjcppObjTreeNode;
+
+    public:
+        WsjcppObjTree();
+        ~WsjcppObjTree();
+
+        bool readTreeFromFile(const std::string &sFilename, std::string &sError);
+        bool writeTreeToFile(const std::string &sFilename, std::string &sError);
+        void clearNodes();
+        void addNode(WsjcppObjTreeNode *pParent, WsjcppObjTreeNode *pChild);
+
+        template<class T>
+        bool addSupportType() {
+            std::map<uint16_t, IFabricWsjcppObjTreeNode*>::iterator it;
+            uint16_t nType = T::staticType();
+            it = m_mapFabricTreeNode.find(nType);
+            if (it != m_mapFabricTreeNode.end()) {
+                WsjcppLog::err(TAG, "WsjcppObjTreeNode '" + std::to_string(nType) + "' type already registered.");
+                return false;
+            }
+            m_mapFabricTreeNode[nType] = new FabricWsjcppObjTreeNode<T>(this);
+            return true;
+        }
+        bool isSupportType(uint16_t );
+        bool hasNode(WsjcppObjTreeNode *);
+
+        template<class T, class A>
+        int findNodes(const A &val, std::vector<T *> &vFoundNodes) {
+            int nRet = 0;
+            uint16_t nType = T::staticType();
+            std::vector<WsjcppObjTreeNode *>::iterator it = m_vNodes.begin();
+            for (it = m_vNodes.begin(); it != m_vNodes.end(); ++it) {
+                if ((*it)->getType() == nType) {
+                    T *pNode = static_cast<T *>(*it);
+                    if (pNode->getValue() == val) {
+                        vFoundNodes.push_back(pNode);
+                        nRet++;
+                    }
+                }
+            }
+            return nRet;
+        };
+        
+    private:
+        std::string TAG;
+        std::vector<WsjcppObjTreeNode *> m_vNodes;
+        int m_nLastId;
+        std::map<uint16_t, IFabricWsjcppObjTreeNode*> m_mapFabricTreeNode;
+
+        void writeUInt32(std::ofstream &f, uint32_t nVal);
+        void writeUInt16(std::ofstream &f, uint16_t nVal);
+};
+
+class WsjcppObjTreeChainDeclare {
+    public:
+        WsjcppObjTreeChainDeclare(WsjcppObjTree *pTree);
+        
+        WsjcppObjTreeChainDeclare &addNode(WsjcppObjTreeNode *);
+
+        template<class T, class A>
+        WsjcppObjTreeChainDeclare &addT(const A &val) {
+            WsjcppObjTreeNode *pNode = new T(m_pTree, val);
+            return addNode(pNode);
+        }
+        template<typename T> WsjcppObjTreeChainDeclare &add(const T &val);
+        template<typename T> WsjcppObjTreeChainDeclare &add(const T *val);
+        WsjcppObjTreeChainDeclare &up();
+        WsjcppObjTreeChainDeclare &switchTo(WsjcppObjTreeNode *);
+
+    private:
+        std::string TAG;
+        WsjcppObjTree *m_pTree;
+        WsjcppObjTreeNode *m_pCurrentNode;
+};
+
+// define for inline templates
+#define WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE( type0, classname ) \
+    template<> inline \
+    WsjcppObjTreeChainDeclare &WsjcppObjTreeChainDeclare::add< type0 >(type0 const &val) { \
+        return this->addT< classname >(val); \
+    }
+
+#define WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE_P( type0, classname ) \
+    template<> inline \
+    WsjcppObjTreeChainDeclare &WsjcppObjTreeChainDeclare::add< type0 >(type0 const *val) { \
+        return this->addT< classname >(val); \
+    }
+
+class WsjcppObjTreeNodeString : public WsjcppObjTreeNode {
+    public:
+        WsjcppObjTreeNodeString(WsjcppObjTree *pTree, const std::string &sValue = "");
+        static uint16_t staticType() { return WSJCPP_OBJ_TREE_NODE_STRING; }; // string
+        
+        std::string getValue();
+        void setValue(const std::string &sValue);
+        
+        // TreeNode
+        virtual int getDataSize() override;
+        virtual const char *getData() override;
+
+    private:
+        std::string m_sValue;
+};
+
+WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE(std::string, WsjcppObjTreeNodeString)
+WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE_P(char, WsjcppObjTreeNodeString)
+
+class WsjcppObjTreeNodeInteger : public WsjcppObjTreeNode {
+    public:
+        WsjcppObjTreeNodeInteger(WsjcppObjTree *pTree, const int32_t &nValue = 0);
+        static uint16_t staticType() { return WSJCPP_OBJ_TREE_NODE_INTEGER; }; // integer 32
+        
+        int32_t getValue();
+        void setValue(int32_t nValue);
+
+        // WsjcppObjTreeNode
+        virtual int getDataSize() override;
+        virtual const char *getData() override;
+
+    private:
+        int32_t m_nValue;
+};
+
+WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE(int, WsjcppObjTreeNodeInteger)
+
+class WsjcppObjTreeNodeFloat : public WsjcppObjTreeNode {
+    public:
+        WsjcppObjTreeNodeFloat(WsjcppObjTree *pTree, const float &nValue = 0);
+        static uint16_t staticType() { return WSJCPP_OBJ_TREE_NODE_FLOAT; }; // float
+        
+        float getValue();
+        void setValue(float nValue);
+
+        // TreeNode
+        virtual int getDataSize() override;
+        virtual const char *getData() override;
+
+    private:
+        float m_nValue;
+};
+
+WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE(float, WsjcppObjTreeNodeFloat)
+
+
+class WsjcppObjTreeNodeDouble : public WsjcppObjTreeNode {
+    public:
+        WsjcppObjTreeNodeDouble(WsjcppObjTree *pTree, const double &nValue = 0);
+        static uint16_t staticType() { return WSJCPP_OBJ_TREE_NODE_DOUBLE; };
+        
+        float getValue();
+        void setValue(float nValue);
+
+        // TreeNode
+        virtual int getDataSize() override;
+        virtual const char *getData() override;
+
+    private:
+        double m_nValue;
+};
+
+WSJCPP_OBJ_TREE_CHAIN_DECLARE_INLINE(double, WsjcppObjTreeNodeDouble)
+
+#endif // WSJCPP_OBJ_TREE_H

unit-tests.wsjcpp/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.0)
 
 project(unit-tests C CXX)
 add_definitions(-DWSJCPP_APP_VERSION="ut-v0.0.1")
-add_definitions(-DWSJCPP_APP_NAME="unit-tests-wsjcpp-obj-tree.git")
+add_definitions(-DWSJCPP_APP_NAME="unit-tests-wsjcpp-obj-tree")
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(MACOSX TRUE)
@@ -29,11 +29,19 @@ list (APPEND WSJCPP_SOURCES "../src.wsjcpp/wsjcpp_core/wsjcpp_unit_tests_main.cp
 list (APPEND WSJCPP_SOURCES "../src.wsjcpp/wsjcpp_core/wsjcpp_resources_manager.h")
 list (APPEND WSJCPP_SOURCES "../src.wsjcpp/wsjcpp_core/wsjcpp_resources_manager.cpp")
 
-# wsjcpp-obj-tree.git:v0.0.1
+# wsjcpp-obj-tree:v0.0.1
 list (APPEND WSJCPP_INCLUDE_DIRS "../src")
+list (APPEND WSJCPP_SOURCES "../src/wsjcpp_obj_tree.h")
+list (APPEND WSJCPP_SOURCES "../src/wsjcpp_obj_tree.cpp")
 
 # unit-tests
 list (APPEND WSJCPP_INCLUDE_DIRS "src")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_add_node.h")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_add_node.cpp")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_write_tree.h")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_write_tree.cpp")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_find_nodes.h")
+list (APPEND WSJCPP_SOURCES "../unit-tests.wsjcpp/src/unit_test_find_nodes.cpp")
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.user-custom.txt)
 

unit-tests.wsjcpp/data/.gitkeeper

@@ -0,0 +1,70 @@
+#include "unit_test_add_node.h"
+#include <vector>
+#include <wsjcpp_core.h>
+#include <wsjcpp_obj_tree.h>
+
+REGISTRY_WSJCPP_UNIT_TEST(UnitTestAddNode)
+
+UnitTestAddNode::UnitTestAddNode()
+    : WsjcppUnitTestBase("UnitTestAddNode") {
+}
+
+// ---------------------------------------------------------------------
+
+void UnitTestAddNode::init() {
+    // nothing
+}
+
+// ---------------------------------------------------------------------
+
+bool UnitTestAddNode::run() {
+    bool bTestSuccess = true;
+
+    WsjcppObjTree tree;
+    tree.addSupportType<WsjcppObjTreeNodeString>();
+    tree.addSupportType<WsjcppObjTreeNodeInteger>();
+    tree.addSupportType<WsjcppObjTreeNodeFloat>();
+    
+    auto *pNodeRoot = new WsjcppObjTreeNodeInteger(&tree, 8);
+    auto *pNodeBar = new WsjcppObjTreeNodeString(&tree, "bar");
+    auto *pNodeBaz = new WsjcppObjTreeNodeString(&tree, "baz");
+    auto *pNode1dot2 = new WsjcppObjTreeNodeFloat(&tree, 1.2);
+
+    compareN(bTestSuccess, "pNodeRoot->getType()", pNodeRoot->getType(), WSJCPP_OBJ_TREE_NODE_INTEGER);
+    compareN(bTestSuccess, "pNodeBar->getType()", pNodeBar->getType(), WSJCPP_OBJ_TREE_NODE_STRING);
+    compareN(bTestSuccess, "pNodeBaz->getType()", pNodeBaz->getType(), WSJCPP_OBJ_TREE_NODE_STRING);
+    compareN(bTestSuccess, "pNode1dot2->getType()", pNode1dot2->getType(), WSJCPP_OBJ_TREE_NODE_FLOAT);
+
+    compareB(bTestSuccess, "pNodeRoot getParent", pNodeRoot->getParent() == nullptr, true);
+    compareB(bTestSuccess, "pNodeBar getParent", pNodeBar->getParent() == nullptr, true);
+    compareB(bTestSuccess, "pNodeBaz getParent", pNodeBaz->getParent() == nullptr, true);
+    compareB(bTestSuccess, "pNode1dot2 getParent", pNode1dot2->getParent() == nullptr, true);
+
+    tree.addNode(nullptr, pNodeRoot);
+    tree.addNode(pNodeRoot, pNodeBar);
+    tree.addNode(pNodeRoot, pNodeBaz);
+
+    compareB(bTestSuccess, "tree.hasNode pNodeRoot", tree.hasNode(pNodeRoot), true);
+    compareB(bTestSuccess, "tree.hasNode pNodeBar", tree.hasNode(pNodeBar), true);
+    compareB(bTestSuccess, "tree.hasNode pNodeBaz", tree.hasNode(pNodeBaz), true);
+    compareB(bTestSuccess, "tree.hasNode pNode1dot2", tree.hasNode(pNode1dot2), false);
+    
+    tree.addNode(pNodeBaz, pNode1dot2);
+    compareB(bTestSuccess, "tree.hasNode pNode1dot2", tree.hasNode(pNode1dot2), true);
+
+    const std::vector<WsjcppObjTreeNode *> &vRootChilds = pNodeRoot->getChilds();
+    compareN(bTestSuccess, "vRootChilds.size()", vRootChilds.size(), 2);
+    if (vRootChilds.size() == 2) {
+        compareB(bTestSuccess, "vRootChilds[0] == pNodeBar", vRootChilds[0] == (WsjcppObjTreeNode *)pNodeBar, true);
+        compareB(bTestSuccess, "vRootChilds[1] == pNodeBaz", vRootChilds[1] == (WsjcppObjTreeNode *)pNodeBaz, true);
+    }
+
+    const std::vector<WsjcppObjTreeNode *> &vBazChilds = pNodeBaz->getChilds();
+    compareN(bTestSuccess, "vBazChilds.size()", vBazChilds.size(), 1);
+    if (vBazChilds.size() == 1) {
+        compareB(bTestSuccess, "vBazChilds[0] == pNode1dot2", vBazChilds[0] == (WsjcppObjTreeNode *)pNode1dot2, true);
+    }
+
+    return bTestSuccess;
+}
+

unit-tests.wsjcpp/data/tmp/example.obj-tree

@@ -0,0 +1,15 @@
+#ifndef UNIT_TEST_ADD_NODE_H
+#define UNIT_TEST_ADD_NODE_H
+
+#include <wsjcpp_unit_tests.h>
+
+// Description: TODO
+class UnitTestAddNode : public WsjcppUnitTestBase {
+    public:
+        UnitTestAddNode();
+        virtual void init();
+        virtual bool run();
+};
+
+#endif // UNIT_TEST_ADD_NODE_H
+

unit-tests.wsjcpp/src/unit_test_add_node.cpp

@@ -0,0 +1,90 @@
+#include "unit_test_find_nodes.h"
+#include <vector>
+#include <wsjcpp_core.h>
+#include <wsjcpp_obj_tree.h>
+
+REGISTRY_WSJCPP_UNIT_TEST(UnitTestFindNodes)
+
+UnitTestFindNodes::UnitTestFindNodes()
+    : WsjcppUnitTestBase("UnitTestFindNodes") {
+}
+
+// ---------------------------------------------------------------------
+
+void UnitTestFindNodes::init() {
+    // nothing
+}
+
+// ---------------------------------------------------------------------
+
+
+class CompStruct : public WsjcppObjTree {
+    public:
+        CompStruct() {
+            addSupportType<WsjcppObjTreeNodeString>();
+            addSupportType<WsjcppObjTreeNodeInteger>();
+            addSupportType<WsjcppObjTreeNodeFloat>();
+            addSupportType<WsjcppObjTreeNodeDouble>();
+        }
+};
+
+bool UnitTestFindNodes::run() {
+    bool bTestSuccess = true;
+
+    CompStruct comp;
+
+    WsjcppObjTreeChainDeclare chain(&comp);
+
+    chain
+        .add("Motherboard")
+            .add("CPU_SOCKET")
+                .add("count")
+                    .add(1).up()
+                .up()
+                .add("frequency")
+                    .add(3.2).up()
+                .up()
+            .add("GPU_SOCKET")
+                .add("count")
+                    .add(1).up()
+                .up()
+            .add("USB-A")
+                .add(4).up()
+            .add("PCI")
+                .add(3).up()
+            .add("PCI_EXPRESS")
+                .add(1).up()
+            .up()
+        .up()
+    ;
+
+    std::vector<WsjcppObjTreeNodeString *> vFoundNodes;
+    comp.findNodes("frequency", vFoundNodes);
+    compareN(bTestSuccess, "Find 'frequency' ", vFoundNodes.size(), 1);
+
+    if (vFoundNodes.size() == 1) {
+        WsjcppObjTreeNode *pNode = vFoundNodes[0];
+        compareN(bTestSuccess, "'frequency' childs size", pNode->getChilds().size(), 1);
+        if (pNode->getChilds().size() == 1) {
+            WsjcppObjTreeNode *pNode2 = pNode->getChilds()[0];
+            compareB(bTestSuccess, "'frequency' parent of the child", pNode2->getParent() == pNode, true);
+            compareN(bTestSuccess, "'frequency' child type", pNode2->getType(), WSJCPP_OBJ_TREE_NODE_DOUBLE);
+            WsjcppObjTreeNodeDouble *pDouble = (WsjcppObjTreeNodeDouble *)pNode2;
+            compareN(bTestSuccess, "'frequency' child data size", pDouble->getDataSize(), 8);
+            compareS(bTestSuccess, "'frequency' child value", std::to_string(pDouble->getValue()), std::to_string(3.2));
+        }
+    }
+    
+    vFoundNodes[0]->getChilds()[0];
+
+    
+    comp.findNodes("count", vFoundNodes);
+    compareN(bTestSuccess, "Find 'count' and 'frequency' ", vFoundNodes.size(), 3);
+
+    vFoundNodes.clear();
+    comp.findNodes("count", vFoundNodes);
+    compareN(bTestSuccess, "Find 'count' ", vFoundNodes.size(), 2);
+    
+    return bTestSuccess;
+}
+

unit-tests.wsjcpp/src/unit_test_add_node.h

@@ -0,0 +1,15 @@
+#ifndef UNIT_TEST_FIND_NODES_H
+#define UNIT_TEST_FIND_NODES_H
+
+#include <wsjcpp_unit_tests.h>
+
+// Description: TODO
+class UnitTestFindNodes : public WsjcppUnitTestBase {
+    public:
+        UnitTestFindNodes();
+        virtual void init();
+        virtual bool run();
+};
+
+#endif // UNIT_TEST_FIND_NODES_H
+

unit-tests.wsjcpp/src/unit_test_find_nodes.cpp

@@ -0,0 +1,75 @@
+#include "unit_test_write_tree.h"
+#include <vector>
+#include <wsjcpp_core.h>
+#include <wsjcpp_obj_tree.h>
+
+REGISTRY_WSJCPP_UNIT_TEST(UnitTestWriteTree)
+
+UnitTestWriteTree::UnitTestWriteTree()
+    : WsjcppUnitTestBase("UnitTestWriteTree") {
+}
+
+// ---------------------------------------------------------------------
+
+void UnitTestWriteTree::init() {
+    // nothing
+}
+
+class CompStruct : public WsjcppObjTree {
+    public:
+        CompStruct() {
+            addSupportType<WsjcppObjTreeNodeString>();
+            addSupportType<WsjcppObjTreeNodeInteger>();
+            addSupportType<WsjcppObjTreeNodeFloat>();
+            addSupportType<WsjcppObjTreeNodeDouble>();
+        }
+};
+
+// ---------------------------------------------------------------------
+
+bool UnitTestWriteTree::run() {
+    bool bTestSuccess = true;
+
+    CompStruct comp;
+
+    WsjcppObjTreeChainDeclare chain(&comp);
+
+    chain
+        .add("Motherboard")
+            .add("CPU_SOCKET")
+                .add("count")
+                    .add(1).up()
+                .up()
+                .add("frequency")
+                    .add(3.2).up()
+                .up()
+            .add("GPU_SOCKET")
+                .add(1).up()
+            .add("USB-A")
+                .add(4).up()
+            .add("PCI")
+                .add(3).up()
+            .add("PCI_EXPRESS")
+                .add(1).up()
+            .up()
+        .up()
+    ;
+
+    if (!WsjcppCore::dirExists("./data/tmp")) {
+        WsjcppCore::makeDir("./data/tmp");
+    }
+
+    std::string sFilename = "./data/tmp/example.obj-tree";
+    std::string sError;
+    bool bWrote = comp.writeTreeToFile(sFilename, sError);
+    compareB(bTestSuccess, "write to file", bWrote, true);
+
+    char *pBuffer = nullptr;
+    int nBufferSize = 0;
+    WsjcppCore::readFileToBuffer(sFilename, &pBuffer, nBufferSize);
+
+    compareN(bTestSuccess, "write to file", nBufferSize, 296);
+    
+    return bTestSuccess;
+}
+

unit-tests.wsjcpp/src/unit_test_find_nodes.h

@@ -0,0 +1,15 @@
+#ifndef UNIT_TEST_WRITE_TREE_H
+#define UNIT_TEST_WRITE_TREE_H
+
+#include <wsjcpp_unit_tests.h>
+
+// Description: TODO
+class UnitTestWriteTree : public WsjcppUnitTestBase {
+    public:
+        UnitTestWriteTree();
+        virtual void init();
+        virtual bool run();
+};
+
+#endif // UNIT_TEST_WRITE_TREE_H
+

unit-tests.wsjcpp/src/unit_test_write_tree.cpp

@@ -7,7 +7,7 @@ authors:
   - name: "Evgenii Sopov"
     email: "mrseakg@gmail.com"
 origins:
-  - address: "https://sea-kg.com/wsjcpp-package-registry/"
+  - address: "https://wsjcpp.org/wsjcpp-package-registry/"
     type: "package-registry"
 keywords:
   - "c++"
@@ -17,3 +17,18 @@ dependencies:
     url: "https://github.com/wsjcpp/wsjcpp-core:master"
     origin: "https://github.com/"
     installation-dir: "./src.wsjcpp/wsjcpp_core"
+distribution:
+  - source-file: "src/wsjcpp_obj_tree.h"
+    target-file: "wsjcpp_obj_tree.h"
+    type: "source-code"
+  - source-file: "src/wsjcpp_obj_tree.cpp"
+    target-file: "wsjcpp_obj_tree.cpp"
+    type: "source-code"
+unit-tests:
+  cases:
+    - name: "AddNode"
+      description: ""
+    - name: "WriteTree"
+      description: ""
+    - name: "FindNodes"
+      description: ""