2 files changed, 192 insertions, 0 deletions
diff --git a/deps/sol2/examples/interop/kaguya/CMakeLists.txt b/deps/sol2/examples/interop/kaguya/CMakeLists.txt
new file mode 100644
index 0000000..0b01061
--- /dev/null
+++ b/deps/sol2/examples/interop/kaguya/CMakeLists.txt
@@ -0,0 +1,68 @@
+# # # # sol3
+# The MIT License (MIT)
+#
+# Copyright (c) 2013-2019 Rapptz, ThePhD, and contributors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# # # sol3 interop Examples - kaguya
+
+find_package(KaguyaBuild)
+
+function (make_kaguya_interop_example target_library example_suffix)
+	set(example_name kaguya_interop_example)
+	set(example_name "${example_name}${example_suffix}")
+	
+	add_executable(${example_name} source/kaguya.cpp)
+	target_link_libraries(${example_name} 
+		PRIVATE ${LUA_LIBRARIES} ${KAGUYA_LIBRARIES} 
+		${target_library} sol2::assert)
+	
+	if (MSVC)
+		target_compile_options(${example_name}
+			PRIVATE /W1 /std:c++latest /EHsc "$<$<CONFIG:Debug>:/MDd>"
+			"$<$<CONFIG:Release>:/MD>"
+			"$<$<CONFIG:RelWithDebInfo>:/MD>"
+			"$<$<CONFIG:MinSizeRel>:/MD>")
+		target_compile_definitions(${example_name}
+			PRIVATE UNICODE _UNICODE 
+			_CRT_SECURE_NO_WARNINGS _CRT_SECURE_NO_DEPRECATE)
+	else()
+		target_compile_options(${example_name}
+			PRIVATE -std=c++1z -w
+			-Wno-unknown-warning -Wno-unknown-warning-option)
+	endif()
+
+	if (CMAKE_DL_LIBS)
+		target_link_libraries(${example_name} PRIVATE ${CMAKE_DL_LIBS})
+	endif()
+	
+	if (SOL2_TESTS_INTEROP_EXAMPLES)
+		add_test(NAME ${example_name} COMMAND ${example_name})
+	endif()
+endfunction()
+
+if (SOL2_INTEROP_EXAMPLES)
+	make_kaguya_interop_example(sol2::sol2 "")
+endif()
+if (SOL2_INTEROP_EXAMPLES_SINGLE)
+	make_kaguya_interop_example(sol2::sol2_single ".single")
+endif()
+if (SOL2_INTEROP_EXAMPLES_SINGLE_GENERATED)
+	make_kaguya_interop_example(sol2::sol2_single_generated ".single.generated")
+endif()
diff --git a/deps/sol2/examples/interop/kaguya/source/kaguya.cpp b/deps/sol2/examples/interop/kaguya/source/kaguya.cpp
new file mode 100644
index 0000000..ce81ff8
--- /dev/null
+++ b/deps/sol2/examples/interop/kaguya/source/kaguya.cpp
@@ -0,0 +1,124 @@
+#include <kaguya/kaguya.hpp>
+
+#define SOL_ALL_SAFETIES_ON 1
+#define SOL_ENABLE_INTEROP 1 // MUST be defined to use interop features
+#include <sol/sol.hpp>
+
+#include <iostream>
+#include <assert.hpp>
+
+// kaguya code lifted from README.md,
+// written by satoren:
+// https://github.com/satoren/kaguya
+// Copyright satoren
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+struct ABC {
+	ABC()
+	: v_(0) {
+	}
+	ABC(int value)
+	: v_(value) {
+	}
+	int value() const {
+		return v_;
+	}
+	void setValue(int v) {
+		v_ = v;
+	}
+	void overload1() {
+		std::cout << "call overload1" << std::endl;
+	}
+	void overload2(int) {
+		std::cout << "call overload2" << std::endl;
+	}
+
+private:
+	int v_;
+};
+
+template <typename T, typename Handler>
+inline bool sol_lua_interop_check(sol::types<T>, lua_State* L, int relindex, sol::type index_type, Handler&& handler, sol::stack::record& tracking) {
+	// just marking unused parameters for no compiler warnings
+	(void)index_type;
+	(void)handler;
+	// using 1 element
+	tracking.use(1);
+	int index = lua_absindex(L, relindex);
+	// use kaguya's own detail wrapper check to see if it's correct
+	bool is_correct_type = kaguya::detail::object_wrapper_type_check(L, index);
+	return is_correct_type;
+}
+
+template <typename T>
+inline std::pair<bool, T*> sol_lua_interop_get(sol::types<T>, lua_State* L, int relindex, void* unadjusted_pointer, sol::stack::record& tracking) {
+	// you may not need to specialize this method every time:
+	// some libraries are compatible with sol2's layout
+
+	// kaguya's storage of data is incompatible with sol's
+	// it stores the data directly in the pointer, not a pointer inside of the `void*`
+	// therefore, leave the raw userdata pointer as-is,
+	// if it's of the right type
+	int index = lua_absindex(L, relindex);
+	if (!kaguya::detail::object_wrapper_type_check(L, index)) {
+		return { false, nullptr };
+	}
+	// using 1 element
+	tracking.use(1);
+	kaguya::ObjectWrapperBase* base = kaguya::object_wrapper(L, index);
+	return { true, static_cast<T*>(base->get()) };
+}
+
+void register_sol_stuff(lua_State* L) {
+	// grab raw state and put into state_view
+	// state_view is cheap to construct
+	sol::state_view lua(L);
+	// bind and set up your things: everything is entirely self-contained
+	lua["f"] = sol::overload(
+		[](ABC& from_kaguya) {
+			std::cout << "calling 1-argument version with kaguya-created ABC { " << from_kaguya.value() << " }" << std::endl;
+			c_assert(from_kaguya.value() == 24);
+		},
+		[](ABC& from_kaguya, int second_arg) {
+			std::cout << "calling 2-argument version with kaguya-created ABC { " << from_kaguya.value() << " } and integer argument of " << second_arg << std::endl;
+			c_assert(from_kaguya.value() == 24);
+			c_assert(second_arg == 5);
+		});
+}
+
+void check_with_sol(lua_State* L) {
+	sol::state_view lua(L);
+	ABC& obj = lua["obj"];
+	(void)obj;
+	c_assert(obj.value() == 24);
+}
+
+int main(int, char* []) {
+
+	std::cout << "=== interop example (kaguya) ===" << std::endl;
+	std::cout << "(code lifted from kaguya's README examples: https://github.com/satoren/kaguya)" << std::endl;
+
+	kaguya::State state;
+
+	state["ABC"].setClass(kaguya::UserdataMetatable<ABC>()
+						  .setConstructors<ABC(), ABC(int)>()
+						  .addFunction("get_value", &ABC::value)
+						  .addFunction("set_value", &ABC::setValue)
+						  .addOverloadedFunctions("overload", &ABC::overload1, &ABC::overload2)
+						  .addStaticFunction("nonmemberfun", [](ABC* self, int) { return 1; }));
+
+
+	register_sol_stuff(state.state());
+
+	state.dostring(R"(
+obj = ABC.new(24)
+f(obj) -- call 1 argument version
+f(obj, 5) -- call 2 argument version
+)");
+
+	check_with_sol(state.state());
+
+	return 0;
+}
+\ No newline at end of file