adding node constructor

Author: Luispain

include/node/node_factory.hpp

@@ -0,0 +1,14 @@
+#ifndef NODE_FACTORY_HPP
+#define NODE_FACTORY_HPP
+
+# include "node/node.hpp"
+# include "array/array.hpp"
+
+template <typename T> [[gnu::used]]
+std::shared_ptr<Node> newNode(
+    const std::string& name = "",
+    const std::string& type = "",
+    const T& data = false,
+    std::shared_ptr<Node> parent = nullptr);
+
+#endif

src/c++/node/node.cpp

@@ -128,7 +128,6 @@ std::shared_ptr<Data> Node::dataPtr() const {
     return this->_data;
 }
 
-
 void Node::setData(std::shared_ptr<Data> d) {
     this->_data = std::move(d);
 }

src/c++/node/node_factory.cpp

@@ -0,0 +1,33 @@
+# include "node/node_factory.hpp"
+
+
+template <typename T> [[gnu::used]]
+std::shared_ptr<Node> newNode(
+    const std::string& name,
+    const std::string& type,
+    const T& data,
+    std::shared_ptr<Node> parent) {
+    
+    std::shared_ptr<Node> node = std::make_shared<Node>();
+    node->setName(name);
+    node->setType(type);
+    Array dataArray(data);
+    node->setData(dataArray);
+    if (parent) node->attachTo(parent);
+    
+    return node;
+}
+
+/*
+    template instantiations
+*/
+
+template <typename... T>
+struct Instantiator {
+    template <typename... U>
+    void operator()() const {
+        (static_cast<void>(newNode<U>(std::string{},std::string{},T{},std::shared_ptr<Node>{})), ...);
+    }
+};
+
+template void utils::instantiateFromTypeList<Instantiator, utils::StringAndScalarTypes>();

tests/c++/array/test_array.cpp

@@ -140,12 +140,12 @@ void test_isScalar() {
         throw py::value_error("should have been detected as scalar");
     }
 
-    Array directScalarArray = Array(12);
+    T scalar(1);
+    Array directScalarArray = Array(scalar);
     if (!directScalarArray.isScalar()) {
         throw py::value_error("should have been detected as scalar");
     }
 
-
     Array vectorArray = arrayfactory::zeros<T>({2});
     if (vectorArray.isScalar()) {
         throw py::value_error("should not have been detected as scalar");

tests/c++/node/test_node_factory.cpp

@@ -0,0 +1,22 @@
+# include "test_node_factory.hpp"
+
+using namespace std::string_literals;
+
+void test_newNodeNoArgs() {
+    // call without arguments requires type instantiation since
+    // it cannot guess data type
+    auto node = newNode<int>();
+}
+
+void test_newNodeOnlyName() {
+    auto node = newNode<int>("TheName"s);
+}
+
+void test_newNodeNameAndType() {
+    auto node = newNode<int>("TheName"s, "TheType"s);
+}
+
+void test_newNodeNameTypeAndData() {
+    // should be able to automatically find type
+    auto node = newNode("TheName"s, "TheType"s, 1);
+}

tests/c++/node/test_node_factory.hpp

@@ -0,0 +1,12 @@
+#ifndef TEST_NODE_FACTORY_H
+#define TEST_NODE_FACTORY_H
+
+# include <node/node.hpp>
+# include <node/node_factory.hpp>
+
+void test_newNodeNoArgs();
+void test_newNodeOnlyName();
+void test_newNodeNameAndType();
+void test_newNodeNameTypeAndData();
+
+#endif

tests/c++/node/test_node_factory_pybind.hpp

@@ -0,0 +1,21 @@
+# ifndef TEST_NODE_FACTORY_PYBIND_HPP
+# define TEST_NODE_FACTORY_PYBIND_HPP
+
+# include <pybind11/pybind11.h>
+
+# include "test_node_factory.hpp"
+
+void bindTestsOfNodeFactory(py::module_ &m) {
+
+    py::module_ sm = m.def_submodule("node_factory");
+    
+    sm.def("test_newNodeNoArgs", &test_newNodeNoArgs);
+    sm.def("test_newNodeOnlyName", &test_newNodeOnlyName);
+    sm.def("test_newNodeNameAndType", &test_newNodeNameAndType);
+    sm.def("test_newNodeNameTypeAndData", &test_newNodeNameTypeAndData);
+
+
+
+}
+
+# endif

tests/c++/test_core_pybind.cpp

@@ -6,6 +6,7 @@
 
 # include "array/test_array_pybind.hpp"
 # include "node/test_node_pybind.hpp"
+# include "node/test_node_factory_pybind.hpp"
 # include "data/data_factory.hpp"
 # include "node/test_data_pybind.hpp"
 # include "node/test_navigation_pybind.hpp"
@@ -27,6 +28,7 @@ PYBIND11_MODULE(tests, m) {
 
     bindTestsOfArray(m);
     bindTestsOfNode(m);
+    bindTestsOfNodeFactory(m);
     bindTestsOfData(m);
     bindTestsOfNavigation(m);
 

tests/python/array/test_array.py

@@ -90,8 +90,14 @@ def test_isScalar(dtype):
     scalarArray = zeros_builder([1],'C')
     assert scalarArray.isScalar()
 
-    directScalarArray = Array(12)
-    assert directScalarArray.isScalar()
+    directBooleanArray = Array(True)
+    assert directBooleanArray.isScalar()
+
+    directIntegerArray = Array(12)
+    assert directIntegerArray.isScalar()
+
+    directFloatArray = Array(3.14159)
+    assert directFloatArray.isScalar()
 
     vectorArray = zeros_builder([2],'C')
     assert not vectorArray.isScalar()

tests/python/node/test_node_factory_cpp.py

@@ -0,0 +1,10 @@
+import pytest
+import noder.tests.node_factory as test_in_cpp
+
+def test_cpp_newNodeNoArgs(): return test_in_cpp.test_newNodeNoArgs()
+def test_cpp_newNodeOnlyName(): return test_in_cpp.test_newNodeOnlyName()
+def test_cpp_newNodeNameAndType(): return test_in_cpp.test_newNodeNameAndType()
+def test_cpp_newNodeNameTypeAndData(): return test_in_cpp.test_newNodeNameTypeAndData()
+
+if __name__ == '__main__':
+    test_cpp_newNodeNoArgs()