void run() { using std::string; using boost::variant; using boost::apply_visitor; typedef variant<int, float, unsigned short, unsigned char> t_var1; typedef variant<int, t_var1, unsigned short, unsigned char> t_var2; typedef variant<string, int, t_var2> t_var3; t_var1 v1; t_var2 v2; t_var2 v2_second; t_var3 v3; const char c0 = 'x'; v1 = c0; //v2 and v3 are holding (aka: containing) a variant v2 = v1; v3 = v2; verify(v1, spec<int>()); verify(v2, spec<t_var1>()); verify(v3, spec<t_var2>()); // // assignment from const char (Converted to int) // v2 = c0; v3 = c0; verify(v2, spec<int>()); verify(v3, spec<int>()); BOOST_CHECK(apply_visitor(sum_int(), v2) == c0); BOOST_CHECK(apply_visitor(sum_int(), v3) == c0); sum_int adder; apply_visitor(adder, v2); apply_visitor(adder, v3); BOOST_CHECK(adder.result() == 2*c0); // // A variant holding a variant // typedef variant<unsigned char, float> t_var4; typedef variant<string, t_var4> t_var5; t_var4 v4; t_var5 v5; v5 = 22.5f; verify(v5, spec<t_var4>(), "[V] [V] 22.5"); }
void operator()(const list& lst) const { check(lst.size() >= 0, "syntax error in 'define'."); value sym_v = lst.head(); symbol sym = apply_visitor(function_name_visitor(), sym_v); check(!env_p->find_local(sym), "attempting to redefine symbol '" + sym + "'."); value params_v = lst.tail(); vector< symbol > params = apply_visitor(lambda_params_visitor(), params_v); env_p->set(sym, make_shared< lambda >(params, expr[2], env_p)); }
void repl(shared_ptr< environment > env_p) { cout << prompt; string line; while (getline(cin, line)) { string code = line; stack< int > open_parens; while (!paren_match(code) || !quot_match(code)) { int ind = indent(line, open_parens); cout << string(ind + prompt.length(), ' '); if (!getline(cin, line)) { cout << bye; return; } if (quot_match(code)) code.push_back(' '); code += line; } vector< string > parts = split(code); for (auto it = begin(parts); it + 1 < end(parts); ++it) eval(parse(*it), env_p); if (!parts.empty()) { value retval = eval(parse(parts.back()), env_p); apply_visitor(return_value_visitor(), retval); } cout << prompt; } cout << bye; }
void IWORKPath::write(librevenge::RVNGPropertyListVector &vec, double deltaX, double deltaY) const { for (Path_t::const_iterator it = m_impl->m_path.begin(); it != m_impl->m_path.end(); ++it) { for (const auto &cIt : *it) apply_visitor(Writer(vec, deltaX, deltaY), cIt); } }
void IWORKPath::operator*=(const glm::dmat3 &tr) { for (auto &it : m_impl->m_path) { for (auto &cIt : it) apply_visitor(Transformer(tr), cIt); } }
vector< symbol > operator()(const list& lst) const { vector< symbol > params(lst.size()); transform(begin(lst), end(lst), begin(params), [](value v) { return apply_visitor(parameter_visitor(), v); }); return params; }
void LabelOperandResolver::operator()(Line* line) { //this is to check if we had a blank line if(line->contents) { auto tmp = ProcLineContents(_labelTable, _errorReporting); apply_visitor(tmp, line->contents.get()); } }
vector<CustomAttributeArgument> const &BaseCustomAttributeGeneratorPimpl<ApiHolder>::GetFieldValues() const { if (!m_fieldValuesInit) { for (auto i = m_fieldValues.begin(), i_end = m_fieldValues.end(); i != i_end; ++i) *i = apply_visitor(resolve_argument_visitor(m_pAsmGen), *i); m_fieldValuesInit = true; } return m_fieldValues; }
void operator()(const symbol& sym) const { check(env_p->find(sym), "argument '" + sym + "' to 'set!' is undefined."); value val = env_p->get(sym); if (apply_visitor(set_reference_visitor(expr, env_p), val)) return; if (env_p->find_local(sym)) env_p->set(sym, eval(expr[2], env_p)); else env_p->set_outermost(sym, eval(expr[2], env_p)); }
const std::string IWORKPath::str() const { ostringstream sink; Path_t::const_iterator it = m_impl->m_path.begin(); const Path_t::const_iterator end = m_impl->m_path.end(); if (it != end) { apply_visitor(SVGPrinter(sink), *it); for (++it; it != end; ++it) { sink << ' '; apply_visitor(SVGPrinter(sink), *it); } if (m_impl->m_closed) sink << " Z"; } return sink.str(); }
void IWORKPath::write(librevenge::RVNGPropertyListVector &vec) const { for (Path_t::const_iterator it = m_impl->m_path.begin(); it != m_impl->m_path.end(); ++it) apply_visitor(Writer(vec), *it); if (m_impl->m_closed) { librevenge::RVNGPropertyList element; element.insert("librevenge:path-action", "Z"); vec.append(element); } }
vector<CustomAttributeArgument> const &BaseCustomAttributeGeneratorPimpl<ApiHolder>::GetConstructorArguments() const { using boost::apply_visitor; if (!m_constructorArgsInit) { for (auto i = m_constructorArgs.begin(), i_end = m_constructorArgs.end(); i != i_end; ++i) *i = apply_visitor(resolve_argument_visitor(m_pAsmGen), *i); m_constructorArgsInit = true; } return m_constructorArgs; }
void IWORKPath::computeBoundingBox(double &minX, double &minY, double &maxX, double &maxY, double factor) const { ComputeBoundingBox bdCompute; for (auto const &it : m_impl->m_path) { for (auto const &cIt : it) apply_visitor(bdCompute, cIt); } minX=factor*bdCompute.m_boundX[0]; maxX=factor*bdCompute.m_boundX[1]; minY=factor*bdCompute.m_boundY[0]; maxY=factor*bdCompute.m_boundY[1]; }
bool approxEqual(const IWORKPath &left, const IWORKPath &right, const double eps) { if ((left.m_impl->m_closed != right.m_impl->m_closed) || (left.m_impl->m_path.size() != right.m_impl->m_path.size())) return false; for (Path_t::const_iterator lit = left.m_impl->m_path.begin(), rit = right.m_impl->m_path.begin(); lit != left.m_impl->m_path.end(); ++lit, ++rit) { if (!apply_visitor(Comparator(eps), *lit, *rit)) return false; } return true; }
string Message::toJson() { using boost::apply_visitor; Json::Value obj; obj["method"] = Json::Value ( name_ ); Json::Value args; for ( const std::pair<argument::Name, argument::Value> & arg : argMap_ ) { apply_visitor ( ToJson ( args[arg.first] ), arg.second ); } obj["args"] = args; Json::FastWriter writer; return writer.write ( obj ); }
const std::string IWORKPath::str() const { ostringstream sink; bool first=true; for (Path_t::const_iterator it = m_impl->m_path.begin(); it != m_impl->m_path.end(); ++it) { for (const auto &cIt : *it) { if (!first) sink << ' '; else first=false; apply_visitor(SVGPrinter(sink), cIt); } } return sink.str(); }
value operator()(const symbol& sym) const { if (sym == "if") { check(expr.size() == 4, "wrong number of arguments to 'if' (must be 3)."); test_visitor visitor; value condition = eval(expr[1], env_p); bool test = apply_visitor(visitor, condition); return eval(test ? expr[2] : expr[3], env_p); } else if (sym == "define") { check(expr.size() == 3, "wrong number of arguments to 'define' (must be 2)."); apply_visitor(define_visitor(expr, env_p), expr[1]); } else if (sym == "set!") { check(expr.size() == 3, "wrong number of arguments to 'set!' (must be 2)."); apply_visitor(set_visitor(expr, env_p), expr[1]); } else if (sym == "begin") { for (int i = 1; i + 1 < expr.size(); ++i) eval(expr[i], env_p); if (expr.size() > 1) return eval(expr.back(), env_p); else return nil(); } else if (sym == "local") { auto local_env_p = nested_environment(env_p); for (int i = 1; i + 1 < expr.size(); ++i) eval(expr[i], local_env_p); if (expr.size() > 1) return eval(expr.back(), local_env_p); else return nil(); } else if (sym == "lambda") { check(expr.size() == 3, "wrong number of arguments to 'lambda' (must be 2)."); vector< symbol > params = apply_visitor(lambda_params_visitor(), expr[1]); return make_shared< lambda >(params, expr[2], env_p); } else if (sym == "defmacro") { check(expr.size() == 3, "wrong number of arguments to 'defmacro' (must be 2)."); apply_visitor(defmacro_visitor(expr, env_p), expr[1]); } else { // sym must refer to a lambda or macro function_call_visitor visitor(expr, env_p); value func_v = eval(value(sym), env_p); return apply_visitor(visitor, func_v); } return nil(); }
void run() { using boost::apply_visitor; using boost::variant; using std::string; using std::vector; using std::cout; using std::endl; //test the general stuff typedef boost::polymorphic_visitor<double, boost::arg_tuple<int, double>, boost::arg_tuple<double, int>, boost::arg_tuple<int, int>, boost::arg_tuple<double, double>> poly_vis; struct vis : poly_vis { virtual double operator()(int x, int y) override { return x+y;} virtual double operator()(double x, double y) override { return x*y;} virtual double operator()(int x, double y) override { return x-y;} virtual double operator()(double x, int y) override { return x/y;} }; vis x; poly_vis &v = x; BOOST_CHECK(v(40, 2) == 42.); BOOST_CHECK(v(1.5,2.) == 3.); BOOST_CHECK(v(50, 8.0) == 42.); BOOST_CHECK(v(100., 25) == 4); //i maybe need some more tests here... variant<int, double> v1{2.5}, v2{4.}; BOOST_CHECK(apply_visitor(v, v1, v2) == 10.); }
void IWORKPath::operator*=(const glm::dmat3 &tr) { for (Path_t::iterator it = m_impl->m_path.begin(); it != m_impl->m_path.end(); ++it) apply_visitor(Transformer(tr), *it); }
value operator()(const symbol& sym) const { check(env_p->find(sym), "symbol '" + sym + "' not found."); value val = env_p->get(sym); return apply_visitor(maybe_reference_visitor(), val); }
value eval(value expr, shared_ptr< environment > env_p) { return apply_visitor(eval_visitor(env_p), expr); }
value operator()(const list& lst) const { return apply_visitor(operator_visitor(lst, env_p), lst.front()); }
void run() { using boost::apply_visitor; using boost::variant; using std::string; using std::vector; using std::cout; using std::endl; typedef variant< char*, string, short > t_var0; typedef variant< int, string, double > t_var1; typedef variant< short, const char* > t_var2; typedef variant< string, char > t_var3; typedef variant< unsigned short, const char* > t_var4; typedef variant< unsigned short, const char*, t_var2 > t_var5; typedef variant< unsigned short, const char*, t_var5 > t_var6; typedef variant< class_a, const void* > t_var7; typedef variant< t_var6, int > t_var8; typedef variant< t_var8, unsigned short > t_var9; typedef variant< char, unsigned char > t_var10; typedef variant< short, int, vector<int>, long> t_var11; t_var1 v1; t_var0 v0; t_var2 v2; t_var3 v3; t_var4 v4; t_var5 v5; t_var6 v6; t_var7 v7; t_var8 v8; t_var9 v9; t_var10 v10; t_var11 v11; // // Check assignment rules // v2 = 4; v4 = v2; verify(v4, spec<unsigned short>()); v2 = "abc"; v4 = v2; verify(v4, spec<const char*>(), "[V] abc"); v5 = "def"; verify(v5, spec<const char*>(), "[V] def"); v5 = v2; verify(v5, spec<t_var2>(), "[V] [V] abc"); v6 = 58; verify(v6, spec<unsigned short>(), "[V] 58"); v6 = v5; verify(v6, spec<t_var5>(), "[V] [V] [V] abc"); v8 = v2; verify(v8, spec<t_var6>(), "[V] [V] abc"); v8 = v6; verify(v8, spec<t_var6>(), "[V] [V] [V] [V] abc"); v7 = v2; verify(v7, spec<const void*>()); v7 = 199; verify(v7, spec<class_a>(), "[V] class_a(199)"); v2 = 200; v7 = v2; verify(v7, spec<class_a>(), "[V] class_a(200)"); // // Check sizes of held values // total_sizeof ts; v1 = 5.9; apply_visitor(ts, v1); v1 = 'B'; apply_visitor(ts, v1); v1 = 3.4f; apply_visitor(ts, v1); BOOST_CHECK(ts.result() == sizeof(int) + sizeof(double)*2); v11 = 5; string res_s = apply_visitor(int_printer(), v11); BOOST_CHECK(res_s == "5"); // // A variant object holding an std::vector // vector<int> int_vec_1; int_vec_1.push_back(512); int_vec_1.push_back(256); int_vec_1.push_back(128); int_vec_1.push_back(64); v11 = int_vec_1; res_s = apply_visitor(int_printer(), v11); BOOST_CHECK(res_s == ",512,256,128,64"); }
value operator()(const list& lambda_lst) const { value lam_p = eval(lambda_lst, env_p); return apply_visitor(function_call_visitor(expr, env_p), lam_p); }