From 21bc3ef789447c9379644b4ba383521ab84807ef Mon Sep 17 00:00:00 2001 From: ThePhD Date: Thu, 16 Mar 2017 08:51:19 -0400 Subject: [PATCH] update all the examples --- docs/source/api/usertype.rst | 4 + docs/source/tutorial/cxx-in-lua.rst | 2 +- examples/usertype.cpp | 222 ++++++++++++------------ examples/usertype_advanced.cpp | 2 +- examples/usertype_special_functions.cpp | 2 +- 5 files changed, 120 insertions(+), 112 deletions(-) diff --git a/docs/source/api/usertype.rst b/docs/source/api/usertype.rst index 169e103f..048cac52 100644 --- a/docs/source/api/usertype.rst +++ b/docs/source/api/usertype.rst @@ -150,7 +150,11 @@ If you don't specify any constructor options at all and the type is `default_con .. _constructor: +* ``"{name}", constructors`` + - Specify the constructors to be bound under ``name``: list constructors by specifying their function signature with ``class_type(arg0, arg1, ... argN)`` + - If you pass the ``constructors<...>`` argument first when constructing the usertype, then it will automatically be given a ``"{name}"`` of ``"new"`` * ``"{name}", constructors`` + - This syntax is longer and provided for backwards-compatibility: the above argument syntax is shorter and cleaner - ``Type-List-N`` must be a ``sol::types``, where ``Args...`` is a list of types that a constructor takes. Supports overloading by default - If you pass the ``constructors<...>`` argument first when constructing the usertype, then it will automatically be given a ``"{name}"`` of ``"new"`` * ``"{name}", sol::initializers( func1, func2, ... )`` diff --git a/docs/source/tutorial/cxx-in-lua.rst b/docs/source/tutorial/cxx-in-lua.rst index dac47dfb..701ddf69 100644 --- a/docs/source/tutorial/cxx-in-lua.rst +++ b/docs/source/tutorial/cxx-in-lua.rst @@ -110,7 +110,7 @@ To do this, you bind things using the ``new_usertype`` and ``set_usertype`` meth lua.new_usertype( "player", // 3 constructors - sol::constructors, sol::types, sol::types>(), + sol::constructors(), // typical member function that returns a variable "shoot", &player::shoot, diff --git a/examples/usertype.cpp b/examples/usertype.cpp index b29f9e8a..bdb07015 100644 --- a/examples/usertype.cpp +++ b/examples/usertype.cpp @@ -1,109 +1,113 @@ -#include -#include -#include -#include - -struct foo { -private: - std::string name; -public: - foo(std::string name): name(std::string(name)) {} - - void print() { - std::cout << name << '\n'; - } - - int test(int x) { - return name.length() + x; - } -}; - -struct vector { -private: - float x = 0; - float y = 0; -public: - vector() = default; - vector(float x): x(x) {} - vector(float x, float y): x(x), y(y) {} - - bool is_unit() const { - return (x * x + y * y) == 1.f; - } -}; - -struct variables { - bool low_gravity = false; - int boost_level = 0; - -}; - -int main() { - std::cout << "=== usertype example ===" << std::endl; - - sol::state lua; - lua.open_libraries(sol::lib::base, sol::lib::math); - - // the simplest way to create a class is through - // sol::state::new_userdata - // the first template is the class type - // the rest are the constructor parameters - // using new_userdata you can only have one constructor - - - // you must make sure that the name of the function - // goes before the member function pointer - lua.new_usertype("foo", "print", &foo::print, "test", &foo::test); - - // making the class from lua is simple - // same with calling member functions - lua.script("x = foo.new('test')\n" - "x:print()\n" - "y = x:test(10)"); - - auto y = lua.get("y"); - std::cout << y << std::endl; // show 14 - - // if you want a class to have more than one constructor - // the way to do so is through set_userdata and creating - // a userdata yourself with constructor types - - { - // Notice the brace: this means we're in a new scope - // first, define the different types of constructors - sol::constructors, sol::types, sol::types> ctor; - - // the only template parameter is the class type - // the first argument of construction is the name - // second is the constructor types - // then the rest are function name and member function pointer pairs - sol::usertype utype(ctor, "is_unit", &vector::is_unit); - - // then you must register it - lua.set_usertype("vector", utype); - // You can throw away the usertype after you set it: you do NOT - // have to keep it around - // cleanup happens automagically - } - // calling it is the same as new_userdata - - lua.script("v = vector.new()\n" - "v = vector.new(12)\n" - "v = vector.new(10, 10)\n" - "assert(not v:is_unit())\n"); - - // You can even have C++-like member-variable-access - // just pass is public member variables in the same style as functions - lua.new_usertype("variables", "low_gravity", &variables::low_gravity, "boost_level", &variables::boost_level); - - // making the class from lua is simple - // same with calling member functions/variables - lua.script("local vars = variables.new()\n" - "assert(not vars.low_gravity)\n" - "vars.low_gravity = true\n" - "local x = vars.low_gravity\n" - "assert(x)"); - - std::cout << std::endl; - -} +#include +#include +#include +#include + +struct foo { +private: + std::string name; +public: + foo(std::string name): name(std::string(name)) {} + + void print() { + std::cout << name << '\n'; + } + + int test(int x) { + return name.length() + x; + } +}; + +struct vector { +private: + float x = 0; + float y = 0; +public: + vector() = default; + vector(float x): x(x) {} + vector(float x, float y): x(x), y(y) {} + + bool is_unit() const { + return (x * x + y * y) == 1.f; + } +}; + +struct variables { + bool low_gravity = false; + int boost_level = 0; + +}; + +int main() { + std::cout << "=== usertype example ===" << std::endl; + + sol::state lua; + lua.open_libraries(sol::lib::base, sol::lib::math); + + // the simplest way to create a class is through + // sol::state::new_userdata + // the first template is the class type + // the rest are the constructor parameters + // using new_userdata you can only have one constructor + + + // you must make sure that the name of the function + // goes before the member function pointer + lua.new_usertype("foo", "print", &foo::print, "test", &foo::test); + + // making the class from lua is simple + // same with calling member functions + lua.script("x = foo.new('test')\n" + "x:print()\n" + "y = x:test(10)"); + + auto y = lua.get("y"); + std::cout << y << std::endl; // show 14 + + // if you want a class to have more than one constructor + // the way to do so is through set_userdata and creating + // a userdata yourself with constructor types + + { + // Notice the brace: this means we're in a new scope + // first, define the different types of constructors + // notice here that the return type + // on the function-type doesn't exactly matter, + // which allows you to use a shorter class name/void + // if necessary + sol::constructors ctor; + + // the only template parameter is the class type + // the first argument of construction is the name + // second is the constructor types + // then the rest are function name and member function pointer pairs + sol::usertype utype(ctor, "is_unit", &vector::is_unit); + + // then you must register it + lua.set_usertype("vector", utype); + // You can throw away the usertype after you set it: you do NOT + // have to keep it around + // cleanup happens automagically + } + // calling it is the same as new_userdata + + lua.script("v = vector.new()\n" + "v = vector.new(12)\n" + "v = vector.new(10, 10)\n" + "assert(not v:is_unit())\n"); + + // You can even have C++-like member-variable-access + // just pass is public member variables in the same style as functions + lua.new_usertype("variables", "low_gravity", &variables::low_gravity, "boost_level", &variables::boost_level); + + // making the class from lua is simple + // same with calling member functions/variables + lua.script("local vars = variables.new()\n" + "assert(not vars.low_gravity)\n" + "vars.low_gravity = true\n" + "local x = vars.low_gravity\n" + "assert(x)"); + + std::cout << std::endl; + +} diff --git a/examples/usertype_advanced.cpp b/examples/usertype_advanced.cpp index ccbb0edc..cd6de9b5 100644 --- a/examples/usertype_advanced.cpp +++ b/examples/usertype_advanced.cpp @@ -63,7 +63,7 @@ int main() { lua.new_usertype("player", // 3 constructors - sol::constructors, sol::types, sol::types>(), + sol::constructors(), // typical member function that returns a variable "shoot", &player::shoot, diff --git a/examples/usertype_special_functions.cpp b/examples/usertype_special_functions.cpp index 6528b684..44ff93e0 100644 --- a/examples/usertype_special_functions.cpp +++ b/examples/usertype_special_functions.cpp @@ -29,7 +29,7 @@ int main() { lua.open_libraries(); lua.new_usertype("vec", - sol::constructors, sol::types>(), + sol::constructors(), "dot", &dot, "norm", [](const vec& self) { double len = std::sqrt(dot(self, self)); return vec(self.x / len, self.y / len); }, // we use `sol::resolve` because other operator+ can exist