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);
}
