Support additional variable types. Add method to get a node by name.

include/rogue/interfaces/api/Root.h

@@ -15,7 +15,15 @@
 
 namespace rogue::interfaces::api { 
 
-typedef boost::variant<Variable<bool>, Variable<int>> node_types;
+typedef boost::variant<Variable<bool>, 
+		       Variable<int>, 
+		       Variable<float>,
+		       Variable<uint8_t>, 
+		       Variable<uint32_t>, 
+		       Variable<uint64_t>, 
+		       Variable<uintmax_t>, 
+		       Variable<std::string>
+		      > node_types;
 
 class Root : Node {
 
@@ -30,16 +38,15 @@ class Root : Node {
   //! Default constuctor
   ~Root() = default; 
 
-   /**
    template <typename T> 
-   T getNode(const std::string &name) const {
+   T getNode(std::string name) const {
        auto it{_nodes.find(name)}; 
        if (it == _nodes.end()) {
            throw rogue::GeneralError::create("Root::getNode",
 			                     ("Node "+name+" does not exist.").c_str()); 
        }
-       return boost::any_cast<T>(it->second);
-   }**/
+       return boost::get<T>(_nodes.at(name));
+   }
 
   //! Setup the tree and start the polling thread.
   void start();

src/rogue/interfaces/api/Root.cpp

@@ -14,7 +14,7 @@ Root::Root(boost::python::object obj) : Node(obj) {
     auto nodes{static_cast<boost::python::list>(obj.attr("nodeList"))};
     for (auto i{0}; i < boost::python::len(nodes); ++i) {
         // Use both the class and base class name to determine the type of node
-	    // to instantiate.
+	// to instantiate.
         std::string class_name{boost::python::extract<std::string>(
 		  nodes[i].attr("__class__").attr("__name__"))};
         std::string base_class{boost::python::extract<std::string>(
@@ -24,19 +24,47 @@ Root::Root(boost::python::object obj) : Node(obj) {
         //if (base_class.compare("BaseVariable") == 0) { 
         if (class_name.find("Variable") != std::string::npos) { 
             std::string type{boost::python::extract<std::string>(nodes[i].attr("typeStr"))};
+            //std::cout << "Class name: " << class_name << std::endl;
+            //std::cout << "Base class name: " << base_class << std::endl;
+            //std::cout << "Type: " << type << std::endl;
             if (type.compare("bool") == 0) { 
-                std::cout << "Class name: " << class_name << std::endl;
-                std::cout << "Base class name: " << base_class << std::endl;
-                std::cout << "Type: " << type << std::endl;
                 _nodes.insert( 
 			std::pair<std::string, node_types>(
 				node_name, Variable<bool>{nodes[i]})); 
-            } /**else if (type.compare("int") == 0) { 
+            } else if (type.compare("int") == 0) { 
                 _nodes.insert( 
 			std::pair<std::string, node_types>(
 				node_name, Variable<int>{nodes[i]})); 
-	    }**/
-        }
+	    } else if (type.compare("str") == 0) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<std::string>{nodes[i]})); 
+	    } else if (type.compare("float") == 0) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<float>{nodes[i]})); 
+	    } else if (type.compare("UInt1") == 0) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<uint8_t>{nodes[i]})); 
+	    } else if (type.compare("UInt32") == 0) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<uint32_t>{nodes[i]})); 
+	    } else if (type.compare("UInt64") == 0) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<uint64_t>{nodes[i]})); 
+	    } /** else if (type.find("UInt") != std::string::npos) { 
+                _nodes.insert( 
+			std::pair<std::string, node_types>(
+				node_name, Variable<uintmax_t>{nodes[i]})); 
+	    }**/ else { 
+	    	std::cout << "Type not supported: " << type << std::endl;
+	    }
+        } else { 
+		std::cout << "Class not supported: " << class_name << std::endl;
+	}
     }
 
 }