blob: 6835d0155985db1e418ef2b30ff4144e7c886edc (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
#include <string>
#include <map>
#include <unordered_map>
namespace Rotor {
class Node;
class Frame_parameters;
class Variable { //base type for variable pointers
public:
virtual void init(std::string s){};
virtual ~Variable(){};
};
template <class T> class Variable_type : public Variable {
public:
Node* connection;
T* get(Frame_parameters frame);
bool connectable;
T value;
};
//type specialisations deal with string conversion
//what happens if we want to link an unlinked attribute at runtime
//should attributes and paramaters just be the same thing
//it would be really nice if there could be arithmetic
//type objects that could act on multiple types
//either we call them attributes and inlets or just vars
//for the author, is it better to have seperate static members?
//for the GUI, yes. but is that another issue?
//does the gui need a hint for the "basic" mode inlets so they stand out?
class Node { //base type for node pointers
};
template <class NT> class Node_type : public Node {
public:
std::unordered_map<std::string,Variable*> vars;
NT* get_output(Frame_parameters frame);
virtual ~Node_type(){
for (auto v:vars){
delete v.second;
}
}
void init(std::map<std::string,std::string> settings){
for (auto s:settings) {
if (vars.find(s.first)){
vars[s.first]->init(s.second);
}
}
}
template <class IT> IT* create_inlet(std::string name){
vars[name]=new Variable_type<IT>();
return &((dynamic_cast<Variable_type<IT>*>(vars[name]))->value);
}
};
class a_node: public Node_type<double> {
a_node(){
delay=create_inlet<int>("delay");
//initialise the pointer to point at the instance variable
//how to delete the vars ???
};
int *delay;
};
}
|
