No OneTemporary
Actions

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/rosa/support/type_list.hpp b/include/rosa/support/type_list.hpp
	index bb50be3..3e35a19 100644
	--- a/include/rosa/support/type_list.hpp
	+++ b/include/rosa/support/type_list.hpp
	@@ -1,444 +1,444 @@
	//===-- rosa/support/type_list.hpp ------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/support/type_list.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief Facilities for types representing lists of types.
	///
	/// \note This implementation is partially based on the \c type_list
	/// implementation of CAF.
	/// \todo Check license.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_SUPPORT_TYPE_LIST_HPP
	#define ROSA_SUPPORT_TYPE_LIST_HPP

	#include "rosa/support/debug.hpp"
	#include "rosa/support/types.hpp"

	#include <type_traits>

	namespace rosa {

	/// A list of types.
	///
	/// \tparam Ts types to make a list of
	template <typename... Ts> struct TypeList {
	/// Constructor, needs to do nothing.
	constexpr TypeList(void) {}
	};

	/// The empty \c rosa::Typelist.
	using EmptyTypeList = TypeList<>;

	/// \defgroup TypeListAtImpl Implementation of rosa::TypeListAt
	///
	/// \brief Gets the type at index \p Pos from a list of types.
	///
	/// \note Only to be used by the implementation of \c rosa::TypeListAt.
	///@{

	/// Declaration of the template.
	///
	/// \tparam Pos index to take the element from
	/// \tparam Ts types
	template <size_t Pos, typename... Ts> struct TypeListAtImpl;

	/// Definition for the general case when \p Pos is not \c 0 and there is type in
	/// the list.
	template <size_t Pos, typename T, typename... Ts>
	struct TypeListAtImpl<Pos, T, Ts...> {
	using Type = typename TypeListAtImpl<Pos - 1, Ts...>::Type;
	};

	/// Specialization for the case when \p Pos is \c 0.
	template <typename T, typename... Ts> struct TypeListAtImpl<0, T, Ts...> {
	using Type = T;
	};

	/// Specialization for the case when there is no more type.
	///
	/// In this case, the found type is \c rosa::none_t.
	template <size_t Pos> struct TypeListAtImpl<Pos> { using Type = none_t; };

	///@}

	/// \defgroup TypeListAt Definition of rosa::TypeListAt
	///
	/// \brief Gets the element at index \p Pos of \p List.
	///
	///
	/// The type at index \c Pos in a \c rosa::TypeList \c List can be obtained as
	/// \code
	/// typename TypeListAt<List, Pos>::Type
	/// \endcode
	///
	/// \note The resulting type is \c rosa::none_t if \code
	/// TypeListSize<List>::Value < Pos
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to take an element from
	/// \tparam Pos index to take the element from
	template <typename List, size_t Pos> struct TypeListAt;

	/// Implementation using \c rosa::TypeListAtImpl.
	template <size_t Pos, typename... Ts> struct TypeListAt<TypeList<Ts...>, Pos> {
	using Type = typename TypeListAtImpl<Pos, Ts...>::Type;
	};

	///@}

	/// \defgroup TypeListIndexOfImpl Implementation of rosa::TypeListIndexOf
	///
	/// \brief Tells the index of the first occurence of a type in a list of types.
	///
	/// \note Only to be used by the implementation of \c rosa::TypeListIndexOf.
	///@{

	/// Declaration of the template.
	///
	/// \tparam Pos the number types already being checked from the beginning of the
	/// list
	/// \tparam X type to search for
	/// \tparam Ts remaining list of types
	template <size_t Pos, typename X, typename... Ts> struct TypeListIndexOfImpl;

	/// Specialization for the case when the list is over.
	///
	/// In this case, the found index is \c -1.
	template <size_t Pos, typename X> struct TypeListIndexOfImpl<Pos, X> {
	static constexpr int Value = -1;
	};

	/// Specialization for the case when the first type in the remaining list
	/// is a match.
	template <size_t Pos, typename X, typename... Ts>
	struct TypeListIndexOfImpl<Pos, X, X, Ts...> {
	static constexpr int Value = Pos;
	};

	/// Implementation for the general case when need to continue looking.
	template <size_t Pos, typename X, typename T, typename... Ts>
	struct TypeListIndexOfImpl<Pos, X, T, Ts...> {
	static constexpr int Value = TypeListIndexOfImpl<Pos + 1, X, Ts...>::Value;
	};

	///@}

	/// \defgroup TypeListIndexOf Definition of rosa::TypeListIndexOf
	///
	/// \brief Tells the index of the first occurence of type in a
	/// \c rosa::TypeList.
	///
	/// The index of the first occurence of type \c T in \c rosa::TypeList \c List
	/// can be obtained as \code
	/// TypeListIndexOf<List, T>::Value
	/// \endcode
	///
	/// \note The resulting index is \c -1 if \c T is not present in \c List.
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to search in
	/// \tparam T type to search for
	template <typename List, typename T> struct TypeListIndexOf;

	/// Implementation of the template using \c rosa::TypeListIndexOfImpl.
	template <typename... Ts, typename T>
	struct TypeListIndexOf<TypeList<Ts...>, T> {
	static constexpr int Value = TypeListIndexOfImpl<0, T, Ts...>::Value;
	};

	///@}

	/// \defgroup TypeListHead Implementation of rosa::TypeListHead
	///
	/// \brief Gets the first element of a \c rosa::TypeList.
	///
	/// The first element of a \c rosa::TypeList \c List can be obtained as \code
	/// typename TypeListHead<List>::Type
	/// \endcode
	///
	/// \note The resulting type is \c rosa::none_t if \c List is
	/// \c rosa::EmptyTypeList.
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to get the first element of
	template <typename List> struct TypeListHead;

	/// Specialization for \c rosa::EmptyTypeList.
	///
	/// In this case, the found type is \c rosa::none_t.
	template <> struct TypeListHead<EmptyTypeList> { using Type = none_t; };

	/// Implementation for a non-empty \c rosa::TypeList.
	template <typename T, typename... Ts> struct TypeListHead<TypeList<T, Ts...>> {
	using Type = T;
	};

	///@}

	/// \defgroup TypeListTail Implementation of rosa::TypeListTail
	///
	/// \brief Gets the tail of a \c rosa::TypeList.
	///
	/// The tail of a \c rosa::TypeList \c List, that is \c List except for its
	/// first element, can be obtained as \code
	/// typename TypeListTail<List>::Type
	/// \endcode
	///
	/// \note If \c List is \c rosa::EmptyTypeList, then the resulting type is also
	/// \c rosa::EmptyTypeList.
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to take the tail of
	template <typename List> struct TypeListTail;

	/// Specialization for \c rosa::EmptyTypeList.
	///
	/// In this case, the resulting type is \c rosa::EmptyTypeList.
	template <> struct TypeListTail<EmptyTypeList> { using Type = EmptyTypeList; };

	/// Implementation for a non-empty \c rosa::TypeList.
	template <typename T, typename... Ts> struct TypeListTail<TypeList<T, Ts...>> {
	using Type = TypeList<Ts...>;
	};

	///@}

	/// \defgroup TypeListPush Implementation of rosa::TypeListPush
	///
	/// \brief Extends a \c rosa::TypeList with a type.
	///
	/// Whether the new type is pushed in the front or in the back of the
	/// \c rosa::TypeList depends on the order of template arguments, as shown in
	/// the following example: \code
	/// using List = TypeList<A>
	/// typename TypeListPush<List, T>::Type; // TypeList<A, T>
	/// typename TypeListPush<T, List>::Type; // TypeList<T, A>
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam P a type if \p Q is a \c rosa::TypeList, a \c rosa::TypeList
	/// otherwise
	/// \tparam Q a type if \p P is a \c rosa::TypeList, a \c rosa::TypeList
	/// otherwise
	template <typename P, typename Q> struct TypeListPush;

	/// Implementation for the case when pushing at the back of the
	/// \c rosa::TypeList.
	template <typename... Ts, typename T> struct TypeListPush<TypeList<Ts...>, T> {
	using Type = TypeList<Ts..., T>;
	};

	/// Implementation for the case when pushing to the front of the
	/// \c rosa::TypeList.
	template <typename T, typename... Ts> struct TypeListPush<T, TypeList<Ts...>> {
	using Type = TypeList<T, Ts...>;
	};

	///@}

	/// \defgroup TypeListDrop Implementation of rosa::TypeListDrop
	///
	/// \brief Drops some elements from the beginning of a \c rosa::TypeList.
	///
	/// The first \c N types of a \c rosa::TypeList \c List can be dropped as \code
	/// typename TypeListDrop<N, List>::Type
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam N number of types to drop
	/// \tparam List \c rosa::TypeList to drop the first \p N element of
	template <size_t N, typename List> struct TypeListDrop;

	/// Specialization for \c rosa::EmptyTypeList.
	template <size_t N> struct TypeListDrop<N, EmptyTypeList> {
	using Type = EmptyTypeList;
	};

	/// Implementation for a non-empty \c rosa::TypeList.
	template <size_t N, typename T, typename... Ts>
	struct TypeListDrop<N, TypeList<T, Ts...>> {
	using Type = typename std::conditional<
	- N == 0, TypeList<Ts...>,
	+ N == 0, TypeList<T, Ts...>,
	typename TypeListDrop<N - 1, TypeList<Ts...>>::Type>::type;
	};

	///@}

	/// \defgroup TypeListSize Implementation of rosa::TypeListSize
	///
	/// \brief Tells the number of types stored in a \c rosa::TypeList.
	///
	/// The size of a \c rosa::TypeList \c List can be obtained as \code
	/// TypeListSize<List>::Value
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to get the size of
	template <typename List> struct TypeListSize;

	/// Implementation of the template.
	template <typename... Ts> struct TypeListSize<TypeList<Ts...>> {
	static constexpr size_t Value = sizeof...(Ts);
	};

	template <typename... Ts> constexpr size_t TypeListSize<TypeList<Ts...>>::Value;

	///@}

	/// Tests whether a \c rosa::TypeList is empty.
	///
	/// \tparam List \c rosa::TypeList to check
	template <typename List> struct TypeListEmpty {
	/// Denotes whether \p List is an empty \c rosa::TypeList or not.
	static constexpr bool Value = std::is_same<EmptyTypeList, List>::value;
	};

	/// \defgroup TypeListContains Implementation of rosa::TypeListContains
	///
	/// \brief Tells if a \c rosa::TypeList contains a given type.
	///
	/// Whether a \c rosa::TypeList \c List contains the type \c T can be checked as
	/// \code
	/// TypeListContains<List, T>::Value
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to search in
	/// \tparam T type to search for
	template <typename List, typename T> struct TypeListContains;

	/// Implementation of the template.
	template <typename... Ts, typename T>
	struct TypeListContains<TypeList<Ts...>, T> {
	static constexpr bool Value =
	std::conditional<TypeListIndexOf<TypeList<Ts...>, T>::Value == -1,
	std::false_type, std::true_type>::type::value;
	};

	///@}

	/// \defgroup TypeListSubsetOf Implementation of rosa::TypeListSubsetOf
	///
	/// \brief Tells if a \c rosa::TypeList is a subset of another one.
	///
	/// Whether a \c rosa::TypeList \c ListA is a subset of another
	/// \c rosa::TypeList \c ListB can be checked as \code
	/// TypeListSubsetOf<ListA, ListB>::Value
	/// \endcode
	///@{

	/// Declaration of the template.
	///
	/// \tparam ListA \c rosa::TypeList to check if is a subset of \p ListB
	/// \tparam ListB \c rosa::TypeList to check if is a superset of \p ListA
	/// \tparam Fwd always use the default value!
	template <typename ListA, typename ListB, bool Fwd = true>
	struct TypeListSubsetOf;

	/// Specialization for the case when all the elements of the original \p ListA
	/// was found in \p ListB.
	template <typename List> struct TypeListSubsetOf<EmptyTypeList, List, true> {
	static constexpr bool Value = true;
	};

	/// Specializaton for the case when an element of the original \p ListA cannot
	/// be found in \p ListB.
	template <typename ListA, typename ListB>
	struct TypeListSubsetOf<ListA, ListB, false> {
	static constexpr bool Value = false;
	};

	/// Definition for the general case.
	template <typename T, typename... Ts, typename List>
	struct TypeListSubsetOf<TypeList<T, Ts...>, List>
	: TypeListSubsetOf<TypeList<Ts...>, List,
	TypeListContains<List, T>::Value> {};

	///@}

	/// \defgroup TypeListFindImpl Implementation of rosa::TypeListFind
	///
	/// \brief Finds the first type in a list of types that satisfies a predicate.
	///
	/// \note Only to be used by the implementation of \c rosa::TypeListFind.
	///@{

	/// Declaration of the template.
	///
	/// \tparam Pred the predicate to check types against
	/// \tparam Ts list of types to check
	template <template <typename> class Pred, typename... Ts>
	struct TypeListFindImpl;

	/// Specialization for the case when no more types remain to check.
	template <template <typename> class Pred> struct TypeListFindImpl<Pred> {
	using Type = none_t;
	};

	/// Implementation for the general case when there is a type to check.
	template <template <typename> class Pred, typename T, typename... Ts>
	struct TypeListFindImpl<Pred, T, Ts...> {
	using Type = typename std::conditional<
	Pred<T>::Value, T, typename TypeListFindImpl<Pred, Ts...>::Type>::type;
	};

	///@}

	/// \defgroup TypeListFind Definition of rosa::TypeListFind
	///
	/// \brief Finds the first element satisfying a predicate in a
	/// \c rosa::TypeList.
	///
	/// The first type satisfying a predicate \c Pred in a \c rosa::TypeList
	/// \c List can be obtained as \code
	/// typename TypeListFind<List, Pred>::Type
	/// \endcode
	///
	/// \note The resulting type is \c rosa::none_t if no type in \c List satisfies
	/// \c Pred.
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to search in
	/// \tparam Pred predicate to check elements against
	template <typename List, template <typename> class Pred> struct TypeListFind;

	/// Implementation of the template using \c rosa::TypeListFindImpl.
	template <typename... Ts, template <typename> class Pred>
	struct TypeListFind<TypeList<Ts...>, Pred> {
	using Type = typename TypeListFindImpl<Pred, Ts...>::Type;
	};

	///@}

	} // End namespace rosa

	#endif // ROSA_SUPPORT_TYPE_LIST_HPP
	diff --git a/include/rosa/support/type_numbers.hpp b/include/rosa/support/type_numbers.hpp
	index 3d46da5..fc19312 100644
	--- a/include/rosa/support/type_numbers.hpp
	+++ b/include/rosa/support/type_numbers.hpp
	@@ -1,231 +1,231 @@
	//===-- rosa/support/type_numbers.hpp ---------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/support/type_numbers.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief Facilities for registering supported types and representing them with
	/// numbers.
	///
	/// \note This implementation is partially based on the \c type_number
	/// implementation of CAF.
	/// \todo Check license.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_SUPPORT_TYPE_NUMBERS_HPP
	#define ROSA_SUPPORT_TYPE_NUMBERS_HPP

	#include "rosa/support/atom.hpp"
	#include "rosa/support/math.hpp"
	#include "rosa/support/squashed_int.hpp"
	#include "rosa/support/type_helper.hpp"
	#include "rosa/support/types.hpp"

	#include <array>
	#include <string>

	namespace rosa {

	/// Compile-time list of all built-in types.
	/// \note Appending new types to the end of this list maintains backward
	/// compatibility in the sense that old builtin types have the same type number
	/// associated to them in both the old and new versions. But changing any of
	/// the already present types in the list breaks that backward compatibility.
	/// Should compatibility be broken, step \c rosa::TypeNumberVersion below!
	/// \note Keep this list in sync with the definition of
	/// \c rosa::NumberedTypeNames.
	/// \note The built-in types are explicitly listed in the definition of
	/// rosa::deluxe::DeluxeAgent. Keep those definitions in sync with this list.
	using BuiltinTypes = TypeList<AtomValue, ///< atom
	int16_t, ///< i16
	int32_t, ///< i32
	int64_t, ///< i64
	int8_t, ///< i8
	long double, ///< ldouble
	std::string, ///< str
	uint16_t, ///< u16
	uint32_t, ///< u32
	uint64_t, ///< u64
	uint8_t, ///< u8
	unit_t, ///< unit
	bool, ///< bool
	double, ///< double
	float ///< float
	>;

	/// Indicates the version number of \c rosa::BuiltinTypes.
	///
	/// Software with the same version number are supposed to have backward
	/// compatible type numbering.
	///
	/// \sa \c rosa::BultinTypes on backward compatibility.
	constexpr size_t TypeNumberVersion = 0;

	/// The number of built-in types.
	static constexpr size_t NumberOfBuiltinTypes =
	TypeListSize<BuiltinTypes>::Value;

	/// Anonymous namespace for helper facilities, consider it private.
	namespace {

	-/// Tells if a type is not \c rosa::UnitType.
	+/// Tells if a type is not \c rosa::NoneType.
	///
	/// \tparam T the type to check
	-template <typename T> struct IsNotUnitType {
	- /// Denotes if \p T is the \c rosa::UnitType or not.
	- static constexpr bool Value = !std::is_same<T, UnitType>::value;
	+template <typename T> struct IsNotNoneType {
	+ /// Denotes if \p T is the \c rosa::NoneType or not.
	+ static constexpr bool Value = !std::is_same<T, NoneType>::value;
	};

	} // End namespace

	/// Integer type to store type numbers.
	/// \note The narrowest unsigned integer type that is wide enough to represent
	/// \c NumberOfBuiltinTypes different values.
	-using type_nr_t =
	- typename TypeListFind<typename TypeListDrop<log2(NumberOfBuiltinTypes) / 8,
	- IntegerTypesBySize>::Type,
	- IsNotUnitType>::Type::Second;
	+using type_nr_t = typename TypeListFind<
	+ typename TypeListDrop<log2(NumberOfBuiltinTypes) / 8 + 1,
	+ IntegerTypesBySize>::Type,
	+ IsNotNoneType>::Type::Second;

	/// Turn \c rosa::type_nr_t into a strongly typed enumeration.
	///
	/// Values of \c rosa::type_nr_t casted to \c rosa::TypeNumbers can be used in a
	/// type-safe way.
	enum class TypeNumber : type_nr_t {};

	/// A type to cast type numbers into in order to output them to streams as
	/// numbers and not ASCII-codes.
	///
	/// \note Use it for safety, necessary for printing \c uint8_t values.
	using printable_tn_t = printable_t<type_nr_t>;

	/// Casts a \c rosa::TypeNumber into \c rosa::printable_tn_t.
	///
	/// \param TN \c rosa::TypeNumber to cast.
	#define PRINTABLE_TN(TN) static_cast<printable_tn_t>(TN)

	/// Converts a \c rosa::TypeNumber into \c std::string.
	///
	/// \param TN \c rosa::TypeNumber to convert
	///
	/// \return \c std::string representing \p TN
	inline std::string to_string(const TypeNumber TN) {
	return std::to_string(static_cast<type_nr_t>(TN));
	}

	/// \name TypeNumberOf
	/// \brief Computes \c rosa::TypeNumber for a type.
	///
	/// The \c rosa::TypeNumber for a type \c T can be obtained as \code
	/// TypeNumberOf<T>::Value
	/// \endcode
	///
	/// \note \c rosa::TypeNumber for a type is based on the corresponding squashed
	/// type, except for \c bool and \c rosa::AtomConstant types.
	///
	/// \sa \c rosa::SquashedType
	///
	/// \note \c rosa::TypeNumber is the index of the type in \c rosa::BuiltinTypes
	/// starting from \c 1; index \c 0 indicates a non-builtin type.
	///@{

	/// Definition of the template for the general case.
	///
	/// \tparam T type to get \c rosa::TypeNumber for
	template <typename T> struct TypeNumberOf {
	static constexpr TypeNumber Value = static_cast<TypeNumber>(
	TypeListIndexOf<BuiltinTypes, squashed_t<T>>::Value + 1);
	};

	/// Specialization for \c bool.
	template <> struct TypeNumberOf<bool> {
	static constexpr TypeNumber Value =
	static_cast<TypeNumber>(TypeListIndexOf<BuiltinTypes, bool>::Value + 1);
	};

	/// Specialization for \c rosa::AtomConstant.
	///
	/// \note For a \c rosa::AtomConstant type, \c rosa::TypeNumber is based on the
	/// \c rosa::AtomValue wrapped into the actual \c rosa::AtomConstant.
	template <AtomValue V> struct TypeNumberOf<AtomConstant<V>> {
	static constexpr TypeNumber Value = TypeNumberOf<AtomValue>::Value;
	};

	///@}

	// clang-format off

	/// List of type names for all builtin-types, indexed via \c rosa::TypeNumber.
	///
	/// \note Keep this definition in sync with \c rosa::BuiltinTypes.
	constexpr std::array<const char *, NumberOfBuiltinTypes> NumberedTypeNames {{
	"atom",
	"i16",
	"i32",
	"i64",
	"i8",
	"ldouble",
	"str",
	"u16",
	"u32",
	"u64",
	"u8",
	"unit",
	"bool",
	"double",
	"float"
	}};

	// clang-format on

	/// Tells if a \c rosa::TypeNumber is valid in the software.
	///
	/// \note A \c rosa::TypeNumber generated by an incompatible version may be
	/// valid but may denote a type that is different from the \c rosa::TypeNumber
	/// denotes in the current software. That is why this validation needs to be
	/// done in connection to checking \c rosa::TypeNumberVersion as well.
	///
	/// \param TN \c rosa::TypeNumber to validate in the context of the current
	/// software
	///
	/// \return Whether \p TN is valid in the current software
	constexpr bool validTypeNumber(const TypeNumber TN) {
	// \todo Duplication of static_cast into a const variable would be
	// possible in C++14.
	return 0 < static_cast<type_nr_t>(TN) &&
	static_cast<type_nr_t>(TN) <= NumberOfBuiltinTypes;
	}

	/// Provides information about the type corresponding to a \c rosa::TypeNumber.
	///
	/// \tparam TN \c rosa::TypeNumber to get information for
	///
	/// \pre Statically, \p TN is a valid \c rosa::TypeNumber:
	/// \code
	/// validTypeNumber(TN)
	/// \endcode
	template <TypeNumber TN> struct TypeForNumber {
	STATIC_ASSERT(validTypeNumber(TN), "not a valid type number");

	/// \p TN as \c rosa::type_nr_t.
	static constexpr type_nr_t TNI = static_cast<type_nr_t>(TN);

	/// The builtin-type corresponding to \p TN.
	using Type = typename TypeListAt<BuiltinTypes, TNI - 1>::Type;

	/// The size of \c Type.
	static constexpr size_t Size = sizeof(Type);

	/// Textual representation of the builtin-type.
	static constexpr const char *Name = NumberedTypeNames[TNI - 1];
	};

	} // End namespace rosa

	#endif // ROSA_SUPPORT_TYPE_NUMBERS_HPP

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 10:33 PM (17 h, 26 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157390
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions