graph linking and traversing

4 files changed, 125 insertions, 94 deletions

diff --git a/Ianimal/Ianimal.cpp b/Ianimal/Ianimal.cpp
index 5aa70cd..2814757 100644
--- a/Ianimal/Ianimal.cpp
+++ b/Ianimal/Ianimal.cpp
@@ -1,37 +1,75 @@
 #include <string>
 #include <iostream>
-#include <map>
+#include <unordered_map>
 #include <vector>
 
+//simple really, to refer to a class from a pointer to the base class, the base class must refer to every member
+//how to make a factory for a derived class carrying settings in the constructor
+
 using namespace std;
 
 class Node { //abstract base class
 	public:
-		virtual string get_name() = 0; //signal output
+		virtual string get_name(){}; //base class
+		virtual Node* clone(unordered_map<string,string> &_settings){};
+		void set(unordered_map<string,string> &_settings){settings=_settings;type=settings["type"];};
+		unordered_map<string,string> settings;
+		string get_type(){ return type; };
+		string type;
+};
+class Node_o: public Node {
+	public:
+		virtual string get_occupation(){}; //needs to be an abstract subclass implementing the interface
+
 };
 
-class A_node: public Node {
+
+class A_node: public Node_o {
 	public:
+		A_node(){};
+		A_node(unordered_map<string,string> &_settings){
+			settings=_settings;
+			type=_settings["type"];
+			cout << "making a " << type << endl;
+		};
+		A_node* clone(unordered_map<string,string> &_settings) { return new A_node(_settings);};
 		string get_name(){ return "A"; };
 		string get_occupation(){ return "an A"; };
+		
 };
 
-class B_node: public Node {
+class B_node: public Node_o {
 	public:
+		B_node(){};
+		B_node(unordered_map<string,string> &_settings) {
+		settings=_settings;
+		type=_settings["type"];
+		cout << "making a " << type << endl;
+		};
+		B_node* clone(unordered_map<string,string> &_settings) { return new B_node(_settings);};
 		string get_name(){ return "B"; };
 		string get_occupation(){ return "a B"; };
 };
 
-class C_node: public Node {
+class C_node: public Node_o {
 	public:
-		string get_name(){ return "C"; };
-		string get_occupation(){ return "a C"; };
+		C_node(){};
+		C_node(unordered_map<string,string> &_settings) {
+		settings=_settings;
+		type=_settings["type"];
+		cout << "making a " << type << endl;
+		};
+		C_node* clone(unordered_map<string,string> &_settings) { return new C_node(_settings);};
+		string get_name(){ return settings["type"]; };
+		string get_occupation(){ return "C node"; };
+
 };
 
 class Node_factory {
 	public:
 		template <typename T>
 		T* clone(T* proto) {
+			cout << "cloning.. " << endl;
 			return new T();
 		};
 		Node_factory() {
@@ -44,24 +82,57 @@ class Node_factory {
 			if (type=="B") return new B_node();
 			if (type=="C") return new C_node();
 		};
-		map<string,Node*> type_map;
+		unordered_map<string,Node*> type_map;
 		void add_type(string type,Node *proto){
 			type_map[type]=proto;
 		};
+		
+		Node *create(unordered_map<string,string> &settings) {
+			if (settings.find("type")!=settings.end()) {
+				if (type_map.find(settings["type"])!=type_map.end()) {
+					return type_map[settings["type"]]->clone(settings);
+				}
+			}
+		}
+		Node *create(string type,unordered_map<string,string> &settings) {
+			if (settings.find("type")!=settings.end()) {
+				if (type_map.find(settings["type"])!=type_map.end()) {
+					Node* t=clone(type_map[settings["type"]]);
+					cout << "cloned.. " << endl;
+					t->set(settings);
+					return t;
+					
+			//T* t= new T();
+				}
+			}
+		}
+		//so when you get a pointer from an array of  pointers to base class, thats all you get
+		/*
 		Node *create(string type) {
 			if (type_map.find(type)!=type_map.end()) {
 				return (Node*)clone(type_map[type]);
 			}
 		}
+		Node *create(string type,string desc) {
+			if (type_map.find(type)!=type_map.end()) {
+				return (Node*)clone(type_map[type],desc);
+			}
+		}
+		*/
 };
 
 int main() {
 	Node_factory f=Node_factory();
+	unordered_map<string,string> settings;
 	vector<Node*> nodes;
-	nodes.push_back(f.get_node("A"));
-	nodes.push_back(f.get_node("B"));
-	nodes.push_back(f.get_node("C"));
+	settings["type"]="A";
+	nodes.push_back(f.create("A",settings));
+	settings["type"]="B";
+	nodes.push_back(f.create(settings));
+	settings["type"]="C";
+	//nodes.push_back(f.create(settings));
 	for (auto &i: nodes) {
-		cout << i->get_name() << endl;
+		//cout << ((Node_o*)i)->get_type() << ", " << ((Node_o*)i)->get_occupation()<< endl;
+		cout << ((Node_o*)i)->get_occupation()<< endl;
 	}
 }
\ No newline at end of file
diff --git a/http b/http
index cbf89b2..0c0314f 100755
--- a/http
+++ b/http
@@ -6,7 +6,7 @@ parser.add_argument("method",default="GET",nargs='?')
 parser.add_argument("path",default="/",nargs='?')
 parser.add_argument("body",default="body",nargs='?')
 args=parser.parse_args()
-connection =  httplib.HTTPConnection('54.228.219.55:9000')
+connection =  httplib.HTTPConnection('127.0.0.1:9000')
 connection.request(args.method, args.path, args.body)
 print connection.getresponse().read()
 
diff --git a/rotord/rotor.cpp b/rotord/rotor.cpp
index 559e47c..c0b9fc5 100644
--- a/rotord/rotor.cpp
+++ b/rotord/rotor.cpp
@@ -42,9 +42,9 @@ void Render_context::add_queue(int item) {
 	mutex.unlock();
 }
 
-bool Signal_input::connect(Node* source) {
+bool Signal_input::connect(Signal_node* source) {
 	if (source->output_type=="signal") {
-		connection=source;
+		connection=(Node*)source;
 		return true;
 	}
 	else return false;
diff --git a/rotord/rotor.h b/rotord/rotor.h
index aab0af9..605ae67 100755
--- a/rotord/rotor.h
+++ b/rotord/rotor.h
@@ -81,6 +81,7 @@ namespace Rotor {
 
 	//forward declaration
 	class Node;
+	class Signal_node;
 
 
 	class Render_status{
@@ -111,73 +112,51 @@ namespace Rotor {
 	};
 	class Signal_input: public Input{
 		public:
-			bool connect(Node* source);
+			bool connect(Signal_node* source);
 			Signal_input(const string &_desc): Input(_desc){};
 			
 	};
 	class Node{		
-		public:
-			Node(){};
-			virtual ~Node(){}; 
-			Node(map<string,string> &settings){
-				cerr << "Node:";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr << it->first << "," << it->second << " "; 
-				}
-				cerr << endl;
-				description=settings["description"];type=settings["type"];output_type=settings["output"];ID=settings["ID"];
-			};
+		public:;
+			virtual Node* clone(map<string,string> &_settings)=0;
 			UUID uid;								//every usable node has a UUID
 			int id;
-			vector<Signal_input*> inputs;				//simple node has signal inputs and outputs
+			vector<Signal_input*> inputs;				//simple node can have signal inputs, output depends on node type
 			void create_signal_input(const string &description) {inputs.push_back(new Signal_input(description));};
-			void gather_inputs(const float &time) {
-				for (uint i=0;i<inputs.size();i++){
-					if (inputs[i]->connection) inputs[i]->connection->get_output(time);
-				}
-			}
-			float get_output(const float &time) { //default is to pass through first input, if disconnected returns 0
-				cerr << "getting output for " << type << "," << ID << endl;
-				if (inputs.size()) {
-					if (inputs[0]->connection) return inputs[0]->connection->get_output(time);
-				}
-				return 0.0f;
-			}
 			string description;
 			string type;
 			string output_type;
 			string ID;
-	};
+			string check(map<string,string> &settings,string key){ if (settings.find(key)!=settings.end()) return settings[key]; else return "";};
+			void base_settings(map<string,string> &settings) {
+				description=check(settings,"description");
+				type=check(settings,"type");
+				output_type=check(settings,"output");
+				ID=check(settings,"ID");
+			}
+		};
 	class Image{
 		char* data;
 	};
 	class Signal_node: public Node{
 		public:
-			Signal_node(){};
-			Signal_node(map<string,string> &settings){
-				cerr << "Signal_node:";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr << it->first << "," << it->second << " "; 
+			float get_output(const float &time) { 		//default is to pass through first input, if disconnected returns 0
+				cerr << "getting output for " << type << "," << ID << endl;
+				if (inputs.size()) {
+					if (inputs[0]->connection) return ((Signal_node*)(inputs[0]->connection))->get_output(time);
 				}
-				cerr << endl;
-				description=settings["description"];type=settings["type"];output_type=settings["output"];ID=settings["ID"];
-				};
+				return 0.0f;
+			}
 	};
 	class Image_node: public Node{
 		public:
 			vector<Image_input> image_inputs;		//image node also has image inputs and outputs
-			void gather_inputs(const float &time) {
-				Node::gather_inputs(time);
-				for (uint i=0;i<image_inputs.size();i++){
-					if (image_inputs[i].connection) image_inputs[i].connection->get_output(time);
-				}
-			}
 			Image* get_output(float time){			//sample implementation
-				gather_inputs(time);
+				
 												//do something with the inputs
 
 												//and then
-				return ((Image_node*)image_inputs[0].connection)->image;
+				return ((Image_node*)image_inputs[0].connection)->get_output(time);
 			}
 			void get_preview(float time);
 			Image* image; 						//this can be privately allocated or just passed on as the node see fit
@@ -189,13 +168,9 @@ namespace Rotor {
 		public:
 			Audio_analysis(){};
 			Audio_analysis(map<string,string> &settings) {
-				cerr << "Audio analysis:";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr << it->first << "," << it->second << " "; 
-				}
-				cerr << endl;
-				description=settings["description"];type=settings["type"];output_type=settings["output"];ID=settings["ID"];
-				};
+				base_settings(settings);
+			};
+			Audio_analysis* clone(map<string,string> &_settings) { return new Audio_analysis(_settings);};
 			float get_output(const float &time) {
 				float t=time;
 				return t;
@@ -208,15 +183,13 @@ namespace Rotor {
 		public:
 			Is_new_integer(){};
 			Is_new_integer(map<string,string> &settings) {
-				cerr << "Is new integer:";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr << it->first << "," << it->second << " "; 
-				}
-				cerr << endl;
-				description=settings["description"];type=settings["type"];output_type=settings["output"];ID=settings["ID"];
-				};
+				base_settings(settings);
+			};
+			Is_new_integer* clone(map<string,string> &_settings) { return new Is_new_integer(_settings);};
 			float get_output(const float &time) {
-				if (((int)Node::get_output(time))>((int)Node::get_output(time-.04))) return 1.0f;
+				if (inputs[0]->connection) {
+					if (((int)((Signal_node*)(inputs[0]->connection))->get_output(time))>((int)((Signal_node*)(inputs[0]->connection))->get_output(time-.04))) return 1.0f;
+				}
 				else return 0.0f;
 			}
 	};
@@ -224,41 +197,28 @@ namespace Rotor {
 		public:
 			Signal_output(){};
 			Signal_output(map<string,string> &settings) {
-				cerr << "Signal output:";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr << it->first << "," << it->second << " "; 
-				}
-				cerr << endl;
-				description=settings["description"];type=settings["type"];output_type=settings["output"];ID=settings["ID"];
-				};
-			
+				base_settings(settings);
+			};
+			Signal_output* clone(map<string,string> &_settings) { return new Signal_output(_settings);};
 			bool render(const float duration, const float framerate,string &xml_out);
 	};
 	//-------------------------------------------------------------------
 	class Node_factory{
 		public:
 			Node_factory();
-			template <typename T>
-			T* clone(T* proto,map<string,string> &settings) { 
-				cerr << "Factory settings: ";
-				for (map<string,string>::iterator it=settings.begin();it!=settings.end();++it) {
-					cerr  << it->first << "," << it->second << " "; 
-				}
-				cerr << endl;
-				return new T(settings); 
-				}
 			void add_type(string type,Node* proto){
 				type_map[type]=proto;
 			};
-			Node* create(map<string,string> &settings){
-				if (type_map.find(settings["type"])!=type_map.end()) {
-					cerr << "Factory: creating " << settings["type"] << endl;
-					return clone(type_map[settings["type"]],settings);
+			Node *create(map<string,string> &settings){
+				if (settings.find("type")!=settings.end()) {
+					if (type_map.find(settings["type"])!=type_map.end()) {
+						return type_map[settings["type"]]->clone(settings);
+					}
 				}
 				else return NULL;
 			};
 		private:
-			map<string,Node*> type_map;
+			unordered_map<string,Node*> type_map;
 	};
 	class Graph{
 		public: