inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/include/story_ptr.h

@@ -0,0 +1,233 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "system.h"
+
+namespace ink::runtime
+{
+namespace internal
+{
+	/** @private */
+	struct ref_block {
+		ref_block()
+		    : references(0)
+		    , valid(true)
+		{
+		}
+
+		size_t references;
+		bool   valid;
+
+		static void remove_reference(ref_block*&);
+	};
+
+	/** @private */
+	class story_ptr_base
+	{
+	protected:
+		/** construct a new pointer with new instance block */
+		story_ptr_base(internal::ref_block* story);
+		/** construct a new pointer with existing instance block */
+		story_ptr_base(internal::ref_block* story, internal::ref_block* instance);
+		/** construct a new pointer basedd on existing story pointer */
+		story_ptr_base(const story_ptr_base&);
+
+		story_ptr_base& operator=(const story_ptr_base&) = delete;
+
+		/** increases reference count */
+		void add_reference();
+		/** decreses reference count
+		 * @retval true if count reaches zero and object was removed
+		 */
+		bool remove_reference();
+
+		/** switch lifetime block */
+		void set(const story_ptr_base& other);
+
+		/** checks if pointer is still alive */
+		inline bool is_valid() const
+		{
+			return _story_block != nullptr && _instance_block != nullptr && _story_block->valid
+			    && _instance_block->valid;
+		}
+
+		/** checks if story still exists */
+		inline bool is_story_valid() const { return _story_block != nullptr && _story_block->valid; }
+
+	private:
+		// reference block for the parent story
+		ref_block* _story_block;
+
+		// reference block for this pointer
+		ref_block* _instance_block;
+	};
+} // namespace internal
+
+/**
+ * Pointer wrapper to an object whose lifetime is tied to a story object.
+ *
+ * A shared pointer whose lifetime is also tied to the lifetime of the parent
+ * story object. The referenced object will live until either
+ * 1) There are no more story_ptr's pointing to this object
+ * 2) The story object which owns this object dies
+ *
+ * @see story_interface
+ * @see runner_interface
+ * @see globals_interface
+ */
+template<typename T>
+class story_ptr : public internal::story_ptr_base
+{
+public:
+	/** constructor. internal use only.
+	 * @private
+	 */
+	story_ptr(T* ptr, internal::ref_block* story)
+	    : story_ptr_base(story)
+	    , _ptr(ptr)
+	{
+		add_reference();
+	}
+
+	/** casting constructor. internal use only
+	 * @private
+	 */
+	template<typename U>
+	story_ptr(T* ptr, const story_ptr<U>& other)
+	    : story_ptr_base(other)
+	    , _ptr(ptr)
+	{
+		add_reference();
+	}
+
+	/** pointer constructor. for nullptr only.
+	 * @param ptr will be ignored, should be nullptr
+	 */
+	story_ptr(T* ptr)
+	    : story_ptr_base(nullptr, nullptr)
+	    , _ptr(nullptr)
+	{
+		inkAssert(ptr == nullptr, "can not create story_ptr from existing pointer!");
+	}
+
+	// null constructor
+	story_ptr()
+	    : story_ptr_base(nullptr, nullptr)
+	    , _ptr(nullptr)
+	{
+	}
+
+	// destructor
+	~story_ptr();
+
+	// == copy methods ==
+	/** copy constructor
+	 * @param oth
+	 */
+	story_ptr(const story_ptr<T>& oth);
+	/** copy assigment operator
+	 * @param oth
+	 */
+	story_ptr<T>& operator=(const story_ptr<T>& oth);
+
+	// == casting ==
+	/** pointer cast while keeping ref count
+	 * @tparam U new pointer type, valid cast form T to U must be available
+	 */
+	template<typename U>
+	story_ptr<U> cast()
+	{
+		// if cast fails, return null
+#ifdef INK_ENABLE_UNREAL
+		// Unreal disables RTTI
+		U* casted = reinterpret_cast<U*>(_ptr);
+#else
+		U* casted = dynamic_cast<U*>(_ptr);
+#endif
+		if (casted == nullptr)
+			return nullptr;
+
+		// create new pointer with casted value but same instance blocks
+		return story_ptr<U>(casted, *this);
+	}
+
+	// == equality ==
+	/** implement operator== */
+	inline bool operator==(const story_ptr<T>& other) { return _ptr == other._ptr; }
+
+	// == validity ==
+	/** checks if optional contains a value */
+	bool is_valid() const { return story_ptr_base::is_valid() && _ptr; }
+
+	/** auto cast to bool with value from @ref #is_valid() */
+	inline operator bool() const { return is_valid(); }
+
+	// === dereference operators ==
+	/** access value as ptr
+	 * @retval nullptr if value is not @ref #is_valid() "valid"
+	 */
+	inline T* get() { return is_valid() ? _ptr : nullptr; }
+
+	/** access value as ptr
+	 * @retval nullptr if value is not @ref #is_valid() "valid"
+	 */
+	inline const T* get() const { return is_valid() ? _ptr : nullptr; }
+
+	/** implement operator-> */
+	inline T* operator->() { return get(); }
+
+	/** implement operator-> */
+	inline const T* operator->() const { return get(); }
+
+	/** implement operator* */
+	inline T& operator*() { return *get(); }
+
+	/** implement operator* */
+	inline const T& operator*() const { return *get(); }
+
+private:
+	T* _ptr;
+};
+
+template<typename T>
+story_ptr<T>::~story_ptr()
+{
+	if (remove_reference()) {
+		delete _ptr;
+		_ptr = nullptr;
+	}
+}
+
+template<typename T>
+story_ptr<T>::story_ptr(const story_ptr<T>& other)
+    : story_ptr_base(other)
+    , _ptr(other._ptr)
+{
+	add_reference();
+}
+
+template<typename T>
+story_ptr<T>& story_ptr<T>::operator=(const story_ptr<T>& other)
+{
+	// Clear out any old data
+	if (remove_reference()) {
+		delete _ptr;
+		_ptr = nullptr;
+	}
+
+	// Set pointers
+	set(other);
+	_ptr = other._ptr;
+
+	// initialize
+	add_reference();
+
+	// return reference to self
+	return *this;
+}
+} // namespace ink::runtime

data/ext/inkcpp_rb/inkcpp/inkcpp/include/traits.h

@@ -0,0 +1,270 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "config.h"
+#include "system.h"
+
+#ifdef INK_ENABLE_STL
+#	include <string>
+#endif
+
+/** Util templates and implimentation of STL if STL is not available */
+namespace ink::runtime::internal
+{
+template<typename... Ts>
+constexpr size_t sizeof_largest_type()
+{
+	size_t ret = 0;
+	return ((ret = sizeof(Ts) > ret ? sizeof(Ts) : ret), ...);
+}
+
+template<unsigned int N, typename Arg, typename... Args>
+struct get_ith_type : /** @cond */ get_ith_type<N - 1, Args...> /** @endcond */ { /** @cond */
+};
+
+template<typename Arg, typename... Args>
+struct get_ith_type<0, Arg, Args...> {
+	/** @endcond */
+	using type = Arg;
+};
+
+// constant and is_same from http://www.cppreference.com
+template<typename T, T v>
+struct constant {
+	static constexpr T value = v;
+	typedef T          value_type;
+	typedef constant   type; // using injected-class-name
+
+	constexpr operator value_type() const noexcept { return value; }
+
+	constexpr value_type operator()() const noexcept { return value; } // since c++14
+};
+
+struct false_type : constant<bool, false> {
+};
+
+struct true_type : constant<bool, true> {
+};
+
+template<typename B>
+true_type test_ptr_conv(const volatile B*);
+template<typename>
+false_type test_ptr_conv(const volatile void*);
+template<typename B, typename D>
+auto test_is_base_of(int) -> decltype(test_ptr_conv<B>(static_cast<D*>(nullptr)));
+
+// template<typename, typename> /// FIXME: needed?
+// auto test_is_base_of(...) -> true_type;
+
+template<class Base, class Derived>
+struct is_base_of : constant<bool, decltype(test_is_base_of<Base, Derived>(0))::value> {
+};
+
+template<class T, class U>
+struct is_same : false_type {
+};
+
+template<class T>
+struct is_same<T, T> : true_type {
+};
+
+template<typename T>
+struct is_pointer : false_type {
+};
+
+template<typename T>
+struct is_pointer<T*> : true_type {
+};
+
+template<class T>
+struct remove_cv {
+	typedef T type;
+};
+
+template<class T>
+struct remove_cv<const T> {
+	typedef T type;
+};
+
+template<class T>
+struct remove_cv<volatile T> {
+	typedef T type;
+};
+
+template<class T>
+struct remove_cv<const volatile T> {
+	typedef T type;
+};
+
+template<class T>
+struct remove_cvref {
+	typedef std::remove_cv_t<std::remove_reference_t<T>> type;
+};
+
+// == string testing (from me) ==
+
+template<typename T>
+struct is_string : false_type {
+};
+
+template<typename T>
+struct is_string<T&> : is_string<T> {
+};
+
+template<typename T>
+struct is_string<const T> : is_string<T> {
+};
+
+template<typename T>
+struct is_string<const T*> : is_string<T*> {
+};
+
+template<typename T>
+struct string_handler {
+};
+
+template<typename T>
+struct string_handler<const T> : string_handler<T> {
+};
+
+template<typename T>
+struct string_handler<const T*> : string_handler<T*> {
+};
+
+template<typename T>
+struct string_handler<T&> : string_handler<T> {
+};
+
+#define MARK_AS_STRING(TYPE, LEN, SRC)                                            \
+	template<>                                                                    \
+	struct is_string<TYPE> : constant<bool, true> {                               \
+	};                                                                            \
+	template<>                                                                    \
+	struct string_handler<TYPE> {                                                 \
+		static size_t length(const TYPE& x) { return static_cast<size_t>(LEN); }  \
+		static void   src_copy(const TYPE& x, char* output)                       \
+		{                                                                         \
+			[&output](const char* src) {                                          \
+				while (*src != '\0')                                              \
+					*(output++) = *(src++);                                       \
+				*output = 0;                                                      \
+			}(SRC);                                                               \
+		}                                                                         \
+	}
+
+inline size_t c_str_len(const char* c)
+{
+	const char* i = c;
+	while (*i != 0)
+		i++;
+	return i - c;
+}
+
+MARK_AS_STRING(char*, c_str_len(x), x);
+#ifdef INK_ENABLE_STL
+MARK_AS_STRING(std::string, x.size(), x.c_str());
+#endif
+#ifdef INK_ENABLE_UNREAL
+MARK_AS_STRING(FString, x.Len(), TCHAR_TO_UTF8(*x));
+#endif
+
+#undef MARK_AS_STRING
+
+// function_traits from https://functionalcpp.wordpress.com/2013/08/05/function-traits/
+
+template<class F>
+struct function_traits;
+
+// function pointer
+template<class R, class... Args>
+struct function_traits<R (*)(Args...)> : public function_traits<R(Args...)> {
+};
+
+template<class R, class... Args>
+struct function_traits<R(Args...)> {
+	using return_type = R;
+
+	static constexpr unsigned int arity = sizeof...(Args);
+
+	template<unsigned int N>
+	struct argument {
+		static_assert(N < arity, "error: invalid parameter index.");
+		using type = typename get_ith_type<N, Args...>::type;
+	};
+};
+
+// member function pointer
+template<class C, class R, class... Args>
+struct function_traits<R (C::*)(Args...)> : public function_traits<R(C&, Args...)> {
+};
+
+// const member function pointer
+template<class C, class R, class... Args>
+struct function_traits<R (C::*)(Args...) const> : public function_traits<R(C&, Args...)> {
+};
+
+// member object pointer
+template<class C, class R>
+struct function_traits<R(C::*)> : public function_traits<R(C&)> {
+};
+
+// functor
+template<class F>
+struct function_traits {
+private:
+	using call_type = function_traits<decltype(&F::operator())>;
+
+public:
+	using return_type = typename call_type::return_type;
+
+	static constexpr unsigned int arity = call_type::arity - 1;
+
+	template<unsigned int N>
+	struct argument {
+		static_assert(N < arity, "error: invalid parameter index.");
+		using type = typename call_type::template argument<N + 1>::type;
+	};
+};
+
+// from https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
+// using aliases for cleaner syntax
+template<class T>
+using Invoke = typename T::type;
+
+template<unsigned...>
+struct seq {
+	using type = seq;
+};
+
+template<class S1, class S2>
+struct concat;
+
+template<unsigned... I1, unsigned... I2>
+struct concat<seq<I1...>, seq<I2...>> : seq<I1..., (sizeof...(I1) + I2)...> {
+};
+
+template<class S1, class S2>
+using Concat = Invoke<concat<S1, S2>>;
+
+template<unsigned N>
+struct gen_seq;
+template<unsigned N>
+using GenSeq = Invoke<gen_seq<N>>;
+
+template<unsigned N>
+struct gen_seq : Concat<GenSeq<N / 2>, GenSeq<N - N / 2>> {
+};
+
+template<>
+struct gen_seq<0> : seq<> {
+};
+
+template<>
+struct gen_seq<1> : seq<0> {
+};
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/include/types.h

@@ -0,0 +1,169 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "list.h"
+#include "story_ptr.h"
+#include "system.h"
+
+namespace ink::runtime
+{
+class globals_interface;
+class runner_interface;
+class snapshot;
+
+/** alias for an managed @ref ink::runtime::globals_interface pointer */
+using globals = story_ptr<globals_interface>;
+/** alias for an managed @ref ink::runtime::runner_interface pointer */
+using runner  = story_ptr<runner_interface>;
+/** alias for @ref ink::runtime::list_interface pointer */
+using list    = list_interface*;
+
+/** A Ink variable
+ *
+ * Used for accassing, writing and observing global variables
+ * @ref ink::runtime::globals_interface::get()
+ * @ref ink::runtime::globals_interface::set()
+ * @ref ink::runtime::globals_interface::observe()
+ *
+ * and for the execution of extern functions
+ * @ref ink::runtime::runner_interface::bind()
+ */
+struct value {
+private:
+	union {
+		bool        v_bool;
+		uint32_t    v_uint32;
+		int32_t     v_int32;
+		const char* v_string;
+		float       v_float;
+		list        v_list;
+	};
+
+public:
+	/** Type labels for @ref ink::runtime::value  */
+	enum class Type {
+		Bool,   ///< containing bool
+		Uint32, ///< containing uint32_t
+		Int32,  ///< containing int32_t
+		String, ///< contaning a const char*
+		Float,  ///< containing a float
+		List    ///< containing a @ref list_interface
+	} type;   ///< Label of type currently contained in @ref value
+
+	value()
+	    : v_int32{0}
+	    , type{Type::Int32}
+	{
+	}
+
+	///@{
+	/** Construct value from corresponding type */
+	value(bool v)
+	    : v_bool{v}
+	    , type{Type::Bool}
+	{
+	}
+
+	value(uint32_t v)
+	    : v_uint32{v}
+	    , type{Type::Uint32}
+	{
+	}
+
+	value(int32_t v)
+	    : v_int32{v}
+	    , type{Type::Int32}
+	{
+	}
+
+	value(const char* v)
+	    : v_string{v}
+	    , type{Type::String}
+	{
+	}
+
+	value(float v)
+	    : v_float{v}
+	    , type{Type::Float}
+	{
+	}
+
+	value(list_interface* list)
+	    : v_list{list}
+	    , type{Type::List}
+	{
+	}
+
+	value(const value& v)
+	    : type{v.type}
+	{
+		switch (type) {
+			case Type::Bool: v_bool = v.v_bool; break;
+			case Type::Uint32: v_uint32 = v.v_uint32; break;
+			case Type::Int32: v_int32 = v.v_int32; break;
+			case Type::String: v_string = v.v_string; break;
+			case Type::Float: v_float = v.v_float; break;
+			case Type::List: v_list = v.v_list; break;
+		}
+	}
+
+	/// @}
+
+	/** Get value to corresponding type
+	 * @tparam Ty #Type label of type to get
+	 * @attention behavior if undefined if Ty != value.type
+	 */
+	template<Type Ty>
+	const auto& get() const
+	{
+		static_assert(Ty != Ty, "No value getter for the selected type");
+	}
+};
+
+/** access #value::Type::Bool value */
+template<>
+inline const auto& value::get<value::Type::Bool>() const
+{
+	return v_bool;
+}
+
+/** access #value::Type::Uint32 value */
+template<>
+inline const auto& value::get<value::Type::Uint32>() const
+{
+	return v_uint32;
+}
+
+/** access #value::Type::Int32 value */
+template<>
+inline const auto& value::get<value::Type::Int32>() const
+{
+	return v_int32;
+}
+
+/** access #value::Type::String value */
+template<>
+inline const auto& value::get<value::Type::String>() const
+{
+	return v_string;
+}
+
+/** access #value::Type::Float value */
+template<>
+inline const auto& value::get<value::Type::Float>() const
+{
+	return v_float;
+}
+
+/** access #value::Type::List value */
+template<>
+inline const auto& value::get<value::Type::List>() const
+{
+	return v_list;
+}
+} // namespace ink::runtime