Rename scripting_* files to something a bit more appropriate

typelesscpp/boxed_value.hpp

@@ -1,39 +1,39 @@
-#ifndef __scripting_object_hpp__
+#ifndef __boxed_value_hpp__
-#define __scripting_object_hpp__
+#define __boxed_value_hpp__
 
-#include "scripting_type_info.hpp"
+#include "type_info.hpp"
 #include <boost/shared_ptr.hpp>
 #include <boost/any.hpp>
 
 #include <boost/ref.hpp>
 
-class Scripting_Object
+class Boxed_Value
 {
   public:
     template<typename T>
-      explicit Scripting_Object(boost::shared_ptr<T> obj)
+      explicit Boxed_Value(boost::shared_ptr<T> obj)
        : m_type_info(Get_Type_Info<T>()()), m_obj(obj), m_is_ref(false)
       {
       }
 
     template<typename T>
-      explicit Scripting_Object(boost::reference_wrapper<T> obj)
+      explicit Boxed_Value(boost::reference_wrapper<T> obj)
        : m_type_info(Get_Type_Info<T>()()), m_obj(obj), m_is_ref(true)
       {
       }
 
     template<typename T>
-      explicit Scripting_Object(const T& t)
+      explicit Boxed_Value(const T& t)
        : m_type_info(Get_Type_Info<T>()()), m_obj(boost::shared_ptr<T>(new T(t))), m_is_ref(false)
       {
       }
 
-    Scripting_Object(const Scripting_Object &t_so)
+    Boxed_Value(const Boxed_Value &t_so)
       : m_type_info(t_so.m_type_info), m_obj(t_so.m_obj), m_is_ref(t_so.m_is_ref)
     {
     }
 
-    Scripting_Object()
+    Boxed_Value()
       : m_type_info(Get_Type_Info<void>()()), m_is_ref(false)
     {
     }
@@ -64,7 +64,7 @@ class Scripting_Object
 template<typename Result>
 struct Cast_Helper
 {
-  typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Scripting_Object ob)
+  typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
   {
     if (ob.is_ref())
     {
@@ -78,7 +78,7 @@ struct Cast_Helper
 template<typename Result>
 struct Cast_Helper<const Result &>
 {
-  typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Scripting_Object ob)
+  typename boost::reference_wrapper<typename boost::add_const<Result>::type > operator()(Boxed_Value ob)
   {
     if (ob.is_ref())
     {
@@ -92,7 +92,7 @@ struct Cast_Helper<const Result &>
 template<typename Result>
 struct Cast_Helper<Result *>
 {
-  Result *operator()(Scripting_Object ob)
+  Result *operator()(Boxed_Value ob)
   {
     if (ob.is_ref())
     {
@@ -106,7 +106,7 @@ struct Cast_Helper<Result *>
 template<typename Result>
 struct Cast_Helper<Result &>
 {
-  typename boost::reference_wrapper<Result> operator()(Scripting_Object ob)
+  typename boost::reference_wrapper<Result> operator()(Boxed_Value ob)
   {
     if (ob.is_ref())
     {

typelesscpp/boxedcpp.hpp

@@ -8,9 +8,9 @@
 #include <stdexcept>
 #include <vector>
 
-#include "scripting_object.hpp"
+#include "boxed_value.hpp"
-#include "scripting_functions.hpp"
+#include "proxy_functions.hpp"
-#include "scripting_constructors.hpp"
+#include "proxy_constructors.hpp"
 
 class Scripting_System
 {
@@ -18,18 +18,18 @@ class Scripting_System
     template<typename Function>
       void register_function(const Function &func, const std::string &name)
       {
-        m_functions.insert(std::make_pair(name, boost::shared_ptr<Function_Handler>(new Function_Handler_Impl<Function>(func))));
+        m_functions.insert(std::make_pair(name, boost::shared_ptr<Proxy_Function>(new Proxy_Function_Impl<Function>(func))));
       }
 
     template<typename Class>
       void add_object(const std::string &name, const Class &obj)
       {
-        m_objects.insert(std::make_pair(name, Scripting_Object(obj)));
+        m_objects.insert(std::make_pair(name, Boxed_Value(obj)));
       }
 
-    Scripting_Object get_object(const std::string &name) const
+    Boxed_Value get_object(const std::string &name) const
     {
-      std::map<std::string, Scripting_Object>::const_iterator itr = m_objects.find(name);
+      std::map<std::string, Boxed_Value>::const_iterator itr = m_objects.find(name);
       if (itr != m_objects.end())
       {
         return itr->second;
@@ -44,9 +44,9 @@ class Scripting_System
         m_types.insert(std::make_pair(name, &typeid(Type)));
       }
 
-    boost::shared_ptr<Function_Handler> get_function(const std::string &t_name)
+    boost::shared_ptr<Proxy_Function> get_function(const std::string &t_name)
     {
-      std::map<std::string, boost::shared_ptr<Function_Handler> >::const_iterator itr = m_functions.find(t_name);
+      std::map<std::string, boost::shared_ptr<Proxy_Function> >::const_iterator itr = m_functions.find(t_name);
       if (itr != m_functions.end())
       {
         return itr->second;
@@ -56,9 +56,9 @@ class Scripting_System
     }
 
   private:
-    std::map<std::string, Scripting_Object > m_objects;
+    std::map<std::string, Boxed_Value > m_objects;
     std::map<std::string, const std::type_info *> m_types;
-    std::map<std::string, boost::shared_ptr<Function_Handler> > m_functions;
+    std::map<std::string, boost::shared_ptr<Proxy_Function> > m_functions;
 };
 
 #endif 

typelesscpp/proxy_constructors.hpp

@@ -1,8 +1,8 @@
 #include <boost/preprocessor.hpp>
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __scripting_constructors_hpp__
+#ifndef __proxy_constructors_hpp__
-#define __scripting_constructors_hpp__
+#define __proxy_constructors_hpp__
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
@@ -22,7 +22,7 @@ boost::function<boost::shared_ptr<Class> ()> build_constructor()
 }
 
 #define BOOST_PP_ITERATION_LIMITS ( 1, 10 )
-#define BOOST_PP_FILENAME_1 "scripting_constructors.hpp"
+#define BOOST_PP_FILENAME_1 "proxy_constructors.hpp"
 #include BOOST_PP_ITERATE()
 # endif
 #else

typelesscpp/proxy_functions.hpp

@@ -5,11 +5,11 @@
 
 
 #ifndef  BOOST_PP_IS_ITERATING
-#ifndef __scripting_functions_hpp__
+#ifndef __proxy_functions_hpp__
-#define __scripting_functions_hpp__
+#define __proxy_functions_hpp__
 
-#include "scripting_object.hpp"
+#include "boxed_value.hpp"
-#include "scripting_type_info.hpp"
+#include "type_info.hpp"
 #include <string>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
@@ -20,28 +20,28 @@
 template<typename Ret>
 struct Handle_Return
 {
-  Scripting_Object operator()(const boost::function<Ret ()> &f)
+  Boxed_Value operator()(const boost::function<Ret ()> &f)
   {
-    return Scripting_Object(f());
+    return Boxed_Value(f());
   }
 };
 
 template<typename Ret>
 struct Handle_Return<Ret &>
 {
-  Scripting_Object operator()(const boost::function<Ret &()> &f)
+  Boxed_Value operator()(const boost::function<Ret &()> &f)
   {
-    return Scripting_Object(boost::ref(f()));
+    return Boxed_Value(boost::ref(f()));
   }
 };
 
 template<>
 struct Handle_Return<void>
 {
-  Scripting_Object operator()(const boost::function<void ()> &f)
+  Boxed_Value operator()(const boost::function<void ()> &f)
   {
     f();
-    return Scripting_Object();
+    return Boxed_Value();
   }
 };
 
@@ -57,7 +57,7 @@ std::vector<Type_Info> build_param_type_list(const boost::function<Ret ()> &f)
 
 // call_func implementations (variadic)
 template<typename Ret>
-Scripting_Object call_func(const boost::function<Ret ()> &f, const std::vector<Scripting_Object> &params)
+Boxed_Value call_func(const boost::function<Ret ()> &f, const std::vector<Boxed_Value> &params)
 {
   if (params.size() != 0)
   {
@@ -70,7 +70,7 @@ Scripting_Object call_func(const boost::function<Ret ()> &f, const std::vector<S
 
 struct Param_List_Builder
 {
-  Param_List_Builder &operator<<(const Scripting_Object &so)
+  Param_List_Builder &operator<<(const Boxed_Value &so)
   {
     objects.push_back(so);
     return *this;
@@ -79,42 +79,42 @@ struct Param_List_Builder
   template<typename T>
     Param_List_Builder &operator<<(T t)
     {
-      objects.push_back(Scripting_Object(t));
+      objects.push_back(Boxed_Value(t));
       return *this;
     }
 
-  operator const std::vector<Scripting_Object> &() const
+  operator const std::vector<Boxed_Value> &() const
   {
     return objects;
   }
 
-  std::vector<Scripting_Object> objects;
+  std::vector<Boxed_Value> objects;
   
 };
 
 
 #define BOOST_PP_ITERATION_LIMITS ( 1, 10 )
-#define BOOST_PP_FILENAME_1 "scripting_functions.hpp"
+#define BOOST_PP_FILENAME_1 "proxy_functions.hpp"
 #include BOOST_PP_ITERATE()
 
-class Function_Handler
+class Proxy_Function
 {
   public:
-    virtual Scripting_Object operator()(const std::vector<Scripting_Object> &params) = 0;
+    virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params) = 0;
     virtual std::vector<Type_Info> get_param_types() = 0;
 
 };
 
 template<typename Func>
-class Function_Handler_Impl : public Function_Handler
+class Proxy_Function_Impl : public Proxy_Function
 {
   public:
-    Function_Handler_Impl(const Func &f)
+    Proxy_Function_Impl(const Func &f)
       : m_f(f)
     {
     }
 
-    virtual Scripting_Object operator()(const std::vector<Scripting_Object> &params)
+    virtual Boxed_Value operator()(const std::vector<Boxed_Value> &params)
     {
       return call_func(m_f, params);
     }
@@ -146,8 +146,8 @@ std::vector<Type_Info> build_param_type_list(const boost::function<Ret (BOOST_PP
 }
 
 template<typename Ret, BOOST_PP_ENUM_PARAMS(n, typename Param)>
-Scripting_Object call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f, 
+Boxed_Value call_func(const boost::function<Ret (BOOST_PP_ENUM_PARAMS(n, Param))> &f, 
-    const std::vector<Scripting_Object> &params)
+    const std::vector<Boxed_Value> &params)
 {
   if (params.size() != n)
   {

typelesscpp/test.cpp

@@ -4,7 +4,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
 
-#include "scripting_system.hpp"
+#include "boxedcpp.hpp"
 
 struct Test
 {
@@ -69,14 +69,14 @@ int main()
   ss.add_object("d", boost::shared_ptr<double>(new double(10.2)));
   ss.add_object("str", std::string("Hello World"));
 
-  std::vector<Scripting_Object> sos;
+  std::vector<Boxed_Value> sos;
   sos.push_back(ss.get_object("testobj")); 
   sos.push_back(ss.get_object("d"));
 
-  boost::shared_ptr<Function_Handler> method1(ss.get_function("method"));
+  boost::shared_ptr<Proxy_Function> method1(ss.get_function("method"));
   (*method1)(sos);
   (*method1)(sos);
-  Scripting_Object o = (*method1)(sos);
+  Boxed_Value o = (*method1)(sos);
   
   (*ss.get_function("print"))(Param_List_Builder() << ss.get_object("str"));
 
@@ -85,13 +85,13 @@ int main()
 
   std::cout << Cast_Helper<int>()(o) << std::endl;
 
-  (*ss.get_function("voidfunc"))(std::vector<Scripting_Object>());
+  (*ss.get_function("voidfunc"))(std::vector<Boxed_Value>());
 
-  std::vector<Scripting_Object> sos3;
+  std::vector<Boxed_Value> sos3;
   sos3.push_back(ss.get_object("testobj2"));
   (*ss.get_function("show_message"))(sos3);
 
-  Scripting_Object stringref = (*ss.get_function("get_message"))(sos3);
+  Boxed_Value stringref = (*ss.get_function("get_message"))(sos3);
 
   std::string &sr = Cast_Helper<std::string &>()(stringref);
   sr = "Bob Updated The message";

typelesscpp/type_info.hpp

@@ -1,5 +1,5 @@
-#ifndef __scripting_type_info_hpp__
+#ifndef __type_info_hpp__
-#define __scripting_type_info_hpp__
+#define __type_info_hpp__
 
 #include <boost/type_traits.hpp>