Move test files to contrib/test and added one liner to readme

contrib/test/callbacktest.cpp

@@ -0,0 +1,69 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include "function_call.hpp"
+#include "chaiscript.hpp"
+#include <boost/function.hpp>
+
+struct Callback_Handler
+{
+  typedef std::vector<std::pair<boost::function<std::string ()>,
+                        boost::function<double (int)> > > Callbacks;
+  
+  Callbacks m_callbacks;
+
+  void add_callbacks(boost::shared_ptr<dispatchkit::Proxy_Function> t_name,
+      boost::shared_ptr<dispatchkit::Proxy_Function> t_value)
+  {
+    m_callbacks.push_back(
+        std::make_pair(dispatchkit::build_function_caller<std::string ()>(t_name),
+                       dispatchkit::build_function_caller<double (int)>(t_value)
+          )
+        );
+  }
+
+  void do_callbacks()
+  {
+    int i=1;
+    for (Callbacks::iterator itr = m_callbacks.begin();
+         itr != m_callbacks.end();
+         ++itr)
+    {
+      std::cout << "Name: " << itr->first() << "  =  " << itr->second(i) << std::endl;
+      ++i;
+    }
+  }
+};
+
+int main(int argc, char *argv[]) {
+
+    chaiscript::ChaiScript_Engine chai;
+
+    Callback_Handler cb_handler;
+    chai.get_eval_engine().add_object("cb_handler", boost::ref(cb_handler));
+    dispatchkit::register_function(chai.get_eval_engine(), &Callback_Handler::add_callbacks, "add_callbacks");
+
+    for (int i = 1; i < argc; ++i) {
+      try {
+        dispatchkit::Boxed_Value val = chai.evaluate_file(argv[i]);
+      }
+      catch (std::exception &e) {
+        std::cerr << "Could not open: " << argv[i] << std::endl;
+        exit(1);
+      }
+    }
+
+    cb_handler.do_callbacks();
+
+    boost::function<std::string (const std::string&, const std::string &)> f = 
+      dispatchkit::build_functor<std::string (const std::string &, const std::string &)>
+        (chai, "function(x, y) { return x + y }");
+
+    std::cout << "Functor call: " << f("Hello", " World") << std::endl;
+}
+

contrib/test/dispatchkit_test.cpp

@@ -0,0 +1,212 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+
+#include <chaiscript/dispatchkit/dispatchkit.hpp>
+#include <chaiscript/dispatchkit/bootstrap.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
+#include <chaiscript/dispatchkit/function_call.hpp>
+
+using namespace dispatchkit;
+
+struct Test
+{
+  Test(const std::string &s)
+    : number(-25), message(s)
+  {
+    std::cout << "Test class constructed with value: " << s << std::endl;
+  }
+
+  void show_message()
+  {
+    std::cout << "Constructed Message: " << message << std::endl;
+  }
+
+  std::string &get_message()
+  {
+    return message;
+  }
+
+  int number;
+
+  std::string message;
+};
+
+
+
+Boxed_Value named_func_call(Dispatch_Engine &ss,
+    const std::string &nametocall, const std::vector<Boxed_Value> &params)
+{
+  if (params.size() == 2)
+  {
+    return dispatch(ss.get_function(nametocall), params);
+  } else {
+    throw std::runtime_error("Invalid num params");
+  }
+}
+
+// A function that takes a dynamic list of params
+// and calls a bunch of conversion functions on them and 
+// returns the result as a boxed_value
+Boxed_Value dynamic_function(Dispatch_Engine &ss, const std::string &name, 
+    const std::vector<Boxed_Value> &params)
+{
+  if (name == "concat_string")
+  {
+    Boxed_Value result;
+
+    //Return a void if there is nothing in the array
+    if (params.size() == 0)
+    {
+      return result;
+    } else {
+      //else, prepopulate the result with a string conversion of the first
+      //param
+      result = 
+        dispatch(ss.get_function("to_string"), Param_List_Builder() << params[0]);
+    }
+
+    //Then, loop over all remaining params, converting them to strings and adding
+    //them to the result. This example maybe bette served with a string += operator
+    //implementation, but it works.
+    for (size_t i = 1; i < params.size(); ++i)
+    {
+      result = 
+        dispatch(ss.get_function("+"), Param_List_Builder() << result << 
+            dispatch(ss.get_function("to_string"), Param_List_Builder() << params[i]));
+    }
+
+    return result;
+  } else {
+    throw std::runtime_error("Unknown function call");
+  }
+}
+
+void test(const std::string &p)
+{
+  std::cout << "Test: " << p << std::endl;
+}
+
+//Test main
+int main()
+{
+  Dispatch_Engine ss;
+  Bootstrap::bootstrap(ss);
+  bootstrap_vector<std::vector<int> >(ss, "VectorInt");
+  dump_system(ss);
+
+  //Calling a function by name and allowing the built in dispatch mechanism to
+  //choose the most appropriate version of the function
+  Boxed_Value addresult = dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3));
+
+  //Using the cast to unbox the resultant value and output it
+  std::cout << boxed_cast<double>(addresult) << std::endl;
+
+  //Using the Boxed_Value as input to another function, again with automatic dispatch.
+  //This time we will not bother saving the result and will instead send it straight out
+  std::cout << boxed_cast<double>(
+      dispatch(ss.get_function("*"), Param_List_Builder() << 2 << addresult)
+      ) << std::endl;
+
+  //Register a new function, this one with typing for us, so we don't have to ubox anything
+  //right here
+
+  //Now we have a print method, let's try to print out the earlier example:
+  //so, we dispatch the to_string and pass its result as a param to "print"
+  //In this example we don't bother with temporaries and we don't have to know
+  //anything about types
+  dispatch(ss.get_function("print_string"),
+      Param_List_Builder() << dispatch(ss.get_function("to_string"), Param_List_Builder() << addresult));
+
+  // Now we are going to register a new dynamic function,
+  // when this function is called the objects are not unboxed, but passed
+  // in in their boxed state
+  ss.register_function(boost::shared_ptr<Proxy_Function>(new Dynamic_Proxy_Function(boost::bind(&dynamic_function, boost::ref(ss), "concat_string", _1))), "concat_string");
+
+
+  // Call our newly defined dynamic function with 10 parameters, then send
+  // its output to the "print" function
+  dispatch(ss.get_function("print_string"),
+      Param_List_Builder() << dispatch(ss.get_function("concat_string"),
+        Param_List_Builder() << std::string("\n\t") << std::string("The Value Was: ") 
+                             << double(42.5) << std::string(".")
+                             << '\n'
+                             << '\t' << std::string("The old value was: ")
+                             << addresult << '.' << '\n' ));
+
+
+
+
+  //Register some local methods of the "Test" class
+  ss.register_function(build_constructor<Test, const std::string &>(), "Test");
+
+  register_function(ss, &Test::get_message, "get_message");
+  register_function(ss, &Test::show_message, "show_message");
+  register_member(ss, &Test::number, "number");
+
+  //Create a new object using the "Test" constructor, passing the param "Yo".
+  //Then, add the new object to the system with the name "testobj2"
+  ss.add_object("testobj2", 
+      dispatch(ss.get_function("Test"), Param_List_Builder() << std::string("Yo")));
+
+  // Look up and store a reference to our new object
+  std::vector<Boxed_Value> sos;
+  sos.push_back(ss.get_object("testobj2"));
+
+  //Build a bound function proxy for calling the script handled function
+  boost::function<void (Test &)> show_message = 
+    build_function_caller<void (Test &)>(ss.get_function("show_message"));
+
+  Test &t = boxed_cast<Test &>(ss.get_object("testobj2"));
+
+  //Print the message the object was created with
+  show_message(t);
+
+  //Now, get a reference to the object's stored message
+  Boxed_Value stringref = dispatch(ss.get_function("get_message"), sos);
+
+  //Unbox it using boxed_cast
+  std::string &sr = boxed_cast<std::string &>(stringref);
+
+  //Update the value of the reference
+  sr = "Bob Updated The message";
+
+  //Now, get a reference to the object's stored number
+  Boxed_Value numberref= dispatch(ss.get_function("number"), sos);
+
+  //Unbox it using boxed_cast
+  int &ir = boxed_cast<int &>(numberref);
+
+  std::cout << "Number: " << ir << std::endl;
+
+  //Now, prove that the reference was successfully acquired
+  //and we are able to peek into the boxed types
+  show_message(t);
+
+
+  // Finally, we are going to register some named function aliases, for 
+  // the fun of it
+  ss.register_function(boost::shared_ptr<Proxy_Function>(
+        new Dynamic_Proxy_Function(boost::bind(&named_func_call, boost::ref(ss), "+", _1))), "add");
+
+  //Call our newly named "add" function (which in turn dispatches +)
+  
+  std::cout << "Result of add function: " << 
+    boxed_cast<int>(dispatch(ss.get_function("add"), Param_List_Builder() << 5 << 2))
+    << std::endl; 
+
+
+  ss.set_object("myfunc", boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<boost::function<void (const std::string &)> >(&test)));
+
+  dispatch(ss.get_function("myfunc"), Param_List_Builder() << std::string("hello function variable"));
+
+}
+

contrib/test/dispatchkit_unittest.cpp

@@ -0,0 +1,23 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include "dispatchkit.hpp"
+#include "bootstrap.hpp"
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE boxedcpp_unittests
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE( add_operators )
+{
+  using namespace dispatchkit;
+
+  Dispatch_Engine ss;
+  Bootstrap::bootstrap(ss);
+  dump_system(ss);
+
+  BOOST_CHECK_EQUAL(boxed_cast<int>(dispatch(ss.get_function("+"), Param_List_Builder() << double(5.1) << double(10.3))), 15.4);
+}

contrib/test/sensors.cpp

@@ -0,0 +1,148 @@
+// This file is distributed under the BSD License.
+// See "license.txt" for details.
+// Copyright 2009, Jonathan Turner (jturner@minnow-lang.org)
+// and Jason Turner (lefticus@gmail.com)
+// http://www.chaiscript.com
+
+#include <iostream>
+
+#include "chaiscript.hpp"
+#include "function_call.hpp"
+#include <boost/function.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/regex.hpp>
+
+
+std::string load_text_file(const std::string &filename)
+{
+  std::ifstream infile(filename.c_str());
+
+  std::string str;
+
+  std::string result;
+
+  while (std::getline(infile, str))
+  {
+    result += str + "\n";
+  }
+
+  return result;
+}
+
+std::vector<dispatchkit::Boxed_Value> regex_search(const std::string &str, const std::string &regex)
+{
+  boost::smatch matches;
+  boost::regex_search(str, matches, boost::regex(regex));
+
+  std::vector<dispatchkit::Boxed_Value> results;
+
+  for (unsigned int i = 0; i < matches.size(); ++i)
+  {
+    results.push_back(dispatchkit::Boxed_Value(std::string(matches.str(i))));
+  }
+
+  return results;
+}
+
+struct Sensor_Manager
+{
+  struct Sensor
+  {
+    int milliseconds;
+    dispatchkit::Boxed_Value state_object;
+    boost::function<double (dispatchkit::Boxed_Value)> sensor;
+    boost::posix_time::ptime next_run;
+
+    Sensor(int t_milliseconds, dispatchkit::Boxed_Value t_state_object, 
+        boost::function<double (dispatchkit::Boxed_Value)> t_sensor)
+      : milliseconds(t_milliseconds), state_object(t_state_object), sensor(t_sensor),
+        next_run(boost::posix_time::microsec_clock::universal_time() 
+            + boost::posix_time::milliseconds(milliseconds))
+    {
+    }
+
+    std::pair<boost::posix_time::ptime, double> get_value()
+    {
+      next_run = boost::posix_time::microsec_clock::universal_time() 
+            + boost::posix_time::milliseconds(milliseconds);
+
+      return std::make_pair(boost::posix_time::microsec_clock::universal_time(),
+          sensor(state_object));
+    }
+  };
+
+  std::map<std::string, Sensor> m_sensors;
+
+  //sensor_manager.add_sensor("CPU", 1000, global_state, function(state) { update_state(state); state["CPU"]; } )
+  void add_sensor(const std::string &t_name, int t_milliseconds, dispatchkit::Boxed_Value t_state_object,
+      boost::shared_ptr<dispatchkit::Proxy_Function> t_func)
+  {
+    m_sensors.insert(
+        std::make_pair(t_name, 
+          Sensor(t_milliseconds, t_state_object, 
+            dispatchkit::build_function_caller<double (dispatchkit::Boxed_Value)>(t_func)
+            )
+          )
+        );
+  }
+
+
+  std::vector<std::pair<std::string, double> > run_sensors()
+  {
+    std::vector<std::pair<std::string, double> > results;
+
+    boost::posix_time::ptime t(boost::posix_time::microsec_clock::universal_time());
+
+    for (std::map<std::string, Sensor>::iterator itr = m_sensors.begin();
+         itr != m_sensors.end();
+         ++itr)
+    {
+      if (itr->second.next_run <= t)
+      {
+        results.push_back(std::make_pair(itr->first, itr->second.get_value().second));
+      }
+    }
+
+    return results;
+  }
+
+};
+
+
+int main(int argc, char *argv[]) {
+
+  chaiscript::ChaiScript_Engine chai;
+
+  Sensor_Manager sensor_manager;
+  chai.get_eval_engine().add_object("sensor_manager", boost::ref(sensor_manager));
+
+  dispatchkit::register_function(chai.get_eval_engine(), &Sensor_Manager::add_sensor, "add_sensor");
+  dispatchkit::register_function(chai.get_eval_engine(), &regex_search, "regex_search");
+  dispatchkit::register_function(chai.get_eval_engine(), &load_text_file, "load_text_file");
+
+
+
+  for (int i = 1; i < argc; ++i) {
+    try {
+      chai.evaluate_file(argv[i]);
+    }
+    catch (std::exception &e) {
+      std::cerr << "Could not open: " << argv[i] << std::endl;
+      exit(1);
+    }
+  }
+
+  while (true)
+  {
+    usleep(1000);
+    std::vector<std::pair<std::string, double> > sensor_data = sensor_manager.run_sensors();
+
+    for (std::vector<std::pair<std::string, double> >::iterator itr = sensor_data.begin();
+         itr != sensor_data.end();
+         ++itr)
+    {
+      std::cout << "Sensor: " << itr->first << " value: " << itr->second << std::endl;
+    }
+  }
+}
+