inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/tuple.hpp

@@ -0,0 +1,151 @@
+/* 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
+
+/// very basic flat tuple implementation, only use for trivial data types.
+
+#include "traits.h"
+
+namespace ink::runtime::internal
+{
+namespace tuple_internal
+{
+	/// data member of tuple
+	template<size_t I, typename T>
+	class tuple_leaf
+	{
+	public:
+		tuple_leaf()
+		    : _value(){};
+
+		template<typename U>
+		explicit tuple_leaf(U&& u)
+		    : _value(std::forward<U>(u))
+		{
+		}
+
+		T& get() { return _value; }
+
+		const T& get() const { return _value; }
+
+	private:
+		T _value;
+		tuple_leaf(const tuple_leaf& tl)         = delete;
+		tuple_leaf& operator=(const tuple_leaf&) = delete;
+	};
+
+	// handle indexing
+	template<size_t... Is>
+	struct tuple_indexes {
+	};
+
+	// create tuple_indexes in [Start,End[
+	template<size_t End, size_t Start = 0, size_t... Is>
+	struct make_tuple_indexes {
+		using type = typename make_tuple_indexes<End, Start + 1, Is..., Start>::type;
+	};
+
+	template<size_t End, size_t... Is>
+	struct make_tuple_indexes<End, End, Is...> {
+		using type = tuple_indexes<Is...>;
+	};
+
+	/// get the index of first appearance of an type in tuple
+	template<typename T, size_t I, typename U, typename... Tys>
+	struct type_index_imp : type_index_imp<T, I + 1, Tys...> {
+	};
+
+	template<typename T, size_t I, typename... Tys>
+	struct type_index_imp<T, I, T, Tys...> {
+		static constexpr size_t value = I;
+	};
+
+	template<typename T, typename... Tys>
+	constexpr size_t type_index = type_index_imp<T, 0, Tys...>::value;
+
+
+	/// implementation class to extract indices
+	template<typename Indexes, typename... Tys>
+	struct tuple_imp;
+
+	template<size_t... Is, typename... Tys>
+	struct tuple_imp<tuple_indexes<Is...>, Tys...> : public tuple_leaf<Is, Tys>... {
+		template<typename... Us>
+		tuple_imp(Us&&... us)
+		    : tuple_leaf<Is, Tys>(std::forward<Us>(us))...
+		{
+			static_assert(
+			    sizeof...(Us) == sizeof...(Tys),
+			    "Tuple must be initialized with same amount of arguments"
+			    ", then types!"
+			);
+		}
+	};
+} // namespace tuple_internal
+
+/// minimal tuple class, only for simple data types!
+/// flat tuple implementation
+template<typename... Tys>
+class tuple
+    : public tuple_internal::tuple_imp<
+          typename tuple_internal::make_tuple_indexes<sizeof...(Tys)>::type, Tys...>
+{
+	using base = tuple_internal::tuple_imp<
+	    typename tuple_internal::make_tuple_indexes<sizeof...(Tys)>::type, Tys...>;
+	using this_type = tuple<Tys...>;
+
+public:
+	template<size_t I>
+	using element_type = typename get_ith_type<I, Tys...>::type;
+	template<typename T>
+	static constexpr size_t type_index = tuple_internal::type_index<T, Tys...>;
+
+	template<typename... Us>
+	tuple(Us&&... us)
+	    : base(std::forward<Us>(us)...)
+	{
+	}
+};
+
+/// access tuple element by index
+template<size_t I, typename T>
+constexpr const auto& get(const T& t)
+{
+	return static_cast<const tuple_internal::tuple_leaf<I, typename T::template element_type<I>>&>(t)
+	    .get();
+};
+
+/// access tuple element by type. First of this type
+template<typename T, typename Tuple>
+constexpr const T& get(const Tuple& t)
+{
+	return get<Tuple::template type_index<T>, Tuple>(t);
+};
+
+template<>
+class tuple<>
+{
+public:
+	tuple() {}
+};
+
+/// check if tuple contains type
+template<typename T, typename Tuple>
+struct has_type;
+
+template<typename T>
+struct has_type<T, tuple<>> : false_type {
+};
+
+template<typename T, typename U, typename... Tys>
+struct has_type<T, tuple<U, Tys...>> : has_type<T, tuple<Tys...>> {
+};
+
+template<typename T, typename... Tys>
+struct has_type<T, tuple<T, Tys...>> : true_type {
+};
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/value.cpp

@@ -0,0 +1,279 @@
+/* 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.
+ */
+#include "value.h"
+
+#include "list_impl.h"
+#include "output.h"
+#include "list_table.h"
+#include "string_utils.h"
+#include "string_table.h"
+#include "system.h"
+
+namespace ink::runtime::internal
+{
+
+template<value_type = value_type::OP_BEGIN>
+bool truthy_impl(const value& v, const list_table& lists);
+
+template<>
+bool truthy_impl<value_type::OP_END>(const value& v, const list_table& lists)
+{
+	inkFail("Type was not found in operational types or it has no conversion to boolean");
+	return false;
+}
+
+template<>
+bool truthy_impl<value_type::string>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::string) {
+		// if string is not empty
+		return *v.get<value_type::string>().str != 0;
+	} else {
+		return truthy_impl<value_type::string + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::list_flag>(const value& v, const list_table& lists)
+{
+	// if list is not empty -> valid flag -> filled list
+	if (v.type() == value_type::list_flag) {
+		return lists.to_bool(v.get<value_type::list_flag>());
+	} else {
+		return truthy_impl<value_type::list_flag + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::list>(const value& v, const list_table& lists)
+{
+	// if list is not empty
+	if (v.type() == value_type::list) {
+		return lists.to_bool(v.get<value_type::list>());
+	} else {
+		return truthy_impl<value_type::list + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::float32>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::float32) {
+		return v.get<value_type::float32>() != 0.0f;
+	} else {
+		return truthy_impl<value_type::float32 + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::int32>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::int32) {
+		return v.get<value_type::int32>() != 0;
+	} else {
+		return truthy_impl<value_type::int32 + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::uint32>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::uint32) {
+		return v.get<value_type::uint32>() != 0;
+	} else {
+		return truthy_impl<value_type::uint32 + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::boolean>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::boolean) {
+		return v.get<value_type::boolean>();
+	} else {
+		return truthy_impl<value_type::boolean + 1>(v, lists);
+	}
+}
+
+template<>
+bool truthy_impl<value_type::divert>(const value& v, const list_table& lists)
+{
+	if (v.type() == value_type::divert) {
+		inkFail("Divert can not be evaluated to boolean");
+		return false;
+	} else {
+		return truthy_impl<value_type::divert + 1>(v, lists);
+	}
+}
+
+bool value::truthy(const list_table& lists) const { return truthy_impl(*this, lists); }
+
+
+#ifdef INK_ENABLE_STL
+template<value_type ty = value_type::PRINT_BEGIN>
+void append(std::ostream& os, const value& val, const list_table* lists)
+{
+	if constexpr (ty != value_type::PRINT_END) {
+		if (ty == val.type()) {
+			os << val.get<ty>();
+		} else {
+			append<ty + 1>(os, val, lists);
+		}
+	}
+}
+
+template<>
+void append<value_type::list_flag>(std::ostream& os, const value& val, const list_table* lists)
+{
+	if (val.type() == value_type::list_flag) {
+		inkAssert(lists, "to stringify lists, we need a list_table");
+		os << lists->toString(val.get<value_type::list_flag>());
+	} else {
+		append<value_type::list_flag + 1>(os, val, lists);
+	}
+}
+
+template<>
+void append<value_type::list>(std::ostream& os, const value& val, const list_table* lists)
+{
+	if (val.type() == value_type::list) {
+		inkAssert(lists, "to stringify lists, we need a list_table");
+		lists->write(os, val.get<value_type::list>());
+	} else {
+		append<value_type::list + 1>(os, val, lists);
+	}
+}
+
+template<>
+void append<value_type::float32>(std::ostream& os, const value& val, const list_table* lists)
+{
+	if (val.type() == value_type::float32) {
+		char number[32];
+		ink::runtime::internal::toStr(number, 32, val.get<value_type::float32>());
+		os << number;
+	} else {
+		append<value_type::float32 + 1>(os, val, lists);
+	}
+}
+
+template<>
+void append<value_type::boolean>(std::ostream& os, const value& val, const list_table* lists)
+{
+	if (val.type() == value_type::boolean) {
+		os << (val.get<value_type::boolean>() ? "true" : "false");
+	} else {
+		append<value_type::boolean + 1>(os, val, lists);
+	}
+}
+
+std::ostream& value::write(std::ostream& os, const list_table* lists) const
+{
+	if (type() < value_type::PRINT_BEGIN || type() >= value_type::PRINT_END) {
+		throw ink_exception("printing this type is not supported");
+	}
+	append(os, *this, lists);
+	return os;
+}
+#endif
+
+basic_stream& operator<<(basic_stream& os, const value& val)
+{
+	os.append(val);
+	return os;
+}
+
+value::value(const ink::runtime::value& val)
+    : value()
+{
+	using types = ink::runtime::value::Type;
+	switch (val.type) {
+		case types::Bool: set<value_type::boolean>(val.get<types::Bool>()); break;
+		case types::Uint32: set<value_type::uint32>(val.get<types::Uint32>()); break;
+		case types::Int32: set<value_type::int32>(val.get<types::Int32>()); break;
+		case types::String: set<value_type::string>(val.get<types::String>()); break;
+		case types::Float: set<value_type::float32>(val.get<types::Float>()); break;
+		case types::List:
+			set<value_type::list>(list_table::list{
+			    static_cast<list_impl*>(val.get<types::List>())->get_lid()});
+	}
+}
+
+bool value::set(const ink::runtime::value& val)
+{
+	auto var = value(val);
+	if (type() == value_type::none || var.type() == type()) {
+		*this = var;
+		return true;
+	}
+	return false;
+}
+
+ink::runtime::value value::to_interface_value(list_table& table) const
+{
+	using val = ink::runtime::value;
+	if (type() == value_type::boolean) {
+		return val(get<value_type::boolean>());
+	} else if (type() == value_type::uint32) {
+		return val(get<value_type::uint32>());
+	} else if (type() == value_type::int32) {
+		return val(get<value_type::int32>());
+	} else if (type() == value_type::string) {
+		return val(get<value_type::string>().str);
+	} else if (type() == value_type::float32) {
+		return val(get<value_type::float32>());
+	} else if (type() == value_type::list_flag) {
+		auto v = table.create();
+		v      = table.add(v, get<value_type::list_flag>());
+		return val(table.handout_list(v));
+	} else if (type() == value_type::list) {
+		return val(table.handout_list(get<value_type::list>()));
+	}
+	inkFail("No valid type to convert to interface value!");
+	return val();
+}
+
+size_t value::snap(unsigned char* data, const snapper& snapper) const
+{
+	unsigned char* ptr          = data;
+	bool           should_write = data != nullptr;
+	ptr                         = snap_write(ptr, _type, should_write);
+	if (_type == value_type::string) {
+		unsigned char buf[max_value_size];
+		string_type*  res = reinterpret_cast<string_type*>(buf);
+		auto          str = get<value_type::string>();
+		res->allocated    = str.allocated;
+		if (str.allocated) {
+			res->str = reinterpret_cast<const char*>(
+			    static_cast<std::uintptr_t>(snapper.strings.get_id(str.str))
+			);
+		} else {
+			res->str = reinterpret_cast<const char*>(
+			    static_cast<std::uintptr_t>(str.str - snapper.story_string_table)
+			);
+		}
+		ptr = snap_write(ptr, buf, should_write);
+	} else {
+		// TODO more space efficent?
+		ptr = snap_write(ptr, &bool_value, max_value_size, should_write);
+	}
+	return ptr - data;
+}
+
+const unsigned char* value::snap_load(const unsigned char* ptr, const loader& loader)
+{
+	ptr = snap_read(ptr, _type);
+	ptr = snap_read(ptr, &bool_value, max_value_size);
+	if (_type == value_type::string) {
+		if (string_value.allocated) {
+			string_value.str = loader.string_table[(std::uintptr_t)(string_value.str)];
+		} else {
+			string_value.str = loader.story_string_table + (std::uintptr_t)(string_value.str);
+		}
+	}
+	return ptr;
+}
+} // namespace ink::runtime::internal