chaiscript::ChaiScript chai;

class MyClass
{
public:
  MyClass(int t_value) : m_value(t_value) {}
 
  int get_value() { return m_value; }
  void multiply_value(int v) { m_value *= v; }
  std::string data;
 
private:
  int m_value;
};
 
std::string concat(const std::string &first, const std::string &second)
{
  return first + second;
}

chai.add(fun(&MyClass::get_value), "get_value");
chai.add(fun(&MyClass::multiply_value), "multiply_value");
 
// the data member can be added like other class members
chai.add(fun(&MyClass::data), "data"); 
 
//"fun"'s can also be implicitly created using the "constructor" function
//for exposing class constructors
chai.add(constructor<MyClass (int)>(), "MyClass");
 
//Exposing a free function is the same:
chai.add(fun(&concat), "my_concat");
 
//Also, a boost::function can be added
chai.add(fun(boost::function<std::string (const std::string)>(boost::bind(&concat, "Hello ", _1))), "my_bound_concat");

class MyClass
{
  public:
    MyClass(int t_val) : m_value(t_val) {}
 
    int add_value(int i) { return m_val + i; }
 
  private:
    int t_val
};
 
MyClass object(10);
chai.add(fun(&MyClass::add_value, &object), "add_value"); // Add "add_value" which is bound to the "object" variable.

int i = 5;
chai.add(var(i), "i"); // Add a copy of i, and call it "i"

boost::shared_ptr<MyClass> myclass(new MyClass(5));
chai.add(var(myclass), "myclass"); // Add our shared MyClass object to the system

// This option is a little dangerous, if the local i were to go out of scope,
// the pointer would become invalidated
int i = 5;
chai.add(var(&i), "i"); // Add a pointer to i. 

// This option is dangerous in the same way that the pointer version is
std::string s = "hello world";
chai.add(var(boost::ref(s)), "str"); // Add a boost::reference to our string

int i = 5;
chai.add(const_var(&i), "consti"); // Add a const pointer to i

chai.add(user_type<MyClass>(), "MyClass");

//Add default and copy constructors for our type
chai.add(bootstrap::basic_constructors<MyClass>("MyClass"));

//Add a new type, a vector of our MyClass
chai.add(bootstrap::vector_type<std::vector<MyClass> >("MyClassVec"));

//Add a new global const value
chai.add(const_var(1), "myconstint");

chai.eval("var j = 5+7; print(j)");

int i = chai.eval<int>("5+7");

boost::shared_ptr<MyClass> obj = chai.eval<boost::shared_ptr<MyClass> >("var obj = MyClass(2)");
 
obj.multiply_value(3);
 
chai.eval("print(obj.get_value())");
chai.eval("obj.multiply_value(2)");
 
std::cout << obj.get_value() << std::endl;

chai("obj.multiply_value(18)");

Boxed_Value bv = chai("MyClass()"); // construct a MyClass in a generic factory-style way

boost::function<void ()> print_value = chai.functor<void ()>("fun() { print(obj.get_value()) }");
 
print_value();
 
boost::function<int (int, int)> int_max = chai.functor<int (int, int)>("fun(x, y) { if (x>y) {x} else {y} }");
 
int m = int_max(6,7);
 
//Note, the returned boost::function need not necessarily be stored in a local
//variable. An interesting shortcut would be to do:
int s = chai.functor<void (int, int)>("fun(x, y) { x+y }")(4,5);
 
//The above technique is particularly handy when you need to substitute
//in C++ variables into your executed ChaiScript code.

ChaiScript::State state = chai.get_state();
chai.set_state(state);

Boxed_Value bv = chai("MyClass()"); 
 
//Various ways of extracting type safe data from a Boxed_Value
boost::shared_ptr<MyClass> o1 = boxed_cast<boost::shared_ptr<MyClass> >(bv);
MyClass &o2 = boxed_cast<MyClass &>(bv);
MyClass o3 = boxed_cast<MyClass>(bv); // This version makes a copy
MyClass *o4 = boxed_cast<MyClass *>(bv);
 
//If we try a boxed_cast that is invalid a bad_boxed_cast is thrown
try {
  int i = boxed_cast<int>(bv);
} catch (const bad_boxed_cast &) {
  // failure in boxed_cast
}

struct Callback_Handler
{
  std::vector<boost::function<int (const std::string &)> > m_funcs;
 
  void add(const chaiscript::Proxy_Function &f)
  {
    //Create a boost::function<> from the passed in Proxy_Function
    //and add it to our vector of chaiscript
    m_funcs.push_back(chaiscript::functor<int (const std::string &)>(f));
  }
};
 
int main()
{
  chaiscript::ChaiScript chai;
  chai.add(fun(&Callback_Handler::add), "add");
 
  Callback_Handler ch;
  chai.add(var(&ch), "callback_handler");
 
  //Create a chaiscript lambda function and add it to the list 
  //list of callbacks 
  chai.eval("challback_handler.add(fun(x) { x.size(); })");
}

chai.add(fun(&MyClass::operator+), "+");

chai.add(operators::less_than<MyClass>());