coffee/ChaiScript
1
0
Fork 0
mirror of https://github.com/ChaiScript/ChaiScript.git synced 2026-02-08 10:46:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add namespace dispatchkit

Browse Source
This commit is contained in:
Jason Turner 2009-06-13 22:42:13 +00:00
parent 416242286a
commit 785263628b
14 changed files with 1485 additions and 1447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
chaiscript/chaiscript_engine.hpp
View File

@ -23,11 +23,11 @@ public:
return engine; return engine;
} }
const Boxed_Value eval(const std::vector<Boxed_Value> &vals) { const dispatchkit::Boxed_Value eval(const std::vector<dispatchkit::Boxed_Value> &vals) {
std::string val; std::string val;
try { try {
val = Cast_Helper<std::string &>()(vals[0]); val = dispatchkit::Cast_Helper<std::string &>()(vals[0]);
} }
catch (std::exception &e) { catch (std::exception &e) {
throw EvalError("Can not evaluate string: " + val, langkit::TokenPtr()); throw EvalError("Can not evaluate string: " + val, langkit::TokenPtr());
@ -191,11 +191,11 @@ public:
Eval_Engine build_eval_system(langkit::Lexer &lexer, langkit::Rule &parser) { Eval_Engine build_eval_system(langkit::Lexer &lexer, langkit::Rule &parser) {
using namespace langkit; using namespace langkit;
Eval_Engine ss; Eval_Engine ss;
Bootstrap::bootstrap(ss); dispatchkit::Bootstrap::bootstrap(ss);
bootstrap_vector<std::vector<Boxed_Value> >(ss, "Vector"); dispatchkit::bootstrap_vector<std::vector<dispatchkit::Boxed_Value> >(ss, "Vector");
ss.register_function(boost::shared_ptr<Proxy_Function>( ss.register_function(boost::shared_ptr<dispatchkit::Proxy_Function>(
new Dynamic_Proxy_Function(boost::bind(&ChaiScript_System<Eval_Engine>::eval, boost::ref(*this), _1), 1)), "eval"); new dispatchkit::Dynamic_Proxy_Function(boost::bind(&ChaiScript_System<Eval_Engine>::eval, boost::ref(*this), _1), 1)), "eval");
evaluate_string("def print(x) { print_string(x.to_string()) } "); evaluate_string("def print(x) { print_string(x.to_string()) } ");
@ -220,10 +220,10 @@ public:
} }
} }
Boxed_Value evaluate_string(const std::string &input, const char *filename = "__EVAL__") { dispatchkit::Boxed_Value evaluate_string(const std::string &input, const char *filename = "__EVAL__") {
using namespace langkit; using namespace langkit;
std::vector<TokenPtr> tokens = lexer.lex(input, filename); std::vector<TokenPtr> tokens = lexer.lex(input, filename);
Boxed_Value value; dispatchkit::Boxed_Value value;
for (unsigned int i = 0; i < tokens.size(); ++i) { for (unsigned int i = 0; i < tokens.size(); ++i) {
if ((tokens[i]->identifier == TokenType::Quoted_String) || (tokens[i]->identifier == TokenType::Single_Quoted_String)) { if ((tokens[i]->identifier == TokenType::Quoted_String) || (tokens[i]->identifier == TokenType::Single_Quoted_String)) {
@ -262,12 +262,12 @@ public:
return value; return value;
} }
Boxed_Value evaluate_file(const char *filename) { dispatchkit::Boxed_Value evaluate_file(const char *filename) {
return evaluate_string(load_file(filename), filename); return evaluate_string(load_file(filename), filename);
} }
}; };
typedef ChaiScript_System<Dispatch_Engine> ChaiScript_Engine; typedef ChaiScript_System<dispatchkit::Dispatch_Engine> ChaiScript_Engine;
#endif /* CHAISCRIPT_ENGINE_HPP_ */ #endif /* CHAISCRIPT_ENGINE_HPP_ */

97
chaiscript/chaiscript_eval.hpp
View File

@ -21,10 +21,10 @@ struct EvalError {
}; };
struct ReturnValue { struct ReturnValue {
Boxed_Value retval; dispatchkit::Boxed_Value retval;
langkit::TokenPtr location; langkit::TokenPtr location;
ReturnValue(const Boxed_Value &return_value, const langkit::TokenPtr where) : retval(return_value), location(where) { } ReturnValue(const dispatchkit::Boxed_Value &return_value, const langkit::TokenPtr where) : retval(return_value), location(where) { }
}; };
struct BreakLoop { struct BreakLoop {
@ -34,21 +34,21 @@ struct BreakLoop {
}; };
template <typename Eval_System> template <typename Eval_System>
const Boxed_Value eval_function (Eval_System &ss, langkit::TokenPtr node, const std::vector<std::string> &param_names, const std::vector<Boxed_Value> &vals) { const dispatchkit::Boxed_Value eval_function (Eval_System &ss, langkit::TokenPtr node, const std::vector<std::string> &param_names, const std::vector<dispatchkit::Boxed_Value> &vals) {
ss.new_scope(); ss.new_scope();
for (unsigned int i = 0; i < param_names.size(); ++i) { for (unsigned int i = 0; i < param_names.size(); ++i) {
ss.add_object(param_names[i], vals[i]); ss.add_object(param_names[i], vals[i]);
} }
Boxed_Value retval = eval_token(ss, node); dispatchkit::Boxed_Value retval = eval_token(ss, node);
ss.pop_scope(); ss.pop_scope();
return retval; return retval;
} }
template <typename Eval_System> template <typename Eval_System>
Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) { dispatchkit::Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
Boxed_Value retval; dispatchkit::Boxed_Value retval;
unsigned int i, j; unsigned int i, j;
switch (node->identifier) { switch (node->identifier) {
@ -60,10 +60,10 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
break; break;
case (TokenType::Identifier) : case (TokenType::Identifier) :
if (node->text == "true") { if (node->text == "true") {
retval = Boxed_Value(true); retval = dispatchkit::Boxed_Value(true);
} }
else if (node->text == "false") { else if (node->text == "false") {
retval = Boxed_Value(false); retval = dispatchkit::Boxed_Value(false);
} }
else { else {
try { try {
@ -75,22 +75,22 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
} }
break; break;
case (TokenType::Real_Number) : case (TokenType::Real_Number) :
retval = Boxed_Value(double(atof(node->text.c_str()))); retval = dispatchkit::Boxed_Value(double(atof(node->text.c_str())));
break; break;
case (TokenType::Integer) : case (TokenType::Integer) :
retval = Boxed_Value(atoi(node->text.c_str())); retval = dispatchkit::Boxed_Value(atoi(node->text.c_str()));
break; break;
case (TokenType::Quoted_String) : case (TokenType::Quoted_String) :
retval = Boxed_Value(node->text); retval = dispatchkit::Boxed_Value(node->text);
break; break;
case (TokenType::Single_Quoted_String) : case (TokenType::Single_Quoted_String) :
retval = Boxed_Value(node->text); retval = dispatchkit::Boxed_Value(node->text);
break; break;
case (TokenType::Equation) : case (TokenType::Equation) :
retval = eval_token(ss, node->children.back()); retval = eval_token(ss, node->children.back());
if (node->children.size() > 1) { if (node->children.size() > 1) {
for (i = node->children.size()-3; ((int)i) >= 0; i -= 2) { for (i = node->children.size()-3; ((int)i) >= 0; i -= 2) {
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << eval_token(ss, node->children[i]); plb << eval_token(ss, node->children[i]);
plb << retval; plb << retval;
try { try {
@ -103,7 +103,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
} }
break; break;
case (TokenType::Variable_Decl): { case (TokenType::Variable_Decl): {
ss.add_object(node->children[0]->text, Boxed_Value()); ss.add_object(node->children[0]->text, dispatchkit::Boxed_Value());
retval = ss.get_object(node->children[0]->text); retval = ss.get_object(node->children[0]->text);
} }
break; break;
@ -115,7 +115,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
if (node->children.size() > 1) { if (node->children.size() > 1) {
for (i = 1; i < node->children.size(); i += 2) { for (i = 1; i < node->children.size(); i += 2) {
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << retval; plb << retval;
plb << eval_token(ss, node->children[i + 1]); plb << eval_token(ss, node->children[i + 1]);
@ -132,7 +132,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
case (TokenType::Array_Call) : { case (TokenType::Array_Call) : {
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
for (i = 1; i < node->children.size(); ++i) { for (i = 1; i < node->children.size(); ++i) {
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << retval; plb << retval;
plb << eval_token(ss, node->children[i]); plb << eval_token(ss, node->children[i]);
try { try {
@ -149,9 +149,9 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
break; break;
case (TokenType::Negate) : { case (TokenType::Negate) : {
retval = eval_token(ss, node->children[1]); retval = eval_token(ss, node->children[1]);
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << retval; plb << retval;
plb << Boxed_Value(-1); plb << dispatchkit::Boxed_Value(-1);
try { try {
retval = dispatch(ss.get_function("*"), plb); retval = dispatch(ss.get_function("*"), plb);
@ -165,17 +165,17 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
bool cond; bool cond;
try { try {
retval = eval_token(ss, node->children[1]); retval = eval_token(ss, node->children[1]);
cond = Cast_Helper<bool &>()(retval); cond = dispatchkit::Cast_Helper<bool &>()(retval);
} }
catch (std::exception) { catch (std::exception) {
throw EvalError("Boolean not('!') condition not boolean", node->children[0]); throw EvalError("Boolean not('!') condition not boolean", node->children[0]);
} }
retval = Boxed_Value(!cond); retval = dispatchkit::Boxed_Value(!cond);
} }
break; break;
case (TokenType::Prefix) : { case (TokenType::Prefix) : {
retval = eval_token(ss, node->children[1]); retval = eval_token(ss, node->children[1]);
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << retval; plb << retval;
try { try {
@ -188,11 +188,11 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
break; break;
case (TokenType::Array_Init) : { case (TokenType::Array_Init) : {
try { try {
retval = dispatch(ss.get_function("Vector"), Param_List_Builder()); retval = dispatch(ss.get_function("Vector"), dispatchkit::Param_List_Builder());
for (i = 0; i < node->children.size(); ++i) { for (i = 0; i < node->children.size(); ++i) {
try { try {
Boxed_Value tmp = eval_token(ss, node->children[i]); dispatchkit::Boxed_Value tmp = eval_token(ss, node->children[i]);
dispatch(ss.get_function("push_back"), Param_List_Builder() << retval << tmp); dispatch(ss.get_function("push_back"), dispatchkit::Param_List_Builder() << retval << tmp);
} }
catch (std::exception inner_e) { catch (std::exception inner_e) {
throw EvalError("Can not find appropriate 'push_back'", node->children[i]); throw EvalError("Can not find appropriate 'push_back'", node->children[i]);
@ -206,13 +206,13 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
break; break;
case (TokenType::Fun_Call) : { case (TokenType::Fun_Call) : {
std::vector<std::pair<std::string, Dispatch_Engine::Function_Map::mapped_type> > fn; std::vector<std::pair<std::string, dispatchkit::Dispatch_Engine::Function_Map::mapped_type> > fn;
Dispatch_Engine::Stack prev_stack = ss.get_stack(); dispatchkit::Dispatch_Engine::Stack prev_stack = ss.get_stack();
Dispatch_Engine::Stack new_stack; dispatchkit::Dispatch_Engine::Stack new_stack;
new_stack.push_back(Dispatch_Engine::Scope()); new_stack.push_back(dispatchkit::Dispatch_Engine::Scope());
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
for (i = 1; i < node->children.size(); ++i) { for (i = 1; i < node->children.size(); ++i) {
plb << eval_token(ss, node->children[i]); plb << eval_token(ss, node->children[i]);
} }
@ -237,16 +237,16 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
} }
break; break;
case (TokenType::Method_Call) : { case (TokenType::Method_Call) : {
std::vector<std::pair<std::string, Dispatch_Engine::Function_Map::mapped_type> > fn; std::vector<std::pair<std::string, dispatchkit::Dispatch_Engine::Function_Map::mapped_type> > fn;
Dispatch_Engine::Stack prev_stack = ss.get_stack(); dispatchkit::Dispatch_Engine::Stack prev_stack = ss.get_stack();
Dispatch_Engine::Stack new_stack; dispatchkit::Dispatch_Engine::Stack new_stack;
new_stack.push_back(Dispatch_Engine::Scope()); new_stack.push_back(dispatchkit::Dispatch_Engine::Scope());
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
if (node->children.size() > 1) { if (node->children.size() > 1) {
for (i = 1; i < node->children.size(); ++i) { for (i = 1; i < node->children.size(); ++i) {
Param_List_Builder plb; dispatchkit::Param_List_Builder plb;
plb << retval; plb << retval;
for (j = 1; j < node->children[i]->children.size(); ++j) { for (j = 1; j < node->children[i]->children.size(); ++j) {
@ -279,7 +279,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
bool cond; bool cond;
try { try {
cond = Cast_Helper<bool &>()(retval); cond = dispatchkit::Cast_Helper<bool &>()(retval);
} }
catch (std::exception &e) { catch (std::exception &e) {
throw EvalError("If condition not boolean", node->children[0]); throw EvalError("If condition not boolean", node->children[0]);
@ -298,7 +298,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
else if (node->children[i]->text == "elseif") { else if (node->children[i]->text == "elseif") {
retval = eval_token(ss, node->children[i+1]); retval = eval_token(ss, node->children[i+1]);
try { try {
cond = Cast_Helper<bool &>()(retval); cond = dispatchkit::Cast_Helper<bool &>()(retval);
} }
catch (std::exception &e) { catch (std::exception &e) {
throw EvalError("Elseif condition not boolean", node->children[i+1]); throw EvalError("Elseif condition not boolean", node->children[i+1]);
@ -317,7 +317,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
bool cond; bool cond;
try { try {
cond = Cast_Helper<bool &>()(retval); cond = dispatchkit::Cast_Helper<bool &>()(retval);
} }
catch (std::exception) { catch (std::exception) {
throw EvalError("While condition not boolean", node->children[0]); throw EvalError("While condition not boolean", node->children[0]);
@ -327,7 +327,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
eval_token(ss, node->children[1]); eval_token(ss, node->children[1]);
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
try { try {
cond = Cast_Helper<bool &>()(retval); cond = dispatchkit::Cast_Helper<bool &>()(retval);
} }
catch (std::exception) { catch (std::exception) {
throw EvalError("While condition not boolean", node->children[0]); throw EvalError("While condition not boolean", node->children[0]);
@ -337,11 +337,11 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
cond = false; cond = false;
} }
} }
retval = Boxed_Value(); retval = dispatchkit::Boxed_Value();
} }
break; break;
case(TokenType::For_Block) : { case(TokenType::For_Block) : {
Boxed_Value condition; dispatchkit::Boxed_Value condition;
bool cond; bool cond;
try { try {
@ -352,7 +352,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
else if (node->children.size() == 3){ else if (node->children.size() == 3){
condition = eval_token(ss, node->children[0]); condition = eval_token(ss, node->children[0]);
} }
cond = Cast_Helper<bool &>()(condition); cond = dispatchkit::Cast_Helper<bool &>()(condition);
} }
catch (std::exception &e) { catch (std::exception &e) {
throw EvalError("For condition not boolean", node); throw EvalError("For condition not boolean", node);
@ -369,7 +369,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
eval_token(ss, node->children[1]); eval_token(ss, node->children[1]);
condition = eval_token(ss, node->children[0]); condition = eval_token(ss, node->children[0]);
} }
cond = Cast_Helper<bool &>()(condition); cond = dispatchkit::Cast_Helper<bool &>()(condition);
} }
catch (std::exception &e) { catch (std::exception &e) {
@ -379,7 +379,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
cond = false; cond = false;
} }
} }
retval = Boxed_Value(); retval = dispatchkit::Boxed_Value();
} }
break; break;
case (TokenType::Function_Def) : { case (TokenType::Function_Def) : {
@ -389,8 +389,8 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
param_names.push_back(node->children[i+1]->text); param_names.push_back(node->children[i+1]->text);
} }
ss.register_function(boost::shared_ptr<Proxy_Function>( ss.register_function(boost::shared_ptr<dispatchkit::Proxy_Function>(
new Dynamic_Proxy_Function(boost::bind(&eval_function<Eval_System>, boost::ref(ss), node->children.back(), param_names, _1))), node->children[0]->text); new dispatchkit::Dynamic_Proxy_Function(boost::bind(&eval_function<Eval_System>, boost::ref(ss), node->children.back(), param_names, _1))), node->children[0]->text);
} }
break; break;
case (TokenType::Lambda_Def) : { case (TokenType::Lambda_Def) : {
@ -400,8 +400,9 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
param_names.push_back(node->children[i]->text); param_names.push_back(node->children[i]->text);
} }
//retval = boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<boost::function<void (const std::string &)> >(&test)); //retval = boost::shared_ptr<dispatchkit::Proxy_Function>(new dispatchkit::Proxy_Function_Impl<boost::function<void (const std::string &)> >(&test));
retval = Boxed_Value(boost::shared_ptr<Proxy_Function>(new Dynamic_Proxy_Function( retval = dispatchkit::Boxed_Value(boost::shared_ptr<dispatchkit::Proxy_Function>(
new dispatchkit::Dynamic_Proxy_Function(
boost::bind(&eval_function<Eval_System>, boost::ref(ss), node->children.back(), param_names, _1)))); boost::bind(&eval_function<Eval_System>, boost::ref(ss), node->children.back(), param_names, _1))));
} }
break; break;
@ -418,7 +419,7 @@ Boxed_Value eval_token(Eval_System &ss, langkit::TokenPtr node) {
retval = eval_token(ss, node->children[0]); retval = eval_token(ss, node->children[0]);
} }
else { else {
retval = Boxed_Value(); retval = dispatchkit::Boxed_Value();
} }
throw ReturnValue(retval, node); throw ReturnValue(retval, node);
} }

2
chaiscript/main.cpp
View File

@ -3,6 +3,8 @@
#include "chaiscript.hpp" #include "chaiscript.hpp"
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
using namespace dispatchkit;
std::string input; std::string input;
ChaiScript_Engine chai; ChaiScript_Engine chai;

842
dispatchkit/bootstrap.hpp
View File

@ -4,456 +4,460 @@
#include "dispatchkit.hpp" #include "dispatchkit.hpp"
#include "bootstrap_pod.hpp" #include "bootstrap_pod.hpp"
template<typename Ret, typename P1, typename P2> namespace dispatchkit
Ret add(P1 p1, P2 p2)
{ {
return p1 + p2; template<typename Ret, typename P1, typename P2>
} Ret add(P1 p1, P2 p2)
template<typename Ret, typename P1, typename P2>
Ret subtract(P1 p1, P2 p2)
{
return p1 - p2;
}
template<typename Ret, typename P1, typename P2>
Ret divide(P1 p1, P2 p2)
{
return p1 / p2;
}
template<typename Ret, typename P1, typename P2>
Ret multiply(P1 p1, P2 p2)
{
return p1 * p2;
}
template<typename P1, typename P2>
bool bool_and(P1 p1, P2 p2)
{
return p1 && p2;
}
template<typename P1, typename P2>
bool bool_or(P1 p1, P2 p2)
{
return p1 || p2;
}
template<typename P1, typename P2>
P1 &assign(P1 &p1, const P2 &p2)
{
return (p1 = p2);
}
template<typename P1>
P1 &assign_pod(P1 &p1, Boxed_POD_Value v)
{
if (v.m_isfloat)
{ {
return (p1 = v.d); return p1 + p2;
} else {
return (p1 = v.i);
} }
}
template<typename P1, typename P2> template<typename Ret, typename P1, typename P2>
bool equals(P1 p1, P2 p2) Ret subtract(P1 p1, P2 p2)
{
return p1 == p2;
}
template<typename P1, typename P2>
bool not_equals(P1 p1, P2 p2)
{
return p1 != p2;
}
template<typename P1, typename P2>
bool less_than(P1 p1, P2 p2)
{
return p1 < p2;
}
template<typename P1, typename P2>
bool greater_than(P1 p1, P2 p2)
{
return p1 > p2;
}
template<typename P1, typename P2>
bool less_than_equals(P1 p1, P2 p2)
{
return p1 <= p2;
}
template<typename P1, typename P2>
bool greater_than_equals(P1 p1, P2 p2)
{
return p1 >= p2;
}
template<typename P1, typename P2>
P1 &timesequal(P1 &p1, const P2 &p2)
{
return (p1 *= p2);
}
template<typename P1>
P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{ {
return (p1 *= r.d); return p1 - p2;
} else {
return (p1 *= r.i);
} }
}
template<typename P1, typename P2> template<typename Ret, typename P1, typename P2>
P1 &dividesequal(P1 &p1, const P2 &p2) Ret divide(P1 p1, P2 p2)
{
return (p1 /= p2);
}
template<typename P1>
P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{ {
return (p1 /= r.d); return p1 / p2;
} else {
return (p1 /= r.i);
} }
}
template<typename P1, typename P2> template<typename Ret, typename P1, typename P2>
P1 &addsequal(P1 &p1, const P2 &p2) Ret multiply(P1 p1, P2 p2)
{
return (p1 += p2);
}
template<typename P1>
P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{ {
return (p1 += r.d); return p1 * p2;
} else {
return (p1 += r.i);
} }
}
template<typename P1, typename P2>
P1 &subtractsequal(P1 &p1, const P2 &p2)
{
return (p1 -= p2);
}
template<typename P1> template<typename P1, typename P2>
P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r) bool bool_and(P1 p1, P2 p2)
{
if (r.m_isfloat)
{ {
return (p1 -= r.d); return p1 && p2;
} else {
return (p1 -= r.i);
} }
}
template<typename P1> template<typename P1, typename P2>
P1 &prefixincrement(P1 &p1) bool bool_or(P1 p1, P2 p2)
{ {
return (++p1); return p1 || p2;
} }
template<typename P1> template<typename P1, typename P2>
P1 &prefixdecrement(P1 &p1) P1 &assign(P1 &p1, const P2 &p2)
{ {
return (--p1); return (p1 = p2);
} }
template<typename P1> template<typename P1>
P1 &prefixnegate(P1 &p1) P1 &assign_pod(P1 &p1, Boxed_POD_Value v)
{ {
return (p1); if (v.m_isfloat)
}
template<typename P1>
P1 &prefixnot(P1 &p1)
{
return (p1);
}
//Add canonical forms of operators
template<typename T>
void add_oper_equals(Dispatch_Engine &s)
{
register_function(s, &equals<const T&, const T&>, "=");
}
template<typename T>
void add_oper_add(Dispatch_Engine &s)
{
register_function(s, &add<T, const T&, const T&>, "+");
}
template<typename T>
void add_oper_add_equals(Dispatch_Engine &s)
{
register_function(s, &addsequal<T, T>, "+=");
}
template<typename T>
void add_oper_subtract(Dispatch_Engine &s)
{
register_function(s, &subtract<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_divide(Dispatch_Engine &s)
{
register_function(s, &divide<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_multiply(Dispatch_Engine &s)
{
register_function(s, &multiply<T, const T&, const T&>, "*");
}
template<typename T>
void add_oper_not_equals(Dispatch_Engine &s)
{
register_function(s, &not_equals<const T&, const T&>, "!=");
}
template<typename T, typename U>
void add_oper_assign_overload(Dispatch_Engine &s)
{
register_function(s, &assign<T,U>, "=");
}
template<typename T>
void add_oper_assign(Dispatch_Engine &s)
{
register_function(s, &assign<T,T>, "=");
}
template<typename T>
void add_oper_assign_pod(Dispatch_Engine &s)
{
register_function(s, &assign_pod<T>, "=");
}
template<typename T>
void add_oper_less_than(Dispatch_Engine &s)
{
register_function(s, &less_than<const T&, const T&>, "<");
}
template<typename T>
void add_oper_greater_than(Dispatch_Engine &s)
{
register_function(s, &greater_than<const T&, const T&>, ">");
}
template<typename T>
void add_oper_less_than_equals(Dispatch_Engine &s)
{
register_function(s, &less_than_equals<const T&, const T&>, "<=");
}
template<typename T>
void add_oper_greater_than_equals(Dispatch_Engine &s)
{
register_function(s, &greater_than_equals<const T&, const T&>, ">=");
}
template<typename T, typename R>
void add_opers_comparison_overload(Dispatch_Engine &s)
{
register_function(s, &equals<const T&, const R&>, "==");
register_function(s, &not_equals<const T&, const R&>, "!=");
register_function(s, &less_than<const T&, const R&>, "<");
register_function(s, &greater_than<const T&, const R&>, ">");
register_function(s, &less_than_equals<const T&, const R&>, "<=");
register_function(s, &greater_than_equals<const T&, const R&>, ">=");
}
template<typename T>
void add_opers_comparison(Dispatch_Engine &s)
{
add_opers_comparison_overload<T, T>(s);
}
template<typename Ret, typename T, typename R>
void add_opers_arithmetic_overload(Dispatch_Engine &s)
{
register_function(s, &add<Ret, T, R>, "+");
register_function(s, &subtract<Ret, T, R>, "-");
register_function(s, &divide<Ret, T, R>, "/");
register_function(s, &multiply<Ret, T, R>, "*");
register_function(s, &timesequal<T, R>, "*=");
register_function(s, &dividesequal<T, R>, "/=");
register_function(s, &subtractsequal<T, R>, "-=");
register_function(s, &addsequal<T, R>, "+=");
register_function(s, &prefixincrement<T>, "++");
register_function(s, &prefixdecrement<T>, "--");
register_function(s, &prefixnegate<T>, "-");
register_function(s, &prefixnot<T>, "!");
}
template<typename T>
void add_opers_arithmetic_modify_pod(Dispatch_Engine &s)
{
register_function(s, &timesequal_pod<T>, "*=");
register_function(s, &dividesequal_pod<T>, "/=");
register_function(s, &subtractsequal_pod<T>, "-=");
register_function(s, &addsequal_pod<T>, "+=");
}
template<typename T>
void add_basic_constructors(Dispatch_Engine &s, const std::string &type)
{
s.register_function(build_constructor<T>(), type);
s.register_function(build_constructor<T, const T &>(), type);
s.register_function(build_constructor<T, const T &>(), "clone");
}
template<typename T, typename U>
void add_constructor_overload(Dispatch_Engine &s, const std::string &type)
{
s.register_function(build_constructor<T, const U &>(), type);
}
template<typename T>
void add_opers_arithmetic(Dispatch_Engine &s)
{
add_opers_arithmetic_overload<T, T, T>(s);
}
class bad_boxed_value_cast : public std::bad_cast
{
public:
bad_boxed_value_cast(const std::string &val) throw()
: m_val(val)
{ {
} return (p1 = v.d);
virtual ~bad_boxed_value_cast() throw()
{
}
virtual const char * what() const throw()
{
return m_val.c_str();
}
private:
std::string m_val;
};
//Built in to_string operator
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
template<> std::string to_string(bool b)
{
if (b)
{
return "true";
} else {
return "false";
}
}
template<typename T>
void bootstrap_pod_type(Dispatch_Engine &s, const std::string &name)
{
s.register_type<T>(name);
add_basic_constructors<T>(s, name);
add_oper_assign<T>(s);
add_oper_assign_pod<T>(s);
add_opers_arithmetic<T>(s);
add_opers_arithmetic_modify_pod<T>(s);
register_function(s, &to_string<T>, "to_string");
}
struct Bootstrap
{
static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
{
if (lhs.is_unknown())
{
return (lhs.assign(rhs));
} else { } else {
throw bad_boxed_value_cast("boxed_value has a set type alread"); return (p1 = v.i);
} }
} }
static void print(const std::string &s)
template<typename P1, typename P2>
bool equals(P1 p1, P2 p2)
{ {
std::cout << s << std::endl; return p1 == p2;
} }
static void bootstrap(Dispatch_Engine &s)
template<typename P1, typename P2>
bool not_equals(P1 p1, P2 p2)
{ {
s.register_type<void>("void"); return p1 != p2;
s.register_type<std::string>("string");
add_basic_constructors<bool>(s, "bool");
add_basic_constructors<std::string>(s, "string");
add_oper_assign<std::string>(s);
register_function(s, &to_string<const std::string &>, "to_string");
register_function(s, &to_string<bool>, "to_string");
register_function(s, &unknown_assign, "=");
bootstrap_pod_type<double>(s, "double");
bootstrap_pod_type<int>(s, "int");
bootstrap_pod_type<size_t>(s, "size_t");
bootstrap_pod_type<char>(s, "char");
bootstrap_pod_type<int64_t>(s, "int64_t");
Pod_Bootstrap::add_opers_comparison(s);
Pod_Bootstrap::add_opers_arithmetic(s);
add_oper_add<std::string>(s);
add_oper_add_equals <std::string>(s);
register_function(s, &print, "print_string");
s.register_function(boost::function<void ()>(boost::bind(&dump_system, boost::ref(s))), "dump_system");
s.register_function(boost::function<void (Boxed_Value)>(boost::bind(&dump_object, _1)), "dump_object");
register_function(s, &bool_and<bool, bool>, "&&");
register_function(s, &bool_or<bool, bool>, "||");
} }
};
template<typename P1, typename P2>
bool less_than(P1 p1, P2 p2)
{
return p1 < p2;
}
template<typename P1, typename P2>
bool greater_than(P1 p1, P2 p2)
{
return p1 > p2;
}
template<typename P1, typename P2>
bool less_than_equals(P1 p1, P2 p2)
{
return p1 <= p2;
}
template<typename P1, typename P2>
bool greater_than_equals(P1 p1, P2 p2)
{
return p1 >= p2;
}
template<typename P1, typename P2>
P1 &timesequal(P1 &p1, const P2 &p2)
{
return (p1 *= p2);
}
template<typename P1>
P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{
return (p1 *= r.d);
} else {
return (p1 *= r.i);
}
}
template<typename P1, typename P2>
P1 &dividesequal(P1 &p1, const P2 &p2)
{
return (p1 /= p2);
}
template<typename P1>
P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{
return (p1 /= r.d);
} else {
return (p1 /= r.i);
}
}
template<typename P1, typename P2>
P1 &addsequal(P1 &p1, const P2 &p2)
{
return (p1 += p2);
}
template<typename P1>
P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{
return (p1 += r.d);
} else {
return (p1 += r.i);
}
}
template<typename P1, typename P2>
P1 &subtractsequal(P1 &p1, const P2 &p2)
{
return (p1 -= p2);
}
template<typename P1>
P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r)
{
if (r.m_isfloat)
{
return (p1 -= r.d);
} else {
return (p1 -= r.i);
}
}
template<typename P1>
P1 &prefixincrement(P1 &p1)
{
return (++p1);
}
template<typename P1>
P1 &prefixdecrement(P1 &p1)
{
return (--p1);
}
template<typename P1>
P1 &prefixnegate(P1 &p1)
{
return (p1);
}
template<typename P1>
P1 &prefixnot(P1 &p1)
{
return (p1);
}
//Add canonical forms of operators
template<typename T>
void add_oper_equals(Dispatch_Engine &s)
{
register_function(s, &equals<const T&, const T&>, "=");
}
template<typename T>
void add_oper_add(Dispatch_Engine &s)
{
register_function(s, &add<T, const T&, const T&>, "+");
}
template<typename T>
void add_oper_add_equals(Dispatch_Engine &s)
{
register_function(s, &addsequal<T, T>, "+=");
}
template<typename T>
void add_oper_subtract(Dispatch_Engine &s)
{
register_function(s, &subtract<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_divide(Dispatch_Engine &s)
{
register_function(s, &divide<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_multiply(Dispatch_Engine &s)
{
register_function(s, &multiply<T, const T&, const T&>, "*");
}
template<typename T>
void add_oper_not_equals(Dispatch_Engine &s)
{
register_function(s, &not_equals<const T&, const T&>, "!=");
}
template<typename T, typename U>
void add_oper_assign_overload(Dispatch_Engine &s)
{
register_function(s, &assign<T,U>, "=");
}
template<typename T>
void add_oper_assign(Dispatch_Engine &s)
{
register_function(s, &assign<T,T>, "=");
}
template<typename T>
void add_oper_assign_pod(Dispatch_Engine &s)
{
register_function(s, &assign_pod<T>, "=");
}
template<typename T>
void add_oper_less_than(Dispatch_Engine &s)
{
register_function(s, &less_than<const T&, const T&>, "<");
}
template<typename T>
void add_oper_greater_than(Dispatch_Engine &s)
{
register_function(s, &greater_than<const T&, const T&>, ">");
}
template<typename T>
void add_oper_less_than_equals(Dispatch_Engine &s)
{
register_function(s, &less_than_equals<const T&, const T&>, "<=");
}
template<typename T>
void add_oper_greater_than_equals(Dispatch_Engine &s)
{
register_function(s, &greater_than_equals<const T&, const T&>, ">=");
}
template<typename T, typename R>
void add_opers_comparison_overload(Dispatch_Engine &s)
{
register_function(s, &equals<const T&, const R&>, "==");
register_function(s, &not_equals<const T&, const R&>, "!=");
register_function(s, &less_than<const T&, const R&>, "<");
register_function(s, &greater_than<const T&, const R&>, ">");
register_function(s, &less_than_equals<const T&, const R&>, "<=");
register_function(s, &greater_than_equals<const T&, const R&>, ">=");
}
template<typename T>
void add_opers_comparison(Dispatch_Engine &s)
{
add_opers_comparison_overload<T, T>(s);
}
template<typename Ret, typename T, typename R>
void add_opers_arithmetic_overload(Dispatch_Engine &s)
{
register_function(s, &add<Ret, T, R>, "+");
register_function(s, &subtract<Ret, T, R>, "-");
register_function(s, &divide<Ret, T, R>, "/");
register_function(s, &multiply<Ret, T, R>, "*");
register_function(s, &timesequal<T, R>, "*=");
register_function(s, &dividesequal<T, R>, "/=");
register_function(s, &subtractsequal<T, R>, "-=");
register_function(s, &addsequal<T, R>, "+=");
register_function(s, &prefixincrement<T>, "++");
register_function(s, &prefixdecrement<T>, "--");
register_function(s, &prefixnegate<T>, "-");
register_function(s, &prefixnot<T>, "!");
}
template<typename T>
void add_opers_arithmetic_modify_pod(Dispatch_Engine &s)
{
register_function(s, &timesequal_pod<T>, "*=");
register_function(s, &dividesequal_pod<T>, "/=");
register_function(s, &subtractsequal_pod<T>, "-=");
register_function(s, &addsequal_pod<T>, "+=");
}
template<typename T>
void add_basic_constructors(Dispatch_Engine &s, const std::string &type)
{
s.register_function(build_constructor<T>(), type);
s.register_function(build_constructor<T, const T &>(), type);
s.register_function(build_constructor<T, const T &>(), "clone");
}
template<typename T, typename U>
void add_constructor_overload(Dispatch_Engine &s, const std::string &type)
{
s.register_function(build_constructor<T, const U &>(), type);
}
template<typename T>
void add_opers_arithmetic(Dispatch_Engine &s)
{
add_opers_arithmetic_overload<T, T, T>(s);
}
class bad_boxed_value_cast : public std::bad_cast
{
public:
bad_boxed_value_cast(const std::string &val) throw()
: m_val(val)
{
}
virtual ~bad_boxed_value_cast() throw()
{
}
virtual const char * what() const throw()
{
return m_val.c_str();
}
private:
std::string m_val;
};
//Built in to_string operator
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
template<> std::string to_string(bool b)
{
if (b)
{
return "true";
} else {
return "false";
}
}
template<typename T>
void bootstrap_pod_type(Dispatch_Engine &s, const std::string &name)
{
s.register_type<T>(name);
add_basic_constructors<T>(s, name);
add_oper_assign<T>(s);
add_oper_assign_pod<T>(s);
add_opers_arithmetic<T>(s);
add_opers_arithmetic_modify_pod<T>(s);
register_function(s, &to_string<T>, "to_string");
}
struct Bootstrap
{
static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
{
if (lhs.is_unknown())
{
return (lhs.assign(rhs));
} else {
throw bad_boxed_value_cast("boxed_value has a set type alread");
}
}
static void print(const std::string &s)
{
std::cout << s << std::endl;
}
static void bootstrap(Dispatch_Engine &s)
{
s.register_type<void>("void");
s.register_type<std::string>("string");
add_basic_constructors<bool>(s, "bool");
add_basic_constructors<std::string>(s, "string");
add_oper_assign<std::string>(s);
register_function(s, &to_string<const std::string &>, "to_string");
register_function(s, &to_string<bool>, "to_string");
register_function(s, &unknown_assign, "=");
bootstrap_pod_type<double>(s, "double");
bootstrap_pod_type<int>(s, "int");
bootstrap_pod_type<size_t>(s, "size_t");
bootstrap_pod_type<char>(s, "char");
bootstrap_pod_type<int64_t>(s, "int64_t");
Pod_Bootstrap::add_opers_comparison(s);
Pod_Bootstrap::add_opers_arithmetic(s);
add_oper_add<std::string>(s);
add_oper_add_equals <std::string>(s);
register_function(s, &print, "print_string");
s.register_function(boost::function<void ()>(boost::bind(&dump_system, boost::ref(s))), "dump_system");
s.register_function(boost::function<void (Boxed_Value)>(boost::bind(&dump_object, _1)), "dump_object");
register_function(s, &bool_and<bool, bool>, "&&");
register_function(s, &bool_or<bool, bool>, "||");
}
};
}
#endif #endif

118
dispatchkit/bootstrap_pod.hpp
View File

@ -4,77 +4,79 @@
#include "register_function.hpp" #include "register_function.hpp"
namespace dispatchkit
struct Pod_Bootstrap
{ {
static Boxed_Value add(Boxed_POD_Value l, Boxed_POD_Value r) struct Pod_Bootstrap
{ {
return l + r; static Boxed_Value add(Boxed_POD_Value l, Boxed_POD_Value r)
} {
return l + r;
}
static Boxed_Value subtract(Boxed_POD_Value l, Boxed_POD_Value r) static Boxed_Value subtract(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l - r; return l - r;
} }
static Boxed_Value divide(Boxed_POD_Value l, Boxed_POD_Value r) static Boxed_Value divide(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l / r; return l / r;
} }
static Boxed_Value multiply(Boxed_POD_Value l, Boxed_POD_Value r) static Boxed_Value multiply(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l * r; return l * r;
} }
static bool equals(Boxed_POD_Value l, Boxed_POD_Value r) static bool equals(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l == r; return l == r;
} }
static bool not_equals(Boxed_POD_Value l, Boxed_POD_Value r) static bool not_equals(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l != r; return l != r;
} }
static bool less_than(Boxed_POD_Value l, Boxed_POD_Value r) static bool less_than(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l < r; return l < r;
} }
static bool greater_than(Boxed_POD_Value l, Boxed_POD_Value r) static bool greater_than(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l > r; return l > r;
} }
static bool less_than_equals(Boxed_POD_Value l, Boxed_POD_Value r) static bool less_than_equals(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l <= r; return l <= r;
} }
static bool greater_than_equals(Boxed_POD_Value l, Boxed_POD_Value r) static bool greater_than_equals(Boxed_POD_Value l, Boxed_POD_Value r)
{ {
return l >= r; return l >= r;
} }
static void add_opers_comparison(Dispatch_Engine &s) static void add_opers_comparison(Dispatch_Engine &s)
{ {
register_function(s, &equals, "=="); register_function(s, &equals, "==");
register_function(s, &not_equals, "!="); register_function(s, &not_equals, "!=");
register_function(s, &less_than, "<"); register_function(s, &less_than, "<");
register_function(s, &greater_than, ">"); register_function(s, &greater_than, ">");
register_function(s, &less_than_equals, "<="); register_function(s, &less_than_equals, "<=");
register_function(s, &greater_than_equals, ">="); register_function(s, &greater_than_equals, ">=");
} }
static void add_opers_arithmetic(Dispatch_Engine &s) static void add_opers_arithmetic(Dispatch_Engine &s)
{ {
register_function(s, &add, "+"); register_function(s, &add, "+");
register_function(s, &subtract, "-"); register_function(s, &subtract, "-");
register_function(s, &divide, "/"); register_function(s, &divide, "/");
register_function(s, &multiply, "*"); register_function(s, &multiply, "*");
} }
}; };
}
#endif #endif

125
dispatchkit/bootstrap_stl.hpp
View File

@ -3,82 +3,85 @@
#include "dispatchkit.hpp" #include "dispatchkit.hpp"
template<typename ContainerType> namespace dispatchkit
void bootstrap_reversible_container(Dispatch_Engine &system, const std::string &type)
{ {
} template<typename ContainerType>
void bootstrap_reversible_container(Dispatch_Engine &system, const std::string &type)
{
}
template<typename ContainerType> template<typename ContainerType>
void bootstrap_random_access_container(Dispatch_Engine &system, const std::string &type) void bootstrap_random_access_container(Dispatch_Engine &system, const std::string &type)
{ {
bootstrap_reversible_container<ContainerType>(system, type); bootstrap_reversible_container<ContainerType>(system, type);
typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t); typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
//In the interest of runtime safety for the system, we prefer the at() method for [] access, //In the interest of runtime safety for the system, we prefer the at() method for [] access,
//to throw an exception in an out of bounds condition. //to throw an exception in an out of bounds condition.
system.register_function( system.register_function(
boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::at)), "[]"); boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::at)), "[]");
system.register_function( system.register_function(
boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[])), "at"); boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[])), "at");
} }
template<typename Assignable> template<typename Assignable>
void bootstrap_assignable(Dispatch_Engine &system, const std::string &type) void bootstrap_assignable(Dispatch_Engine &system, const std::string &type)
{ {
system.register_function( system.register_function(
boost::function<Assignable &(Assignable*, const Assignable&)>(&Assignable::operator=), "="); boost::function<Assignable &(Assignable*, const Assignable&)>(&Assignable::operator=), "=");
} }
template<typename ContainerType> template<typename ContainerType>
void bootstrap_container(Dispatch_Engine &system, const std::string &type) void bootstrap_container(Dispatch_Engine &system, const std::string &type)
{ {
bootstrap_assignable<ContainerType>(system, type); bootstrap_assignable<ContainerType>(system, type);
system.register_function( system.register_function(
boost::function<size_t (ContainerType *)>(&ContainerType::size), "size"); boost::function<size_t (ContainerType *)>(&ContainerType::size), "size");
system.register_function( system.register_function(
boost::function<size_t (ContainerType *)>(&ContainerType::size), "maxsize"); boost::function<size_t (ContainerType *)>(&ContainerType::size), "maxsize");
} }
template<typename ContainerType> template<typename ContainerType>
void bootstrap_forward_container(Dispatch_Engine &system, const std::string &type) void bootstrap_forward_container(Dispatch_Engine &system, const std::string &type)
{ {
bootstrap_container<ContainerType>(system, type); bootstrap_container<ContainerType>(system, type);
} }
template<typename Type> template<typename Type>
void bootstrap_default_constructible(Dispatch_Engine &system, const std::string &type) void bootstrap_default_constructible(Dispatch_Engine &system, const std::string &type)
{ {
system.register_function(build_constructor<Type>(), type); system.register_function(build_constructor<Type>(), type);
} }
template<typename SequenceType> template<typename SequenceType>
void bootstrap_sequence(Dispatch_Engine &system, const std::string &type) void bootstrap_sequence(Dispatch_Engine &system, const std::string &type)
{ {
bootstrap_forward_container<SequenceType>(system, type); bootstrap_forward_container<SequenceType>(system, type);
bootstrap_default_constructible<SequenceType>(system, type); bootstrap_default_constructible<SequenceType>(system, type);
} }
template<typename SequenceType> template<typename SequenceType>
void bootstrap_back_insertion_sequence(Dispatch_Engine &system, const std::string &type) void bootstrap_back_insertion_sequence(Dispatch_Engine &system, const std::string &type)
{ {
bootstrap_sequence<SequenceType>(system, type); bootstrap_sequence<SequenceType>(system, type);
typedef typename SequenceType::reference (SequenceType::*backptr)(); typedef typename SequenceType::reference (SequenceType::*backptr)();
system.register_function(boost::function<typename SequenceType::reference (SequenceType *)>(backptr(&SequenceType::back)), "back"); system.register_function(boost::function<typename SequenceType::reference (SequenceType *)>(backptr(&SequenceType::back)), "back");
system.register_function(boost::function<void (SequenceType *,typename SequenceType::value_type)>(&SequenceType::push_back), "push_back"); system.register_function(boost::function<void (SequenceType *,typename SequenceType::value_type)>(&SequenceType::push_back), "push_back");
system.register_function(boost::function<void (SequenceType *)>(&SequenceType::pop_back), "pop_back"); system.register_function(boost::function<void (SequenceType *)>(&SequenceType::pop_back), "pop_back");
} }
template<typename VectorType> template<typename VectorType>
void bootstrap_vector(Dispatch_Engine &system, const std::string &type) void bootstrap_vector(Dispatch_Engine &system, const std::string &type)
{ {
system.register_type<VectorType>(type); system.register_type<VectorType>(type);
bootstrap_random_access_container<VectorType>(system, type); bootstrap_random_access_container<VectorType>(system, type);
bootstrap_back_insertion_sequence<VectorType>(system, type); bootstrap_back_insertion_sequence<VectorType>(system, type);
}
} }
#endif #endif

856
dispatchkit/boxed_value.hpp
View File

@ -8,28 +8,30 @@
#include <boost/ref.hpp> #include <boost/ref.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
class Boxed_Value namespace dispatchkit
{ {
public: class Boxed_Value
struct Void_Type {
{ public:
}; struct Void_Type
private:
struct Data
{
struct Shared_Ptr_Proxy
{ {
virtual ~Shared_Ptr_Proxy()
{
}
virtual bool unique(boost::any *) = 0;
virtual long use_count(boost::any *) = 0;
}; };
template<typename T> private:
struct Shared_Ptr_Proxy_Impl : Shared_Ptr_Proxy struct Data
{
struct Shared_Ptr_Proxy
{
virtual ~Shared_Ptr_Proxy()
{
}
virtual bool unique(boost::any *) = 0;
virtual long use_count(boost::any *) = 0;
};
template<typename T>
struct Shared_Ptr_Proxy_Impl : Shared_Ptr_Proxy
{ {
virtual ~Shared_Ptr_Proxy_Impl() virtual ~Shared_Ptr_Proxy_Impl()
{ {
@ -46,454 +48,452 @@ class Boxed_Value
boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a); boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(a);
return ptr->use_count(); return ptr->use_count();
} }
}; };
Data(const Type_Info &ti, Data(const Type_Info &ti,
const boost::any &to, const boost::any &to,
bool tr, bool tr,
const boost::shared_ptr<Shared_Ptr_Proxy> &t_proxy = boost::shared_ptr<Shared_Ptr_Proxy>()) const boost::shared_ptr<Shared_Ptr_Proxy> &t_proxy = boost::shared_ptr<Shared_Ptr_Proxy>())
: m_type_info(ti), m_obj(to), : m_type_info(ti), m_obj(to),
m_is_ref(tr), m_ptr_proxy(t_proxy) m_is_ref(tr), m_ptr_proxy(t_proxy)
{
}
Data &operator=(const Data &rhs)
{
m_type_info = rhs.m_type_info;
m_obj = rhs.m_obj;
m_is_ref = rhs.m_is_ref;
m_ptr_proxy = rhs.m_ptr_proxy;
return *this;
}
static bool get_false()
{
return false;
}
Type_Info m_type_info;
boost::any m_obj;
bool m_is_ref;
boost::shared_ptr<Shared_Ptr_Proxy> m_ptr_proxy;
};
struct Object_Cache
{
boost::shared_ptr<Data> get(Boxed_Value::Void_Type)
{
return boost::shared_ptr<Data> (new Data(
Get_Type_Info<void>::get(),
boost::any(),
false)
);
}
template<typename T>
boost::shared_ptr<Data> get(boost::shared_ptr<T> obj)
{
boost::shared_ptr<Data> data(new Data(
Get_Type_Info<T>::get(),
boost::any(obj),
false,
boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
);
std::map<void *, Data >::iterator itr
= m_ptrs.find(obj.get());
if (itr != m_ptrs.end())
{
(*data) = (itr->second);
} else {
m_ptrs.insert(std::make_pair(obj.get(), *data));
}
return data;
}
template<typename T>
boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
{
boost::shared_ptr<Data> data(new Data(
Get_Type_Info<T>::get(),
boost::any(obj),
true)
);
std::map<void *, Data >::iterator itr
= m_ptrs.find(obj.get_pointer());
if (itr != m_ptrs.end())
{
std::cout << "Reference wrapper ptr found, using it" << std::endl;
(*data) = (itr->second);
}
return data;
}
template<typename T>
boost::shared_ptr<Data> get(const T& t)
{
boost::shared_ptr<Data> data(new Data(
Get_Type_Info<T>::get(),
boost::any(boost::shared_ptr<T>(new T(t))),
false,
boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
);
boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(&data->m_obj);
m_ptrs.insert(std::make_pair(ptr->get(), *data));
return data;
}
boost::shared_ptr<Data> get()
{
return boost::shared_ptr<Data> (new Data(
Type_Info(),
boost::any(),
false)
);
}
void cull()
{
std::map<void *, Data >::iterator itr = m_ptrs.begin();
while (itr != m_ptrs.end())
{
if (itr->second.m_ptr_proxy->unique(&itr->second.m_obj) == 1)
{
std::map<void *, Data >::iterator todel = itr;
// std::cout << "Releasing unique ptr " << std::endl;
++itr;
m_ptrs.erase(todel);
} else {
++itr;
}
}
// std::cout << "References held: " << m_ptrs.size() << std::endl;
}
std::map<void *, Data > m_ptrs;
};
public:
template<typename T>
explicit Boxed_Value(T t)
: m_data(get_object_cache().get(t))
{
}
Boxed_Value(const Boxed_Value &t_so)
: m_data(t_so.m_data)
{ {
} }
Data &operator=(const Data &rhs) Boxed_Value()
: m_data(get_object_cache().get())
{ {
m_type_info = rhs.m_type_info; }
m_obj = rhs.m_obj;
m_is_ref = rhs.m_is_ref;
m_ptr_proxy = rhs.m_ptr_proxy;
~Boxed_Value()
{
get_object_cache().cull();
}
Object_Cache &get_object_cache()
{
static Object_Cache oc;
return oc;
}
Boxed_Value assign(const Boxed_Value &rhs)
{
(*m_data) = (*rhs.m_data);
return *this; return *this;
} }
static bool get_false() Boxed_Value &operator=(const Boxed_Value &rhs)
{ {
return false; m_data = rhs.m_data;
return *this;
} }
Type_Info m_type_info; const Type_Info &get_type_info() const
boost::any m_obj; {
bool m_is_ref; return m_data->m_type_info;
boost::shared_ptr<Shared_Ptr_Proxy> m_ptr_proxy; }
bool is_unknown() const
{
return m_data->m_type_info.m_is_unknown;
}
boost::any get() const
{
return m_data->m_obj;
}
bool is_ref() const
{
return m_data->m_is_ref;
}
private:
boost::shared_ptr<Data> m_data;
};
//cast_help specializations
template<typename Result>
struct Cast_Helper
{
typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
} else {
return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
}
}
}; };
struct Object_Cache template<typename Result>
struct Cast_Helper<const Result &>
{ {
boost::shared_ptr<Data> get(Boxed_Value::Void_Type) typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
{ {
return boost::shared_ptr<Data> (new Data( if (ob.is_ref())
Get_Type_Info<void>::get(),
boost::any(),
false)
);
}
template<typename T>
boost::shared_ptr<Data> get(boost::shared_ptr<T> obj)
{ {
boost::shared_ptr<Data> data(new Data( return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
Get_Type_Info<T>::get(), } else {
boost::any(obj), return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
false,
boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
);
std::map<void *, Data >::iterator itr
= m_ptrs.find(obj.get());
if (itr != m_ptrs.end())
{
(*data) = (itr->second);
} else {
m_ptrs.insert(std::make_pair(obj.get(), *data));
}
return data;
} }
template<typename T>
boost::shared_ptr<Data> get(boost::reference_wrapper<T> obj)
{
boost::shared_ptr<Data> data(new Data(
Get_Type_Info<T>::get(),
boost::any(obj),
true)
);
std::map<void *, Data >::iterator itr
= m_ptrs.find(obj.get_pointer());
if (itr != m_ptrs.end())
{
std::cout << "Reference wrapper ptr found, using it" << std::endl;
(*data) = (itr->second);
}
return data;
} }
template<typename T>
boost::shared_ptr<Data> get(const T& t)
{
boost::shared_ptr<Data> data(new Data(
Get_Type_Info<T>::get(),
boost::any(boost::shared_ptr<T>(new T(t))),
false,
boost::shared_ptr<Data::Shared_Ptr_Proxy>(new Data::Shared_Ptr_Proxy_Impl<T>()))
);
boost::shared_ptr<T> *ptr = boost::any_cast<boost::shared_ptr<T> >(&data->m_obj);
m_ptrs.insert(std::make_pair(ptr->get(), *data));
return data;
}
boost::shared_ptr<Data> get()
{
return boost::shared_ptr<Data> (new Data(
Type_Info(),
boost::any(),
false)
);
}
void cull()
{
std::map<void *, Data >::iterator itr = m_ptrs.begin();
while (itr != m_ptrs.end())
{
if (itr->second.m_ptr_proxy->unique(&itr->second.m_obj) == 1)
{
std::map<void *, Data >::iterator todel = itr;
// std::cout << "Releasing unique ptr " << std::endl;
++itr;
m_ptrs.erase(todel);
} else {
++itr;
}
}
// std::cout << "References held: " << m_ptrs.size() << std::endl;
}
std::map<void *, Data > m_ptrs;
}; };
public: template<typename Result>
template<typename T> struct Cast_Helper<const Result *>
explicit Boxed_Value(T t) {
: m_data(get_object_cache().get(t)) const Result *operator()(Boxed_Value ob)
{ {
if (ob.is_ref())
{
return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
} else {
return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
}
}
};
template<typename Result>
struct Cast_Helper<Result *>
{
Result *operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
} else {
return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
}
}
};
template<typename Result>
struct Cast_Helper<Result &>
{
typename boost::reference_wrapper<Result> operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
} else {
return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
}
}
};
template<typename Result>
struct Cast_Helper<typename boost::shared_ptr<Result> >
{
typename boost::shared_ptr<Result> operator()(Boxed_Value ob)
{
return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
}
};
template<>
struct Cast_Helper<Boxed_Value>
{
Boxed_Value operator()(Boxed_Value ob)
{
return ob;
}
};
struct Boxed_POD_Value
{
Boxed_POD_Value(const Boxed_Value &v)
: d(0), i(0), m_isfloat(false)
{
const int inp_ = int(v.get_type_info().m_type_info);
const int char_ = int(&typeid(char));
const int bool_ = int(&typeid(bool));
const int double_ = int(&typeid(double));
const int float_ = int(&typeid(float));
const int long_ = int(&typeid(long));
const int unsigned_long_ = int(&typeid(unsigned long));
const int int_ = int(&typeid(int));
const int unsigned_int_ = int(&typeid(unsigned int));
const int uint8_t_ = int(&typeid(uint8_t));
const int uint16_t_ = int(&typeid(uint16_t));
const int uint32_t_ = int(&typeid(uint32_t));
// const int uint64_t_ = int(&typeid(uint64_t));
const int int8_t_ = int(&typeid(int8_t));
const int int16_t_ = int(&typeid(int16_t));
const int int32_t_ = int(&typeid(int32_t));
const int int64_t_ = int(&typeid(int64_t));
if (inp_ == double_)
{
d = Cast_Helper<double>()(v);
m_isfloat = true;
} else if (inp_ == float_) {
d = Cast_Helper<float>()(v);
m_isfloat = true;
} else if (inp_ == bool_ ) {
i = Cast_Helper<bool>()(v);
} else if (inp_ == char_) {
i = Cast_Helper<char>()(v);
} else if (inp_ == int_) {
i = Cast_Helper<int>()(v);
} else if (inp_ == unsigned_int_) {
i = Cast_Helper<unsigned int>()(v);
} else if (inp_ == long_) {
i = Cast_Helper<long>()(v);
} else if (inp_ == unsigned_long_) {
i = Cast_Helper<unsigned long>()(v);
} else if (inp_ == int8_t_) {
i = Cast_Helper<int8_t>()(v);
} else if (inp_ == int16_t_) {
i = Cast_Helper<int16_t>()(v);
} else if (inp_ == int32_t_) {
i = Cast_Helper<int32_t>()(v);
} else if (inp_ == int64_t_) {
i = Cast_Helper<int64_t>()(v);
} else if (inp_ == uint8_t_) {
i = Cast_Helper<uint8_t>()(v);
} else if (inp_ == uint16_t_) {
i = Cast_Helper<uint16_t>()(v);
} else if (inp_ == uint32_t_) {
i = Cast_Helper<uint32_t>()(v);
} else {
throw boost::bad_any_cast();
}
}
bool operator==(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) == ((r.m_isfloat)?r.d:r.i);
}
bool operator<(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) < ((r.m_isfloat)?r.d:r.i);
}
bool operator>(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) > ((r.m_isfloat)?r.d:r.i);
}
bool operator>=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) >= ((r.m_isfloat)?r.d:r.i);
}
bool operator<=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) <= ((r.m_isfloat)?r.d:r.i);
}
bool operator!=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) != ((r.m_isfloat)?r.d:r.i);
}
Boxed_Value operator+(const Boxed_POD_Value &r) const
{
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i + r.i);
} }
Boxed_Value(const Boxed_Value &t_so) return Boxed_Value(((m_isfloat)?d:i) + ((r.m_isfloat)?r.d:r.i));
: m_data(t_so.m_data)
{
} }
Boxed_Value() Boxed_Value operator*(const Boxed_POD_Value &r) const
: m_data(get_object_cache().get())
{ {
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i * r.i);
}
return Boxed_Value(((m_isfloat)?d:i) * ((r.m_isfloat)?r.d:r.i));
} }
~Boxed_Value() Boxed_Value operator/(const Boxed_POD_Value &r) const
{ {
get_object_cache().cull(); if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i / r.i);
}
return Boxed_Value(((m_isfloat)?d:i) / ((r.m_isfloat)?r.d:r.i));
} }
Boxed_Value operator-(const Boxed_POD_Value &r) const
Object_Cache &get_object_cache()
{ {
static Object_Cache oc; if (!m_isfloat && !r.m_isfloat)
return oc; {
return Boxed_Value(i - r.i);
}
return Boxed_Value(((m_isfloat)?d:i) - ((r.m_isfloat)?r.d:r.i));
} }
double d;
int64_t i;
Boxed_Value assign(const Boxed_Value &rhs) bool m_isfloat;
};
template<>
struct Cast_Helper<Boxed_POD_Value>
{ {
(*m_data) = (*rhs.m_data); Boxed_POD_Value operator()(Boxed_Value ob)
return *this; {
} return Boxed_POD_Value(ob);
}
Boxed_Value &operator=(const Boxed_Value &rhs) };
{ }
m_data = rhs.m_data;
return *this;
}
const Type_Info &get_type_info() const
{
return m_data->m_type_info;
}
bool is_unknown() const
{
return m_data->m_type_info.m_is_unknown;
}
boost::any get() const
{
return m_data->m_obj;
}
bool is_ref() const
{
return m_data->m_is_ref;
}
private:
boost::shared_ptr<Data> m_data;
};
//cast_help specializations
template<typename Result>
struct Cast_Helper
{
typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
} else {
return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
}
}
};
template<typename Result>
struct Cast_Helper<const Result &>
{
typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return boost::cref((boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get());
} else {
return boost::cref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
}
}
};
template<typename Result>
struct Cast_Helper<const Result *>
{
const Result *operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
} else {
return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
}
}
};
template<typename Result>
struct Cast_Helper<Result *>
{
Result *operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return (boost::any_cast<boost::reference_wrapper<Result> >(ob.get())).get_pointer();
} else {
return (boost::any_cast<boost::shared_ptr<Result> >(ob.get())).get();
}
}
};
template<typename Result>
struct Cast_Helper<Result &>
{
typename boost::reference_wrapper<Result> operator()(Boxed_Value ob)
{
if (ob.is_ref())
{
return boost::any_cast<boost::reference_wrapper<Result> >(ob.get());
} else {
return boost::ref(*(boost::any_cast<boost::shared_ptr<Result> >(ob.get())));
}
}
};
template<typename Result>
struct Cast_Helper<typename boost::shared_ptr<Result> >
{
typename boost::shared_ptr<Result> operator()(Boxed_Value ob)
{
return boost::any_cast<boost::shared_ptr<Result> >(ob.get());
}
};
template<>
struct Cast_Helper<Boxed_Value>
{
Boxed_Value operator()(Boxed_Value ob)
{
return ob;
}
};
struct Boxed_POD_Value
{
Boxed_POD_Value(const Boxed_Value &v)
: d(0), i(0), m_isfloat(false)
{
const int inp_ = int(v.get_type_info().m_type_info);
const int char_ = int(&typeid(char));
const int bool_ = int(&typeid(bool));
const int double_ = int(&typeid(double));
const int float_ = int(&typeid(float));
const int long_ = int(&typeid(long));
const int unsigned_long_ = int(&typeid(unsigned long));
const int int_ = int(&typeid(int));
const int unsigned_int_ = int(&typeid(unsigned int));
const int uint8_t_ = int(&typeid(uint8_t));
const int uint16_t_ = int(&typeid(uint16_t));
const int uint32_t_ = int(&typeid(uint32_t));
// const int uint64_t_ = int(&typeid(uint64_t));
const int int8_t_ = int(&typeid(int8_t));
const int int16_t_ = int(&typeid(int16_t));
const int int32_t_ = int(&typeid(int32_t));
const int int64_t_ = int(&typeid(int64_t));
if (inp_ == double_)
{
d = Cast_Helper<double>()(v);
m_isfloat = true;
} else if (inp_ == float_) {
d = Cast_Helper<float>()(v);
m_isfloat = true;
} else if (inp_ == bool_ ) {
i = Cast_Helper<bool>()(v);
} else if (inp_ == char_) {
i = Cast_Helper<char>()(v);
} else if (inp_ == int_) {
i = Cast_Helper<int>()(v);
} else if (inp_ == unsigned_int_) {
i = Cast_Helper<unsigned int>()(v);
} else if (inp_ == long_) {
i = Cast_Helper<long>()(v);
} else if (inp_ == unsigned_long_) {
i = Cast_Helper<unsigned long>()(v);
} else if (inp_ == int8_t_) {
i = Cast_Helper<int8_t>()(v);
} else if (inp_ == int16_t_) {
i = Cast_Helper<int16_t>()(v);
} else if (inp_ == int32_t_) {
i = Cast_Helper<int32_t>()(v);
} else if (inp_ == int64_t_) {
i = Cast_Helper<int64_t>()(v);
} else if (inp_ == uint8_t_) {
i = Cast_Helper<uint8_t>()(v);
} else if (inp_ == uint16_t_) {
i = Cast_Helper<uint16_t>()(v);
} else if (inp_ == uint32_t_) {
i = Cast_Helper<uint32_t>()(v);
} else {
throw boost::bad_any_cast();
}
}
bool operator==(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) == ((r.m_isfloat)?r.d:r.i);
}
bool operator<(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) < ((r.m_isfloat)?r.d:r.i);
}
bool operator>(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) > ((r.m_isfloat)?r.d:r.i);
}
bool operator>=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) >= ((r.m_isfloat)?r.d:r.i);
}
bool operator<=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) <= ((r.m_isfloat)?r.d:r.i);
}
bool operator!=(const Boxed_POD_Value &r) const
{
return ((m_isfloat)?d:i) != ((r.m_isfloat)?r.d:r.i);
}
Boxed_Value operator+(const Boxed_POD_Value &r) const
{
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i + r.i);
}
return Boxed_Value(((m_isfloat)?d:i) + ((r.m_isfloat)?r.d:r.i));
}
Boxed_Value operator*(const Boxed_POD_Value &r) const
{
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i * r.i);
}
return Boxed_Value(((m_isfloat)?d:i) * ((r.m_isfloat)?r.d:r.i));
}
Boxed_Value operator/(const Boxed_POD_Value &r) const
{
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i / r.i);
}
return Boxed_Value(((m_isfloat)?d:i) / ((r.m_isfloat)?r.d:r.i));
}
Boxed_Value operator-(const Boxed_POD_Value &r) const
{
if (!m_isfloat && !r.m_isfloat)
{
return Boxed_Value(i - r.i);
}
return Boxed_Value(((m_isfloat)?d:i) - ((r.m_isfloat)?r.d:r.i));
}
double d;
int64_t i;
bool m_isfloat;
};
template<>
struct Cast_Helper<Boxed_POD_Value>
{
Boxed_POD_Value operator()(Boxed_Value ob)
{
return Boxed_POD_Value(ob);
}
};
#endif #endif

306
dispatchkit/dispatchkit.hpp
View File

@ -16,194 +16,196 @@
#include "proxy_functions.hpp" #include "proxy_functions.hpp"
#include "proxy_constructors.hpp" #include "proxy_constructors.hpp"
class Dispatch_Engine namespace dispatchkit
{ {
public: class Dispatch_Engine
typedef std::multimap<std::string, boost::shared_ptr<Proxy_Function> > Function_Map; {
typedef std::map<std::string, Type_Info> Type_Name_Map; public:
typedef std::map<std::string, Boxed_Value> Scope; typedef std::multimap<std::string, boost::shared_ptr<Proxy_Function> > Function_Map;
typedef std::deque<Scope> Stack; typedef std::map<std::string, Type_Info> Type_Name_Map;
typedef std::map<std::string, Boxed_Value> Scope;
typedef std::deque<Scope> Stack;
Dispatch_Engine() Dispatch_Engine()
{
m_scopes.push_back(Scope());
}
void register_function(const boost::shared_ptr<Proxy_Function> &f, const std::string &name)
{
m_functions.insert(std::make_pair(name, f));
}
template<typename Function>
void register_function(const Function &func, const std::string &name)
{ {
m_functions.insert(std::make_pair(name, boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<Function>(func)))); m_scopes.push_back(Scope());
}
void register_function(const boost::shared_ptr<Proxy_Function> &f, const std::string &name)
{
m_functions.insert(std::make_pair(name, f));
} }
template<typename Class> template<typename Function>
void set_object(const std::string &name, const Class &obj) void register_function(const Function &func, const std::string &name)
{
m_functions.insert(std::make_pair(name, boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<Function>(func))));
}
template<typename Class>
void set_object(const std::string &name, const Class &obj)
{
for (int i = m_scopes.size()-1; i >= 0; --i)
{
std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
if (itr != m_scopes[i].end())
{
m_scopes[i][name] = Boxed_Value(obj);
return;
}
}
add_object(name, obj);
}
template<typename Class>
void add_object(const std::string &name, const Class &obj)
{
m_scopes.back()[name] = Boxed_Value(obj);
}
void new_scope()
{
m_scopes.push_back(Scope());
}
void pop_scope()
{
if (m_scopes.size() > 1)
{
m_scopes.pop_back();
} else {
throw std::range_error("Unable to pop global stack");
}
}
Stack get_stack()
{
return m_scopes;
}
Stack set_stack(Stack s)
{
swap(s, m_scopes);
return s;
}
Boxed_Value get_object(const std::string &name) const
{ {
for (int i = m_scopes.size()-1; i >= 0; --i) for (int i = m_scopes.size()-1; i >= 0; --i)
{ {
std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name); std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
if (itr != m_scopes[i].end()) if (itr != m_scopes[i].end())
{ {
m_scopes[i][name] = Boxed_Value(obj); return itr->second;
return;
} }
} }
add_object(name, obj); throw std::range_error("Object not known: " + name);
} }
template<typename Class> template<typename Type>
void add_object(const std::string &name, const Class &obj) void register_type(const std::string &name)
{
m_scopes.back()[name] = Boxed_Value(obj);
}
void new_scope()
{
m_scopes.push_back(Scope());
}
void pop_scope()
{
if (m_scopes.size() > 1)
{
m_scopes.pop_back();
} else {
throw std::range_error("Unable to pop global stack");
}
}
Stack get_stack()
{
return m_scopes;
}
Stack set_stack(Stack s)
{
swap(s, m_scopes);
return s;
}
Boxed_Value get_object(const std::string &name) const
{
for (int i = m_scopes.size()-1; i >= 0; --i)
{
std::map<std::string, Boxed_Value>::const_iterator itr = m_scopes[i].find(name);
if (itr != m_scopes[i].end())
{ {
return itr->second; m_types.insert(std::make_pair(name, Get_Type_Info<Type>::get()));
} }
}
throw std::range_error("Object not known: " + name); std::vector<Type_Name_Map::value_type> get_types() const
}
template<typename Type>
void register_type(const std::string &name)
{ {
m_types.insert(std::make_pair(name, Get_Type_Info<Type>::get())); return std::vector<Type_Name_Map::value_type>(m_types.begin(), m_types.end());
} }
std::vector<Type_Name_Map::value_type> get_types() const std::vector<std::pair<std::string, Function_Map::mapped_type> >
{ get_function(const std::string &t_name) const
return std::vector<Type_Name_Map::value_type>(m_types.begin(), m_types.end()); {
} std::vector<std::pair<std::string, Function_Map::mapped_type> > funcs;
std::vector<std::pair<std::string, Function_Map::mapped_type> > try {
get_function(const std::string &t_name) const funcs.insert(funcs.end(),
{ Function_Map::value_type(
std::vector<std::pair<std::string, Function_Map::mapped_type> > funcs; t_name,
Cast_Helper<Function_Map::mapped_type>()(get_object(t_name)))
);
} catch (const std::bad_cast &) {
} catch (const std::range_error &) {
}
try { std::pair<Function_Map::const_iterator, Function_Map::const_iterator> range
funcs.insert(funcs.end(), = m_functions.equal_range(t_name);
Function_Map::value_type(
t_name, funcs.insert(funcs.end(), range.first, range.second);
Cast_Helper<Function_Map::mapped_type>()(get_object(t_name))) return funcs;
);
} catch (const std::bad_cast &) {
} catch (const std::range_error &) {
} }
std::pair<Function_Map::const_iterator, Function_Map::const_iterator> range std::vector<Function_Map::value_type> get_functions() const
= m_functions.equal_range(t_name); {
return std::vector<Function_Map::value_type>(m_functions.begin(), m_functions.end());
}
funcs.insert(funcs.end(), range.first, range.second); private:
return funcs; std::deque<Scope> m_scopes;
}
std::vector<Function_Map::value_type> get_functions() const Function_Map m_functions;
{ Type_Name_Map m_types;
return std::vector<Function_Map::value_type>(m_functions.begin(), m_functions.end()); };
}
private: void dump_object(Boxed_Value o)
std::deque<Scope> m_scopes;
Function_Map m_functions;
Type_Name_Map m_types;
};
void dump_object(Boxed_Value o)
{
std::cout << o.get_type_info().m_type_info->name() << std::endl;
}
void dump_type(const Type_Info &type)
{
std::cout << type.m_bare_type_info->name();
}
void dump_function(const Dispatch_Engine::Function_Map::value_type &f)
{
std::vector<Type_Info> params = f.second->get_param_types();
dump_type(params.front());
std::cout << " " << f.first << "(";
for (std::vector<Type_Info>::const_iterator itr = params.begin() + 1;
itr != params.end();
++itr)
{ {
dump_type(*itr); std::cout << o.get_type_info().m_type_info->name() << std::endl;
std::cout << ", ";
} }
std::cout << ")" << std::endl; void dump_type(const Type_Info &type)
}
void dump_system(const Dispatch_Engine &s)
{
std::cout << "Registered Types: " << std::endl;
std::vector<Dispatch_Engine::Type_Name_Map::value_type> types = s.get_types();
for (std::vector<Dispatch_Engine::Type_Name_Map::value_type>::const_iterator itr = types.begin();
itr != types.end();
++itr)
{ {
std::cout << itr->first << ": "; std::cout << type.m_bare_type_info->name();
dump_type(itr->second); }
void dump_function(const Dispatch_Engine::Function_Map::value_type &f)
{
std::vector<Type_Info> params = f.second->get_param_types();
dump_type(params.front());
std::cout << " " << f.first << "(";
for (std::vector<Type_Info>::const_iterator itr = params.begin() + 1;
itr != params.end();
++itr)
{
dump_type(*itr);
std::cout << ", ";
}
std::cout << ")" << std::endl;
}
void dump_system(const Dispatch_Engine &s)
{
std::cout << "Registered Types: " << std::endl;
std::vector<Dispatch_Engine::Type_Name_Map::value_type> types = s.get_types();
for (std::vector<Dispatch_Engine::Type_Name_Map::value_type>::const_iterator itr = types.begin();
itr != types.end();
++itr)
{
std::cout << itr->first << ": ";
dump_type(itr->second);
std::cout << std::endl;
}
std::cout << std::endl; std::vector<Dispatch_Engine::Function_Map::value_type> funcs = s.get_functions();
std::cout << "Functions: " << std::endl;
for (std::vector<Dispatch_Engine::Function_Map::value_type>::const_iterator itr = funcs.begin();
itr != funcs.end();
++itr)
{
dump_function(*itr);
}
std::cout << std::endl; std::cout << std::endl;
} }
std::cout << std::endl; std::vector<Dispatch_Engine::Function_Map::value_type> funcs = s.get_functions();
std::cout << "Functions: " << std::endl;
for (std::vector<Dispatch_Engine::Function_Map::value_type>::const_iterator itr = funcs.begin();
itr != funcs.end();
++itr)
{
dump_function(*itr);
}
std::cout << std::endl;
} }
#endif #endif

43
dispatchkit/proxy_constructors.hpp
View File

@ -8,17 +8,20 @@
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <boost/function.hpp> #include <boost/function.hpp>
template<typename Class> namespace dispatchkit
boost::shared_ptr<Class> constructor()
{ {
return boost::shared_ptr<Class>(new Class()); template<typename Class>
} boost::shared_ptr<Class> constructor()
{
return boost::shared_ptr<Class>(new Class());
}
template<typename Class> template<typename Class>
boost::function<boost::shared_ptr<Class> ()> build_constructor() boost::function<boost::shared_ptr<Class> ()> build_constructor()
{ {
typedef boost::shared_ptr<Class> (*func)(); typedef boost::shared_ptr<Class> (*func)();
return boost::function<boost::shared_ptr<Class> ()>(func(&(constructor<Class>))); return boost::function<boost::shared_ptr<Class> ()>(func(&(constructor<Class>)));
}
} }
#define BOOST_PP_ITERATION_LIMITS ( 1, 10 ) #define BOOST_PP_ITERATION_LIMITS ( 1, 10 )
@ -28,18 +31,20 @@ boost::function<boost::shared_ptr<Class> ()> build_constructor()
#else #else
# define n BOOST_PP_ITERATION() # define n BOOST_PP_ITERATION()
namespace dispatchkit
template<typename Class, BOOST_PP_ENUM_PARAMS(n, typename Param) >
boost::shared_ptr<Class> constructor( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
{ {
return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) )); template<typename Class, BOOST_PP_ENUM_PARAMS(n, typename Param) >
} boost::shared_ptr<Class> constructor( BOOST_PP_ENUM_BINARY_PARAMS(n, Param, p) )
{
return boost::shared_ptr<Class>(new Class( BOOST_PP_ENUM_PARAMS(n, p) ));
}
template<typename Class, BOOST_PP_ENUM_PARAMS(n, typename Param) > template<typename Class, BOOST_PP_ENUM_PARAMS(n, typename Param) >
boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))> build_constructor() boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))> build_constructor()
{ {
typedef boost::shared_ptr<Class> (*func)(BOOST_PP_ENUM_PARAMS(n, Param)); typedef boost::shared_ptr<Class> (*func)(BOOST_PP_ENUM_PARAMS(n, Param));
return boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))>(func(&(constructor<Class, BOOST_PP_ENUM_PARAMS(n, Param)>))); return boost::function<boost::shared_ptr<Class> (BOOST_PP_ENUM_PARAMS(n, Param))>(func(&(constructor<Class, BOOST_PP_ENUM_PARAMS(n, Param)>)));
}
} }
#endif #endif

360
dispatchkit/proxy_functions.hpp
View File

@ -16,212 +16,220 @@
#include <stdexcept> #include <stdexcept>
#include <vector> #include <vector>
// handle_return implementations namespace dispatchkit
template<typename Ret>
struct Handle_Return
{ {
Boxed_Value operator()(const boost::function<Ret ()> &f) // handle_return implementations
{ template<typename Ret>
return Boxed_Value(f()); struct Handle_Return
}
};
template<typename Ret>
struct Handle_Return<Ret &>
{
Boxed_Value operator()(const boost::function<Ret &()> &f)
{
return Boxed_Value(boost::ref(f()));
}
};
template<>
struct Handle_Return<Boxed_Value>
{
Boxed_Value operator()(const boost::function<Boxed_Value ()> &f)
{
return f();
}
};
template<>
struct Handle_Return<Boxed_Value &>
{
Boxed_Value operator()(const boost::function<Boxed_Value &()> &f)
{
return f();
}
};
template<>
struct Handle_Return<void>
{
Boxed_Value operator()(const boost::function<void ()> &f)
{
f();
return Boxed_Value(Boxed_Value::Void_Type());
}
};
// Build param type list (variadic)
template<typename Ret>
std::vector<Type_Info> build_param_type_list(const boost::function<Ret ()> &f)
{
std::vector<Type_Info> ti;
ti.push_back(Get_Type_Info<Ret>::get());
return ti;
}
// call_func implementations (variadic)
template<typename Ret>
Boxed_Value call_func(const boost::function<Ret ()> &f, const std::vector<Boxed_Value> &params)
{
if (params.size() != 0)
{
throw std::range_error("Incorrect number of parameters");
} else {
return Handle_Return<Ret>()(f);
}
}
struct Param_List_Builder
{
Param_List_Builder &operator<<(const Boxed_Value &so)
{
objects.push_back(so);
return *this;
}
template<typename T>
Param_List_Builder &operator<<(T t)
{ {
objects.push_back(Boxed_Value(t)); Boxed_Value operator()(const boost::function<Ret ()> &f)
{
return Boxed_Value(f());
}
};
template<typename Ret>
struct Handle_Return<Ret &>
{
Boxed_Value operator()(const boost::function<Ret &()> &f)
{
return Boxed_Value(boost::ref(f()));
}
};
template<>
struct Handle_Return<Boxed_Value>
{
Boxed_Value operator()(const boost::function<Boxed_Value ()> &f)
{
return f();
}
};
template<>
struct Handle_Return<Boxed_Value &>
{
Boxed_Value operator()(const boost::function<Boxed_Value &()> &f)
{
return f();
}
};
template<>
struct Handle_Return<void>
{
Boxed_Value operator()(const boost::function<void ()> &f)
{
f();
return Boxed_Value(Boxed_Value::Void_Type());
}
};
// Build param type list (variadic)
template<typename Ret>
std::vector<Type_Info> build_param_type_list(const boost::function<Ret ()> &f)
{
std::vector<Type_Info> ti;
ti.push_back(Get_Type_Info<Ret>::get());
return ti;
}
// call_func implementations (variadic)
template<typename Ret>
Boxed_Value call_func(const boost::function<Ret ()> &f, const std::vector<Boxed_Value> &params)
{
if (params.size() != 0)
{
throw std::range_error("Incorrect number of parameters");
} else {
return Handle_Return<Ret>()(f);
}
}
struct Param_List_Builder
{
Param_List_Builder &operator<<(const Boxed_Value &so)
{
objects.push_back(so);
return *this; return *this;
} }
operator const std::vector<Boxed_Value> &() const template<typename T>
{ Param_List_Builder &operator<<(T t)
return objects; {
} objects.push_back(Boxed_Value(t));
return *this;
}
std::vector<Boxed_Value> objects; operator const std::vector<Boxed_Value> &() const
}; {
return objects;
}
std::vector<Boxed_Value> objects;
};
}
#define BOOST_PP_ITERATION_LIMITS ( 1, 10 ) #define BOOST_PP_ITERATION_LIMITS ( 1, 10 )
#define BOOST_PP_FILENAME_1 "proxy_functions.hpp" #define BOOST_PP_FILENAME_1 "proxy_functions.hpp"
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
class Proxy_Function namespace dispatchkit
{ {
public: class Proxy_Function
virtual ~Proxy_Function() {} {
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) = 0; public:
virtual std::vector<Type_Info> get_param_types() = 0; virtual ~Proxy_Function() {}
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) = 0;
virtual std::vector<Type_Info> get_param_types() = 0;
}; };
class Dynamic_Proxy_Function : public Proxy_Function class Dynamic_Proxy_Function : public Proxy_Function
{ {
public: public:
Dynamic_Proxy_Function(const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, int arity=-1) Dynamic_Proxy_Function(const boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> &t_f, int arity=-1)
: m_f(t_f), m_arity(arity) : m_f(t_f), m_arity(arity)
{
}
virtual ~Dynamic_Proxy_Function() {}
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
{
if (m_arity < 0 || params.size() == size_t(m_arity))
{ {
return m_f(params); }
} else {
throw std::range_error("Incorrect number of parameters"); virtual ~Dynamic_Proxy_Function() {}
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
{
if (m_arity < 0 || params.size() == size_t(m_arity))
{
return m_f(params);
} else {
throw std::range_error("Incorrect number of parameters");
}
}
virtual std::vector<Type_Info> get_param_types()
{
return build_param_type_list(m_f);
}
private:
boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
int m_arity;
};
template<typename Func>
class Proxy_Function_Impl : public Proxy_Function
{
public:
Proxy_Function_Impl(const Func &f)
: m_f(f)
{
}
virtual ~Proxy_Function_Impl() {}
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
{
return call_func(m_f, params);
}
virtual std::vector<Type_Info> get_param_types()
{
return build_param_type_list(m_f);
}
private:
Func m_f;
};
Boxed_Value dispatch(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs,
const std::vector<Boxed_Value> &plist)
{
for (std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > >::const_iterator itr = funcs.begin();
itr != funcs.end();
++itr)
{
try {
return (*itr->second)(plist);
} catch (const std::bad_cast &) {
//try again
} catch (const std::range_error &) {
//invalid num params, try again
} }
} }
virtual std::vector<Type_Info> get_param_types() throw std::runtime_error("No matching function to dispatch to");
{
return build_param_type_list(m_f);
}
private:
boost::function<Boxed_Value (const std::vector<Boxed_Value> &)> m_f;
int m_arity;
};
template<typename Func>
class Proxy_Function_Impl : public Proxy_Function
{
public:
Proxy_Function_Impl(const Func &f)
: m_f(f)
{
}
virtual ~Proxy_Function_Impl() {}
virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
{
return call_func(m_f, params);
}
virtual std::vector<Type_Info> get_param_types()
{
return build_param_type_list(m_f);
}
private:
Func m_f;
};
Boxed_Value dispatch(const std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > > &funcs,
const std::vector<Boxed_Value> &plist)
{
for (std::vector<std::pair<std::string, boost::shared_ptr<Proxy_Function> > >::const_iterator itr = funcs.begin();
itr != funcs.end();
++itr)
{
try {
return (*itr->second)(plist);
} catch (const std::bad_cast &) {
//try again
} catch (const std::range_error &) {
//invalid num params, try again
}
} }
throw std::runtime_error("No matching function to dispatch to");
} }
# endif # endif
#else #else
# define n BOOST_PP_ITERATION() # define n BOOST_PP_ITERATION()
template<typename Ret, BOOST_PP_ENUM_PARAMS(n, typename Param) > namespace dispatchkit
std::vector<Type_Info> build_param_type_list(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f)
{ {
std::vector<Type_Info> ti; template<typename Ret, BOOST_PP_ENUM_PARAMS(n, typename Param) >
ti.push_back(Get_Type_Info<Ret>::get()); std::vector<Type_Info> build_param_type_list(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f)
{
std::vector<Type_Info> ti;
ti.push_back(Get_Type_Info<Ret>::get());
BOOST_PP_REPEAT(n, gettypeinfo, ~) BOOST_PP_REPEAT(n, gettypeinfo, ~)
return ti; return ti;
} }
template<typename Ret, BOOST_PP_ENUM_PARAMS(n, typename Param)> template<typename Ret, BOOST_PP_ENUM_PARAMS(n, typename Param)>
Boxed_Value call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f, Boxed_Value call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f,
const std::vector<Boxed_Value> &params) const std::vector<Boxed_Value> &params)
{ {
if (params.size() != n) if (params.size() != n)
{ {
throw std::range_error("Incorrect number of parameters"); throw std::range_error("Incorrect number of parameters");
} else { } else {
return Handle_Return<Ret>()(boost::bind(f BOOST_PP_REPEAT(n, casthelper, ~))); return Handle_Return<Ret>()(boost::bind(f BOOST_PP_REPEAT(n, casthelper, ~)));
} }
}
} }
#endif #endif

20
dispatchkit/register_function.hpp
View File

@ -18,18 +18,20 @@
#else #else
# define n BOOST_PP_ITERATION() # define n BOOST_PP_ITERATION()
template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)> namespace dispatchkit
void register_function(Dispatch_Engine &s, Ret (*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name)
{ {
s.register_function(boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))>(f), name); template<typename Ret BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
} void register_function(Dispatch_Engine &s, Ret (*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name)
{
s.register_function(boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))>(f), name);
}
template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)> template<typename Ret, typename Class BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename Param)>
void register_function(Dispatch_Engine &s, Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name) void register_function(Dispatch_Engine &s, Ret (Class::*f)(BOOST_PP_ENUM_PARAMS(n, Param)), const std::string &name)
{ {
s.register_function(boost::function<Ret (Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f), name); s.register_function(boost::function<Ret (Class* BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Param))>(f), name);
}
} }
#endif #endif

2
dispatchkit/test.cpp
View File

@ -8,6 +8,8 @@
#include "bootstrap.hpp" #include "bootstrap.hpp"
#include "bootstrap_stl.hpp" #include "bootstrap_stl.hpp"
using namespace dispatchkit;
struct Test struct Test
{ {
Test(const std::string &s) Test(const std::string &s)

129
dispatchkit/type_info.hpp
View File

@ -3,78 +3,83 @@
#include <boost/type_traits.hpp> #include <boost/type_traits.hpp>
#include <boost/ref.hpp> #include <boost/ref.hpp>
struct Type_Info
namespace dispatchkit
{ {
Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, struct Type_Info
const std::type_info *t_ti, const std::type_info *t_bareti) {
: m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer), Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void,
const std::type_info *t_ti, const std::type_info *t_bareti)
: m_is_const(t_is_const), m_is_reference(t_is_reference), m_is_pointer(t_is_pointer),
m_type_info(t_ti), m_bare_type_info(t_bareti), m_type_info(t_ti), m_bare_type_info(t_bareti),
m_is_unknown(false) m_is_unknown(false)
{ {
} }
Type_Info() Type_Info()
: m_is_const(false), m_is_reference(false), m_is_pointer(false), : m_is_const(false), m_is_reference(false), m_is_pointer(false),
m_is_void(false), m_type_info(0), m_bare_type_info(0), m_is_void(false), m_type_info(0), m_bare_type_info(0),
m_is_unknown(true) m_is_unknown(true)
{ {
} }
Type_Info &operator=(const Type_Info &ti) Type_Info &operator=(const Type_Info &ti)
{ {
m_is_const = ti.m_is_const; m_is_const = ti.m_is_const;
m_is_reference = ti.m_is_reference; m_is_reference = ti.m_is_reference;
m_is_pointer = ti.m_is_pointer; m_is_pointer = ti.m_is_pointer;
m_is_void = ti.m_is_void; m_is_void = ti.m_is_void;
m_type_info = ti.m_type_info; m_type_info = ti.m_type_info;
m_bare_type_info = ti.m_bare_type_info; m_bare_type_info = ti.m_bare_type_info;
m_is_unknown = ti.m_is_unknown; m_is_unknown = ti.m_is_unknown;
return *this; return *this;
} }
bool m_is_const; bool m_is_const;
bool m_is_reference; bool m_is_reference;
bool m_is_pointer; bool m_is_pointer;
bool m_is_void; bool m_is_void;
const std::type_info *m_type_info; const std::type_info *m_type_info;
const std::type_info *m_bare_type_info; const std::type_info *m_bare_type_info;
bool m_is_unknown; bool m_is_unknown;
}; };
template<typename T> template<typename T>
struct Get_Type_Info struct Get_Type_Info
{ {
static Type_Info get() static Type_Info get()
{ {
return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value,
boost::is_void<T>::value, boost::is_void<T>::value,
&typeid(T), &typeid(T),
&typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type)); &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
} }
}; };
template<typename T> template<typename T>
struct Get_Type_Info<boost::shared_ptr<T> > struct Get_Type_Info<boost::shared_ptr<T> >
{ {
static Type_Info get() static Type_Info get()
{ {
return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value,
boost::is_void<T>::value, boost::is_void<T>::value,
&typeid(boost::shared_ptr<T> ), &typeid(boost::shared_ptr<T> ),
&typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type)); &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
} }
}; };
template<typename T> template<typename T>
struct Get_Type_Info<boost::reference_wrapper<T> > struct Get_Type_Info<boost::reference_wrapper<T> >
{ {
static Type_Info get() static Type_Info get()
{ {
return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value, return Type_Info(boost::is_const<T>::value, boost::is_reference<T>::value, boost::is_pointer<T>::value,
boost::is_void<T>::value, boost::is_void<T>::value,
&typeid(boost::reference_wrapper<T> ), &typeid(boost::reference_wrapper<T> ),
&typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type)); &typeid(typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type));
} }
}; };
}
#endif #endif

2
dispatchkit/unittest.cpp
View File

@ -7,6 +7,8 @@
BOOST_AUTO_TEST_CASE( add_operators ) BOOST_AUTO_TEST_CASE( add_operators )
{ {
using namespace dispatchkit;
Dispatch_Engine ss; Dispatch_Engine ss;
Bootstrap::bootstrap(ss); Bootstrap::bootstrap(ss);
dump_system(ss); dump_system(ss);