Function main

samples/example.cpp:66–176

}

int main(int /*argc*/, char * /*argv*/[]) {
  using namespace chaiscript;

  ChaiScript chai;
  

  //Create a new system object and share it with the chaiscript engine
  System system;
  chai.add_global(var(&system), "system");

  //Add a bound callback method
  chai.add(fun(&System::add_callback, std::ref(system)), "add_callback_bound");

  //Register the two methods of the System structure.
  chai.add(fun(&System::add_callback), "add_callback");
  chai.add(fun(&System::do_callbacks), "do_callbacks");

  chai.add(fun(&take_shared_ptr), "take_shared_ptr");

  // Let's use chaiscript to add a new lambda callback to our system. 
  // The function "{ 'Callback1' + x }" is created in chaiscript and passed into our C++ application
  // in the "add_callback" function of struct System the chaiscript function is converted into a 
  // std::function, so it can be handled and called easily and type-safely
  chai.eval(R"(system.add_callback("#1", fun(x) { "Callback1 " + x });)");
  
  // Because we are sharing the "system" object with the chaiscript engine we have equal
  // access to it both from within chaiscript and from C++ code
  system.do_callbacks("TestString");
  chai.eval(R"(system.do_callbacks("TestString");)");

  // The log function is overloaded, therefore we have to give the C++ compiler a hint as to which
  // version we want to register. One way to do this is to create a typedef of the function pointer
  // then cast your function to that typedef.
  using PlainLog = void (*)(const std::string &);
  using ModuleLog = void (*)(const std::string &, const std::string &);
  chai.add(fun(PlainLog(&log)), "log");
  chai.add(fun(ModuleLog(&log)), "log");

  chai.eval(R"(log("Test Message"))");

  // A shortcut to using eval is just to use the chai operator()
  chai(R"(log("Test Module", "Test Message");)");

  //Finally, it is possible to register a lambda as a system function, in this 
  //way, we can, for instance add a bound member function to the system
  chai.add(fun([&system](){ return system.do_callbacks("Bound Test"); }), "do_callbacks");

  //Call bound version of do_callbacks
  chai("do_callbacks()");

  std::function<void ()> caller = chai.eval<std::function<void ()> >(
    R"(fun() { system.do_callbacks("From Functor"); })"
  );
  caller();


  //If we would like a type-safe return value from all call, we can use
  //the templated version of eval: