No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/rosa/core/Invoker.hpp b/include/rosa/core/Invoker.hpp
	index 9f35ca3..365e133 100644
	--- a/include/rosa/core/Invoker.hpp
	+++ b/include/rosa/core/Invoker.hpp
	@@ -1,258 +1,257 @@
	//===-- rosa/core/Invoker.hpp ------------------------------------ C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/core/Invoker.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017-2019
	///
	/// \brief Facilities for providing actual arguments for functions as
	/// \c rosa::Messageobjects.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_CORE_INVOKER_HPP
	#define ROSA_CORE_INVOKER_HPP

	#include "rosa/core/MessageMatcher.hpp"

	#include "rosa/support/log.h"
	#include "rosa/support/sequence.hpp"

	#include <functional>
	#include <memory>

	namespace rosa {

	/// Wraps a function and provides a simple interface to invoke the stored
	/// function by passing actual arguments as a \c rosa::Message object.
	///
	/// \note A \c rosa::Invoker instance is supposed to be owned by a
	/// \c rosa::MessageHandler instance, and not being used directly from user
	/// code.
	class Invoker {
	protected:
	/// Creates an instance.
	///
	/// \note Protected constructor restricts instantiation to derived classes.
	Invoker(void) noexcept;

	public:
	/// Destroys \p this object.
	virtual ~Invoker(void);

	/// Possible results of an invocation.
	enum class Result {
	NoMatch, ///< The wrapped function could not be invoked
	Invoked ///< The wrapped function has been invoked
	};

	/// Type alias for a smart-pointer for \c rosa::Invoker.
	using invoker_t = std::unique_ptr<const Invoker>;

	/// Type alias for \c rosa::Invoker::Result.
	using result_t = Result;

	/// Tells if a \c rosa::Message object can be used to invoke the function
	/// wrapped in \p this object.
	///
	/// \param Msg \c rosa::Message to check
	///
	/// \return whether \p Msg can be used to invoke the wrapped function
	virtual bool match(const Message &Msg) const noexcept = 0;

	/// Tries to invoke the wrapped function with a \c rosa::Message object.
	///
	/// The wrapped function is invoked if the actual \c rosa::Message object can
	/// be used to invoke it.
	///
	/// \param Msg \c rosa::Message to try to invoke the wrapped function with
	///
	/// \return whether the wrapped function could be invoked with \p Msg
	virtual result_t operator()(const Message &Msg) const noexcept = 0;

	/// Instantiates an implementation of \c rosa::Invoker with the given
	/// function.
	///
	/// \note As there is no empty \c rosa::Message, no \c rosa::Invoker wraps a
	/// function without any argument.
	///
	/// \todo Enforce F does not potentially throw exception.
	///
	/// \tparam T type of the first mandatory argument
	/// \tparam Ts types of any further arguments
	///
	/// \param F function to wrap
	///
	/// \return new \c rosa::Invoker::invoker_t object created from the given
	/// function
	template <typename T, typename... Ts>
	static invoker_t wrap(std::function<void(T, Ts...)> &&F) noexcept;

	/// Convenience template alias for casting callable stuff to function objects
	/// for wrapping.
	///
	/// \tparam Ts types of arguments
	///
	/// \todo Should make it possible to avoid using an explicit conversion for
	/// the arguments of wrap.
	template <typename... Ts> using F = std::function<void(Ts...)>;


	/// Convenience template for preparing non-static member functions into
	/// function objects for wrapping.
	///
	/// \tparam C type whose non-static member the function is
	/// \tparam Ts types of arguments
	///
	/// \see \c THISMEMBER
	template <typename C, typename... Ts>
	static inline F<Ts...> M(C O, void (C::Fun)(Ts...) noexcept) noexcept;
	};

	/// Convenience preprocessor macro for the typical use of \c rosa::Invoker::M.
	/// It can be used inside a class to turn a non-static member function into a
	/// function object capturing this pointer, so using the actual object when
	/// handling a \c rosa::Message.
	///
	/// \param FUN the non-static member function to wrap
	///
	/// \note Inside the class \c MyClass, use\code
	/// THISMEMBER(fun)
	/// \endcode instead of\code
	/// Invoker::M(this, &MyClass::fun)
	/// \endcode
	#define THISMEMBER(FUN) \
	Invoker::M(this, &std::decay<decltype(*this)>::type::FUN)

	/// Nested namespace with implementation of \c rosa::Invoker and helper
	/// templates, consider it private.
	namespace {

	/// \defgroup InvokerImpl Implementation for rosa::Invoker
	///
	/// Implements the \c rosa::Invoker interface for functions with different
	/// signatures.
	///
	///@{

	/// Declaration of \c rosa::InvokerImpl implementing \c rosa::Invoker.
	///
	/// \tparam Fun function to wrap
	template <typename Fun> class InvokerImpl;

	/// Implementation of \c rosa::InvokerImpl for \c std::function.
	///
	/// \tparam T type of the first mandatory argument
	/// \tparam Ts types of further arguments
	///
	/// \note As there is no empty \c rosa::Message, no \c rosa::Invoker wraps a
	/// function without any argument, i.e., no
	/// \c std::function<void(void)>.
	template <typename T, typename... Ts>
	class InvokerImpl<std::function<void(T, Ts...)>> final
	: public Invoker {

	/// Type alias for the stored function.
	using function_t = std::function<void(T, Ts...)>;

	/// Type alias for correctly typed argument-tuples as obtained from
	/// \c rosa::Message.
	using args_t = std::tuple<const T &, const Ts &...>;

	/// Alias for \c rosa::MessageMatcher for the arguments of the stored
	/// function.
	using Matcher = MsgMatcher<T, Ts...>;

	/// The wrapped function.
	const function_t F;

	/// Invokes \c InvokerImpl::F by unpacking arguments from a \c std::tuple with
	/// the help of the actual template arguments.
	///
	/// \tparam S sequence of numbers indexing \c std::tuple for arguments
	///
	/// \param Args arguments to invoke \c InvokerImpl::F with
	///
	/// \pre the length of \p S and size of \p Args are matching:\code
	/// sizeof...(S) == std::tuple_size<args_t>::value
	/// \endcode
	template <size_t... S>
	inline void invokeFunction(Seq<S...>, const args_t &Args) const noexcept;

	public:
	/// Creates an instance.
	///
	/// \param F function to wrap
	///
	/// \pre \p F is valid:\code
	/// bool(F)
	/// \endcode
	InvokerImpl(function_t &&F) noexcept : F(F) {
	ASSERT(bool(F)); // Sanity check.
	}

	/// Destroys \p this object.
	~InvokerImpl(void) = default;

	/// Tells if a \c rosa::Message object can be used to invoke the function
	/// wrapped in \p this object.
	///
	/// \param Msg \c rosa::Message to check
	///
	/// \return whether \p Msg can be used to invoke the wrapped function
	bool match(const Message &Msg) const noexcept override {
	return Matcher::doesStronglyMatch(Msg);
	};

	/// Tries to invoke the wrapped function with a \c rosa::Message object.
	///
	/// The wrapped function is invoked if the actual \c rosa::Message object can
	/// be used to invoke it.
	///
	/// \param Msg \c rosa::Message to try to invoke the wrapped function with
	///
	/// \return whether the wrapped function could be invoked with \p Msg
	result_t operator()(const Message &Msg) const noexcept override {
	if (match(Msg)) {
	LOG_TRACE("Invoking with matching arguments");
	- invokeFunction(typename GenSeq<sizeof...(Ts) + 1>::Type(),
	- Matcher::extractedValues(Msg));
	+ invokeFunction(seq_t<sizeof...(Ts) + 1>(), Matcher::extractedValues(Msg));
	return result_t::Invoked;
	} else {
	LOG_TRACE("Tried to invoke with non-matching arguments");
	return result_t::NoMatch;
	}
	}
	};

	template <typename T, typename... Ts>
	template <size_t... S>
	void InvokerImpl<std::function<void(T, Ts...)>>::invokeFunction(
	Seq<S...>, const args_t &Args) const noexcept {
	ASSERT(sizeof...(S) == std::tuple_size<args_t>::value); // Sanity check.
	F(std::get<S>(Args)...);
	}

	///@}

	} // End namespace

	template <typename T, typename... Ts>
	Invoker::invoker_t
	Invoker::wrap(std::function<void(T, Ts...)> &&F) noexcept {
	return std::unique_ptr<Invoker>(
	new InvokerImpl<std::function<void(T, Ts...)>>(std::move(F)));
	}

	template <typename C, typename... Ts>
	Invoker::F<Ts...> Invoker::M(C O, void (C::Fun)(Ts...) noexcept) noexcept {
	return [ O, Fun ](Ts... Vs) noexcept->void { (O->*Fun)(Vs...); };
	}
	} // End namespace rosa

	#endif // ROSA_CORE_INVOKER_HPP
	diff --git a/include/rosa/support/sequence.hpp b/include/rosa/support/sequence.hpp
	index 5764a80..62b8408 100755
	--- a/include/rosa/support/sequence.hpp
	+++ b/include/rosa/support/sequence.hpp
	@@ -1,51 +1,57 @@
	//===-- rosa/support/sequence.hpp -------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/support/sequence.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	-/// \date 2017
	+/// \date 2017-2019
	///
	/// \brief Template facilities to statically generate a sequence of numbers.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_SUPPORT_SEQUENCE_HPP
	#define ROSA_SUPPORT_SEQUENCE_HPP

	#include <cstddef>

	namespace rosa {

	/// \defgroup Seq Implementation of rosa::Seq
	///
	/// Facility to statically generate sequences of numbers.
	///
	///@{

	/// Template with an empty struct to store a sequence of numbers in compile time
	/// as template arguments.
	///
	/// Generate a sequence of numbers from `0` up to (including) `(N - 1)` like
	/// \code
	/// typename GenSeq<N>::Type
	/// \endcode
	template <size_t...> struct Seq {};

	/// Sequence generator, the general case when counting down by extending the
	/// sequence.
	template <size_t N, size_t... S> struct GenSeq : GenSeq<N - 1, N - 1, S...> {};

	/// Sequence generator, the terminal case when storing the generated sequence
	/// into \c Seq.
	template <size_t... S> struct GenSeq<0, S...> { using Type = Seq<S...>; };

	///@}

	+/// Convenience template alias for using \c rosa::GenSeq to obtain an instance
	+/// of \c rosa::Seq.
	+///
	+/// \see \c rosa::Seq and \c rosa::GenSeq
	+template <size_t... S> using seq_t = typename GenSeq<S...>::Type;
	+
	} // End namespace rosa

	#endif // ROSA_SUPPORT_SEQUENCE_HPP
	diff --git a/include/rosa/support/type_list.hpp b/include/rosa/support/type_list.hpp
	index 3e35a19..b3e8107 100644
	--- a/include/rosa/support/type_list.hpp
	+++ b/include/rosa/support/type_list.hpp
	@@ -1,444 +1,468 @@
	//===-- 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
	+/// \date 2017-2019
	///
	/// \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<T, Ts...>,
	typename TypeListDrop<N - 1, TypeList<Ts...>>::Type>::type;
	};

	///@}

	+/// \defgroup TypeListConcat Implementation of rosa::TypeListConcat
	+///
	+/// \brief Concatenates two \c rosa::TypeList instances.
	+///
	+/// Two instances of \c rosa::TypeList \c List1 and \c List2 can be
	+/// concatenated as \code
	+/// typename TypeListConcat<List1, List2>::Type
	+/// \endcode
	+///@{
	+
	+/// Declaration of the template
	+///
	+/// \tparam List1 the first instance of \c rosa::TypeList
	+/// \tparam List2 the second instance of \c rosa::TypeList
	+template <typename List1, typename List2> struct TypeListConcat;
	+
	+/// Implementation of the template for \c rosa::TypeList instances.
	+template <typename... As, typename... Bs>
	+struct TypeListConcat<TypeList<As...>, TypeList<Bs...>> {
	+ using Type = TypeList<As..., Bs...>;
	+};
	+
	+///@}
	+
	/// \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_token.hpp b/include/rosa/support/type_token.hpp
	index ee08886..cc4aeaf 100644
	--- a/include/rosa/support/type_token.hpp
	+++ b/include/rosa/support/type_token.hpp
	@@ -1,288 +1,306 @@
	//===-- rosa/support/type_token.hpp ------------------------------ C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/support/type_token.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017-2019
	///
	/// \brief Facilities for encoding TypeLists as unsigned integer values.
	///
	/// \note **On the compatibility between different versions of the type token
	/// implementation:**
	/// Different software versions produce compatible type tokens as long as
	/// backward compatibility of \c rosa::BuiltinTypes is maintained (denoted by
	/// \c rosa::TypeNumberVersion) and the type token implementation uses the same
	/// type as \c rosa::token_t (boiling down to the same \c rosa::token::TokenBits
	/// value) and the same \c rosa::token::RepresentationBits value. Thus,
	/// interacting software need to cross-validate the aforementioned values to
	/// check compatibility. Interoperation between compatible sofware is limited
	/// to backward compatiblity, that is builtin types defined in both software
	/// versions are handled correctly but a newer system may produce a type token
	/// which is invalid in an old one. Therefore, tokens obtained from a compatible
	/// remote system need to be validated.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_SUPPORT_TYPE_TOKEN_HPP
	#define ROSA_SUPPORT_TYPE_TOKEN_HPP

	#include "rosa/support/type_numbers.hpp"

	namespace rosa {

	/// Integer type to store type tokens.
	///
	/// \note The trade-off between the binary overhead of type encoding and the
	/// maximal size of encodable lists can be tuned by using unsigned integer types
	/// of different widths as \c rosa::token_t.
	using token_t = uint64_t;

	/// Sanity check in case someone would change \c rosa::token_t.
	STATIC_ASSERT(std::is_unsigned<token_t>::value,
	"token_t is not an unsigned integer");

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

	/// A type to cast tokens 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_token_t = printable_t<token_t>;

	/// Casts a \c rosa::Token into \c rosa::printable_token_t.
	///
	/// \param T \c rosa::Token to cast
	#define PRINTABLE_TOKEN(T) static_cast<printable_token_t>(T)

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

	/// Encloses constants related to the implementation of \c rosa::Token.
	namespace token {

	/// The number of bits in one \c rosa::Token.
	constexpr size_t TokenBits = sizeof(Token) * 8;

	/// The number of bits a builtin type can be uniquely encoded into, that is any
	/// valid \c rosa::TypeNumber can fit into.
	///
	/// \note There is one extra bit position added for encoding so that providing a
	/// better chance to maintain backward comaptibility when \c rosa::BuiltinTypes
	/// is extended.
	constexpr size_t RepresentationBits = log2(NumberOfBuiltinTypes) + 1;

	/// Maximal size of uniquely tokenizable \c rosa::TypeList.
	constexpr size_t MaxTokenizableListSize = TokenBits / RepresentationBits;

	} // End namespace token

	/// Integer type to store length of a \c rosa::Token.
	///
	/// \note The narrowest unsigned integer type that is wide enough to
	/// represent \c rosa::token::MaxTokenizableListSize different values.
	using token_size_t = typename TypeListFind<
	typename TypeListDrop<log2(token::MaxTokenizableListSize) / 8 + 1,
	IntegerTypesBySize>::Type,
	IsNotNoneType>::Type::Second;

	/// \defgroup TypeListTokenImpl Implementation of rosa::TypeListToken
	///
	/// \brief Generates a \c rosa::Token for a squashed \c rosa::TypeList.
	///
	/// \note Only to be used by the implementation of \c rosa::TypeListToken.
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to generate \c rosa::Token for
	template <typename List> struct TypeListTokenImpl;

	/// Specialization for \c rosa::EmptyTypeList.
	template <> struct TypeListTokenImpl<EmptyTypeList> {
	static constexpr Token Value = static_cast<Token>(0);
	};

	/// Specialization for a non-empty \c rosa::TypeList.
	template <typename T, typename... Ts>
	struct TypeListTokenImpl<TypeList<T, Ts...>> {
	static constexpr TypeNumber TN = TypeNumberOf<T>::Value;
	// Check if the generated type number is valid.
	STATIC_ASSERT(validTypeNumber(TN), "non-builtin type");
	static constexpr Token Value = static_cast<Token>(
	(static_cast<token_t>(TypeListTokenImpl<TypeList<Ts...>>::Value)
	<< token::RepresentationBits) \|
	static_cast<type_nr_t>(TN));
	};

	///@}

	/// \name TypeListToken
	///
	/// \brief Generates a \c rosa::Token for a \c rosa::TypeList.
	///
	/// \c rosa::Token for a \c rosa::TypeList \c List can be obtained as \code
	/// TypeListToken<List>::Value
	/// \endcode
	///
	/// \note The \c rosa::TypeList cannot have more than
	/// \c rosa::token::MaxTokenizableListSize elements and must be a subset of
	/// \c rosa::BuiltinTypes with respect to squashed integers.
	///
	/// \note A generated \c rosa::Token uniquely represents a list of types, except
	/// for \c rosa::AtomConstant types. Observe that any \c rosa::AtomConstant is
	/// encoded as the type \c rosa::AtomValue. The type information on all separate
	/// \c rosa::AtomConstant types are lost and replaced by the \c rosa::AtomValue
	/// type whose actual value needs to be used in order to obtain the original
	/// \c rosa::AtomConstant type and so the full type information on the encoded
	/// \c rosa::TypeList.
	///
	///@{

	/// Declaration of the template.
	///
	/// \tparam List \c rosa::TypeList to generate \c rosa::Token for
	template <typename List> struct TypeListToken;

	/// Implementation using \c rosa::TypeListTokenImpl.
	template <typename... Ts> struct TypeListToken<TypeList<Ts...>> {
	/// \note \c rosa::TypeNumber is computed against \c rosa::squased_t, so let's
	/// do the same here.
	using List = typename SquashedTypeList<TypeList<Ts...>>::Type;
	/// Check the length of the list here.
	/// \note Type validation is done one-by-one in \c rosa::TypeListTokenImpl.
	STATIC_ASSERT((TypeListSize<List>::Value <= token::MaxTokenizableListSize),
	"too long list of types");
	/// The \c rosa::Token for \p List.
	static constexpr Token Value = TypeListTokenImpl<List>::Value;
	};

	///@}

	/// Convenience template to generate \c rosa::Token for a list of types.
	template <typename... Ts> using TypeToken = TypeListToken<TypeList<Ts...>>;

	/// Tells if a given \c rosa::Token is valid.
	///
	/// A \c rosa::Token is considered valid if it can be decoded by the current
	/// software.
	///
	/// \note Validation gives a correct result only when \p T was generated by a
	/// compatible software.
	///
	/// \sa Note for type_token.hpp on compatibility.
	///
	/// \param T \c rosa::Token to validate
	///
	/// \return if \p T is valid
	bool validToken(const Token T);

	/// Tells if a \c rosa::Token does encode an empty list of types.
	///
	/// \param T \c rosa::Token to check
	///
	/// \return if \p T encodes an empty list of types
	bool emptyToken(const Token T);

	/// Tells how many types are encoded in a \c rosa::Token.
	///
	/// \param T \c rosa::Token to check
	///
	/// \return how many types are encoded in \p T
	token_size_t lengthOfToken(const Token T);

	/// Tells the full memory size of the types encoded in a \c rosa::Token.
	///
	/// The full memory size of the types encoded in a \c rosa::Token is the sum of
	/// the separate memory sizes of all the types encoded in the \c rosa::Token.
	///
	/// \param T \c rosa::Token to check
	///
	/// \return full memory size of the types encoded in \p T
	///
	/// \pre \p T is valid:\code
	/// validToken(T)
	/// \endcode
	size_t sizeOfValuesOfToken(const Token T);

	/// Extracts the \c rosa::TypeNumber of the first encoded type of a
	/// \c rosa::Token.
	///
	/// \note The returned type number is not validated.
	///
	/// \param T \c rosa::Token to take the first \c rosa::TypeNumber from
	///
	/// \return the first \c rosa::TypeNumber encoded in \p T
	inline TypeNumber headOfToken(const Token T) {
	return static_cast<TypeNumber>(static_cast<token_t>(T) &
	((1 << token::RepresentationBits) - 1));
	}

	/// Tells the memory size of the first type encoded in a \c rosa::Token.
	///
	/// \param T \c rosa::Token to check the first encoded type of
	///
	/// \return memory size of the first type encoded in \p T
	///
	/// \pre \p T is not empty and valid:\code
	/// !empty(T) && validToken(T)
	/// \endcode
	size_t sizeOfHeadOfToken(const Token T);

	/// Gives the textual representation of the first type encoded in a
	/// \c rosa::Token.
	///
	/// \param T \c rosa::Token to take the name of its first encoded type
	///
	/// \return textual representation of the first type encoded in \p T
	///
	/// \pre \p T is not empty and valid:\code
	/// !empty(T) && validToken(T)
	/// \endcode
	const char *nameOfHeadOfToken(const Token T);

	/// Updates a \c rosa::Token by dropping its first encoded type.
	///
	/// \param [in,out] T \c rosa::Token to drop the first encoded type of
	void dropHeadOfToken(Token &T);

	/// Updates a \c rosa::Token by dropping a number of its first encoded types
	///
	/// \param [in,out] T \c rosa::Token to drop the first \p N encoded types of
	/// \param N the number of types to drop from \p T
	void dropNOfToken(Token &T, const size_t N);

	+/// Tells what type is encoded at Position \p Pos in the \c rosa::Token \p T
	+///
	+/// \param T \c rosa::Token to check
	+/// \param Pos the position to check
	+///
	+/// \return \c rosa::TypeNumber of the type encodeded at position \p Pos of \c
	+/// rosa::Token \p T
	+///
	+/// \pre \p T is valid and it encodes \p Pos types: \code
	+/// validToken(T) && Pos < static_cast<size_t>(lengthOfToken(T))
	+/// \endcode
	+inline TypeNumber typeAtPositionOfToken(const Token T, const size_t Pos) {
	+ ASSERT(validToken(T) && Pos < static_cast<size_t>(lengthOfToken(T)));
	+ Token TT = T;
	+ dropNOfToken(TT, Pos);
	+ return headOfToken(TT);
	+}
	+
	/// Tells if the first encoded type of a \c rosa::Token is a given type.
	///
	/// \tparam Type type to match the first encoded type of \p T against
	///
	/// \param T \c rosa::Token whose first encoded type is to be matched against
	/// \p Type
	///
	/// \return if the first encoded type of \p T is \p Type
	///
	/// \pre \p T is not empty and valid:\code
	/// !empty(T) && validToken(T)
	/// \endcode
	template <typename Type> bool isHeadOfTokenTheSameType(const Token T) {
	ASSERT(!emptyToken(T) && validToken(T));
	return TypeNumberOf<Type>::Value == headOfToken(T);
	}

	} // End namespace rosa

	#endif // ROSA_SUPPORT_TYPE_TOKEN_HPP

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 7:22 PM (14 h, 4 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157320
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions