Moving files into new locations

src/callbacktest.cpp

@@ -0,0 +1,63 @@
+#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;
+}
+

src/main.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+
+#include "chaiscript.hpp"
+
+void print_help() {
+    std::cout << "ChaiScript evaluator.  To evaluate and expression, type it and press <enter>." << std::endl;
+    std::cout << "Additionally, you can inspect the runtime system using:" << std::endl;
+    std::cout << "  dump_system() - outputs all functions registered to the system" << std::endl;
+    std::cout << "  dump_object(x) - dumps information about the given symbol" << std::endl;
+}
+
+int main(int argc, char *argv[]) {
+    std::string input;
+    chaiscript::ChaiScript_Engine chai;
+
+    chai.build_eval_system();
+
+    if (argc < 2) {
+        std::cout << "eval> ";
+        std::getline(std::cin, input);
+        while (input != "quit") {
+
+            dispatchkit::Boxed_Value val;
+
+            if (input == "help") {
+                print_help();
+            }
+            else {
+                try {
+                    //First, we evaluate it
+                    val = chai.evaluate_string(input);
+
+                    //Then, we try to print the result of the evaluation to the user
+                    if (val.get_type_info().m_bare_type_info && *(val.get_type_info().m_bare_type_info) != typeid(void)) {
+                        try {
+                            dispatchkit::dispatch(chai.get_eval_engine().get_function("print"), dispatchkit::Param_List_Builder() << val);
+                        }
+                        catch (...) {
+                            //If we can't, do nothing
+                        }
+                    }
+                }
+                catch (chaiscript::Parse_Error &pe) {
+                    std::cout << pe.reason << " in " << pe.filename << " at " << pe.position.line << ", " << pe.position.column << std::endl;
+                }
+                catch (chaiscript::Eval_Error &ee) {
+                    std::cout << ee.reason << std::endl;
+                }
+                catch (std::exception &e) {
+                    std::cout << e.what() << std::endl;
+                }
+            }
+
+            std::cout << "eval> ";
+            std::getline(std::cin, input);
+        }
+    }
+    else {
+        for (int i = 1; i < argc; ++i) {
+            std::string filename(argv[i]);
+            try {
+              dispatchkit::Boxed_Value val = chai.evaluate_file(argv[i]);
+            }
+            catch (chaiscript::Parse_Error &pe) {
+                if (filename != std::string("__EVAL__")) {
+                    std::cout << pe.reason << " in " << pe.filename << " at " << pe.position.line << ", " << pe.position.column << std::endl;
+                }
+                else {
+                    std::cout << pe.reason << std::endl;
+                }
+            }
+            catch (chaiscript::Eval_Error &ee) {
+                if (filename != std::string("__EVAL__")) {
+                    std::cout << ee.reason << " in '" << ee.location->filename << "' at " << ee.location->start.line  << ", " << ee.location->start.column << std::endl;
+                }
+                else {
+                    std::cout << ee.reason << std::endl;
+                }
+            }
+            catch (std::exception &e) {
+                std::cout << e.what() << std::endl;
+            }
+        }
+    }
+}
+

src/sensors.cpp

@@ -0,0 +1,142 @@
+#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;
+    }
+  }
+}
+