From a5e24b4fa2ef13eaee0647e230c69956d615ce86 Mon Sep 17 00:00:00 2001 From: Rapptz Date: Tue, 21 Jul 2015 19:26:35 -0400 Subject: [PATCH] Fix userdata -> usertype in examples. --- README.md | 2 +- bootstrap.py | 2 +- examples/{userdata.cpp => usertype.cpp} | 213 ++++++++++++------------ 3 files changed, 111 insertions(+), 106 deletions(-) rename examples/{userdata.cpp => usertype.cpp} (75%) diff --git a/README.md b/README.md index 5daebd20..ce908c98 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ struct vars { int main() { sol::state lua; - lua.new_userdata("vars", "boop", &vars::boop); + lua.new_usertype("vars", "boop", &vars::boop); lua.script("beep = vars.new()\n" "beep.boop = 1"); assert(lua.get("beep").boop == 1); diff --git a/bootstrap.py b/bootstrap.py index 1d6a0b3b..ce6750eb 100755 --- a/bootstrap.py +++ b/bootstrap.py @@ -50,7 +50,7 @@ args = parser.parse_args() # general variables include = [ '.', os.path.join('Catch', 'include')] depends = [] -cxxflags = [ '-Wall', '-Wextra', '-pedantic', '-pedantic-errors', '-std=c++11' ] +cxxflags = [ '-Wall', '-Wextra', '-pedantic', '-pedantic-errors', '-std=c++11', '-Wno-unused-variable' ] ldflags = [] script_dir = os.path.dirname(os.path.realpath(sys.argv[0])) sol_dir = os.path.join(script_dir, 'sol') diff --git a/examples/userdata.cpp b/examples/usertype.cpp similarity index 75% rename from examples/userdata.cpp rename to examples/usertype.cpp index 96d269f4..15457590 100644 --- a/examples/userdata.cpp +++ b/examples/usertype.cpp @@ -1,104 +1,109 @@ -#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() { - 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_userdata("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"); - assert(y == 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::userdata udata("vector", ctor, "is_unit", &vector::is_unit); - - // then you must register it - lua.set_userdata(udata); - // You can throw away the userdata 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_userdata("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)"); -} +#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() { + sol::state lua; + lua.open_libraries(sol::lib::base, sol::lib::math); + + // the simplest way to create a class is through + // sol::state::new_usertype + // the first template is the class type + // the rest are the constructor parameters + // using new_usertype 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"); + assert(y == 14); + + // if you want a class to have more than one constructor + // the way to do so is through set_usertype and creating + // a usertype 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 udata(ctor, "is_unit", &vector::is_unit); + + // then you must register it + // by default, the registered name is done through demangling of T in sol::usertype + // using the demangling API provided by the compiler + // if you don't want to use the unmangled name, you can provide your own name like so: + // lua.set_usertype("vector", udata); + lua.set_usertype(udata); + + // 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_usertype + + 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)"); +}