From 377472a6dd2c9bdff4d5667f5789c49aee2abb4c Mon Sep 17 00:00:00 2001 From: Miodrag Milanovic Date: Fri, 7 Oct 2016 14:43:09 +0200 Subject: Added sol2 header only library as future replacement for luabridge (nw) --- 3rdparty/sol2/docs/source/api/make_reference.rst | 26 ++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 3rdparty/sol2/docs/source/api/make_reference.rst (limited to '3rdparty/sol2/docs/source/api/make_reference.rst') diff --git a/3rdparty/sol2/docs/source/api/make_reference.rst b/3rdparty/sol2/docs/source/api/make_reference.rst new file mode 100644 index 00000000000..cd39b5a31d9 --- /dev/null +++ b/3rdparty/sol2/docs/source/api/make_reference.rst @@ -0,0 +1,26 @@ +make_object/make_reference +========================== +Create a value on the Lua stack and return it +--------------------------------------------- + +.. code-block:: cpp + :caption: function: make_reference + :name: make-reference + + template + R make_reference(lua_State* L, T&& value); + template + R make_reference(lua_State* L, Args&&... args); + +Makes an ``R`` out of the value. The first overload deduces the type from the passed in argument, the second allows you to specify a template parameter and forward any relevant arguments to ``sol::stack::push``. The type figured out for ``R`` is what is referenced from the stack. This allows you to request arbitrary pop-able types from Sol and have it constructed from ``R(lua_State* L, int stack_index)``. If the template boolean ``should_pop`` is ``true``, the value that was pushed will be popped off the stack. It defaults to popping, but if it encounters a type such as :doc:`sol::stack_reference` (or any of its typically derived types in Sol), it will leave the pushed values on the stack. + +.. code-block:: cpp + :caption: function: make_object + :name: make-object + + template + object make_object(lua_State* L, T&& value); + template + object make_object(lua_State* L, Args&&... args); + +Makes an object out of the value. It pushes it onto the stack, then pops it into the returned ``sol::object``. The first overload deduces the type from the passed in argument, the second allows you to specify a template parameter and forward any relevant arguments to ``sol::stack::push``. The implementation essentially defers to :ref:`sol::make_reference` with the specified arguments, ``R == object`` and ``should_pop == true``. It is preferred that one uses the :ref:`in_place object constructor instead`, since it's probably easier to deal with, but both versions will be supported for forever, since there's really no reason not to and people already have dependencies on ``sol::make_object``. -- cgit v1.2.3-70-g09d2