Page MenuHomePhorge
Files F386502

No OneTemporary
Actions

Size
15 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/include/rosa/deluxe/DeluxeTuple.hpp b/include/rosa/deluxe/DeluxeTuple.hpp
index 9e26950..743872d 100644
--- a/include/rosa/deluxe/DeluxeTuple.hpp
+++ b/include/rosa/deluxe/DeluxeTuple.hpp
@@ -1,465 +1,465 @@
//===-- rosa/deluxe/DeluxeTuple.hpp -----------------------------*- C++ -*-===//
//
// The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \file rosa/deluxe/DeluxeTuple.hpp
///
/// \author David Juhasz (david.juhasz@tuwien.ac.at)
///
/// \date 2019
///
/// \brief Facilities for handling multiple input/output values for connections
/// in the *deluxe interface*.
///
/// \see \c rosa::deluxe::DeluxeContext
///
//===----------------------------------------------------------------------===//
#ifndef ROSA_DELUXE_DELUXETUPLE_HPP
#define ROSA_DELUXE_DELUXETUPLE_HPP
#include "rosa/support/sequence.hpp"
#include "rosa/support/type_token.hpp"
#include <ostream>
#include <tuple>
namespace rosa {
namespace deluxe {
/// A tuple to manage multiple input/output values in the *deluxe interface*.
///
/// \tparam Ts types of elements of the tuple
///
/// \note The template may be instantiated only with built-in types and the
/// number of those type may not exceed the capacity of a \c rosa::Token.
template <typename... Ts>
struct DeluxeTuple : public std::tuple<Ts...> {
// Statically enforce that the class template is instantiated only with
// built-in types.
STATIC_ASSERT((TypeListSubsetOf<TypeList<Ts...>, BuiltinTypes>::Value),
"not built-in types");
// Statically enforce that the class template is instantiated with not too
// many types.
// \note Instantiation would fail on \c rosa::deluxe::DeluxeTuple::TT if there
- // are too any types; this assertion is for more readable error reporting.
+ // are too many types; this assertion is for more readable error reporting.
STATIC_ASSERT(sizeof...(Ts) <= token::MaxTokenizableListSize,
"Too many types");
/// How many elements the instance has.
static constexpr token_size_t Length = sizeof...(Ts);
/// What types the class contains.
///
/// Type information encoded as \c rosa::Token.
static constexpr Token TT = TypeToken<Ts...>::Value;
/// Default constructor, zero-initializes elements.
DeluxeTuple(void) = default;
/// Constructor, initializes the underlying \c std::tuple with lvalue
/// references.
///
/// \param Args value references to the values to store
DeluxeTuple(const std::decay_t<Ts> &... Args) : std::tuple<Ts...>(Args...) {}
/// Constructor, initializes the underlying \c std::tuple with rvalue
/// references.
///
/// \param Args rvalue references to the values to store
DeluxeTuple(std::decay_t<Ts> &&... Args)
: std::tuple<Ts...>(std::move(Args)...) {}
/// Contructor, initializes the underlying \c std::tuple from another matching
/// \c std::tuple.
DeluxeTuple(const std::tuple<Ts...> &Args) : std::tuple<Ts...>(Args) {}
/// Default copy-constructor.
DeluxeTuple(const DeluxeTuple &) = default;
/// Default move-constructor.
DeluxeTuple(DeluxeTuple &&) = default;
/// Default copy-assignment.
DeluxeTuple &operator=(const DeluxeTuple &) = default;
/// Default move-assignment.
DeluxeTuple &operator=(DeluxeTuple &&) = default;
private:
/// Dumps \p this object to a given \c std::ostream.
///
/// \note Provides implementation for \c rosa::deluxe::DeluxeTuple::dump.
///
/// \tparam S0 Indices for accessing elements.
///
/// \param [in,out] OS output stream to dump to
///
/// \note The second argument provides indices statically as template
/// arguments \p S0..., so its actual value is ignored.
///
/// \pre Statically, \p S0... matches number of types \p this object was
/// created: \code
/// sizeof...(S0) == sizeof...(Ts)
/// \endcode
template <size_t... S0>
void dump(std::ostream &OS, Seq<S0...>) const noexcept;
public:
/// Dumps \p this object to a given \c std::ostream.
///
/// \param [in,out] OS output stream to dump to
void dump(std::ostream &OS) const noexcept;
};
template <typename... Ts>
template <size_t... S0>
void DeluxeTuple<Ts...>::dump(std::ostream &OS, Seq<S0...>) const noexcept {
STATIC_ASSERT(sizeof...(S0) == sizeof...(Ts), "inconsistent type arguments");
// Convert value to std::string with std::to_string except for a value of
// std::string that does not need conversion.
auto dump_to_string = [](const auto &V) {
if constexpr (std::is_same<std::decay_t<decltype(V)>, std::string>::value) {
return V;
} else {
return std::to_string(V);
}
};
OS << "{";
(OS << ... << (" " + dump_to_string(std::get<S0>(*this))));
OS << " }";
}
template <typename... Ts>
void DeluxeTuple<Ts...>::dump(std::ostream &OS) const noexcept {
dump(OS, seq_t<sizeof...(Ts)>());
}
/// Type alias for a \c rosa::deluxe::DeluxeTuple that contains no elements.
using EmptyDeluxeTuple = DeluxeTuple<>;
/// Template specialization for \c rosa::deluxe::EmptyDeluxeTuple.
template <> struct DeluxeTuple<> : public std::tuple<> {
/// How many elements the instance has.
static constexpr token_size_t Length = 0;
/// What types the class contains.
///
/// Type information encoded as \c rosa::Token.
static constexpr Token TT = TypeToken<>::Value;
/// Constructor, initializes the underlying \c std::tuple.
DeluxeTuple(void) : std::tuple<>() {}
/// Default copy-constructor.
DeluxeTuple(const DeluxeTuple &) = default;
// Default move-constructor.
DeluxeTuple(DeluxeTuple &&) = default;
/// Default copy-assignment.
DeluxeTuple &operator=(const DeluxeTuple &) = default;
// Default move-assignment,
DeluxeTuple &operator=(DeluxeTuple &&) = default;
/// Dumps \p this object to a given \c std::ostream.
///
/// \param [in,out] OS output stream to dump to
static void dump(std::ostream &OS) noexcept;
};
/// Creates a \c rosa::deluxe::DeluxeTuple instance from the given lvalues
/// references.
///
/// \tparam Ts types of elements of the tuple
///
/// \see \c rosa::deluxe::DeluxeTuple
///
/// \param Args values to store in the tuple
///
/// \return an instance of \c rosa::deluxe::DeluxeTuple<Ts...> with \p Args as
/// elements
template <typename... Ts>
inline DeluxeTuple<Ts...> make_deluxe_tuple(const Ts &... Args) noexcept {
return DeluxeTuple<Ts...>(Args...);
}
/// Creates a \c rosa::deluxe::DeluxeTuple instance from the given rvalue
/// references.
///
/// \tparam Ts types of elements of the tuple
///
/// \see \c rosa::deluxe::DeluxeTuple
///
/// \param Args values to store in the tuple
///
/// \return an instance of \c rosa::deluxe::DeluxeTuple<Ts...> with \p Args as
/// elements
template <typename... Ts>
inline DeluxeTuple<Ts...> make_deluxe_tuple(Ts&&... Args) noexcept {
return DeluxeTuple<Ts...>(std::move(Args)...);
}
/// Creates a \c rosa::deluxe::DeluxeTuple instance from the given \c std::tuple
/// reference.
///
/// \tparam Ts types of elements of the tuple
///
/// \see \c rosa::deluxe::DeluxeTuple
///
/// \param Args values to store in the tuple
///
/// \return an instance of \c rosa::deluxe::DeluxeTuple<Ts...> with \p Args as
/// elements
template <typename... Ts>
inline DeluxeTuple<Ts...>
make_deluxe_tuple(const std::tuple<Ts...> &Args) noexcept {
return DeluxeTuple<Ts...>(Args);
}
/// \defgroup UnwrapDeluxeTuple Implementation of
/// rosa::deluxe::UnwrapDeluxeTuple
///
/// \brief Unwraps element types from an instance of \c
/// rosa::deluxe::DeluxeTuple into a \c rosa::TypeList
///
/// Types can be unwrapped from a \c rosa::deluxe::DeluxeTuple instance as \code
/// typename UnwrapDeluxeTuple<List>::Type
/// \endcode
///
/// For example, the following expression evaluates to `true`: \code
/// std::is_same<typename UnwrapDeluxeTuple<DeluxeTuple<T1, T2>>::Type,
/// TypeList<T1, T2>>::value
/// \endcode
///@{
/// Declaration of the template.
///
/// \tparam Tuple \c rosa::deluxe::DeluxeTuple to unwrap
template <typename Tuple> struct UnwrapDeluxeTuple;
/// Implementation of the template for \c rosa::deluxe::DeluxeTuple instances.
template <typename... Ts> struct UnwrapDeluxeTuple<DeluxeTuple<Ts...>> {
using Type = TypeList<Ts...>;
};
///@}
/// \defgroup TypeListUnwrapDeluxeTuple Implementation of
/// \c rosa::deluxe::TypeListUnwrapDeluxeTuple
///
/// \brief Unwraps element types from instances of \c
/// rosa::deluxe::DeluxeTuple in a \c rosa::TypeList.
///
/// Types can be unwrapped from \c rosa::deluxe::DeluxeTuple instances as \code
/// typename TypeListUnwrapDeluxeTuple<List>::Type
/// \endcode
///
/// For example, the following expression evaluates to `true`: \code
/// std::is_same<
/// typename TypeListUnwrapDeluxeTuple<TypeList<T0,
/// DeluxeTuple<T1, T2>,
/// T3>>::Type,
/// TypeList<T0, T1, T2, T3>
/// >::value
/// \endcode
///@{
/// Declaration of the template.
///
/// \tparam List \c rosa::TypeList to check
template <typename List> struct TypeListUnwrapDeluxeTuple;
/// Specialization for \c rosa::EmptyTypeList.
template <> struct TypeListUnwrapDeluxeTuple<EmptyTypeList> {
using Type = EmptyTypeList;
};
/// Specialization for the case when the first type in \p List is an instance of
/// \c rosa::deluxe::DeluxeTuple.
template <typename... As, typename... Ts>
struct TypeListUnwrapDeluxeTuple<TypeList<DeluxeTuple<As...>, Ts...>> {
using Type = typename TypeListConcat<
typename UnwrapDeluxeTuple<DeluxeTuple<As...>>::Type,
typename TypeListUnwrapDeluxeTuple<TypeList<Ts...>>::Type>::Type;
};
/// Implementation for a general first type in \p List.
template <typename T, typename... Ts>
struct TypeListUnwrapDeluxeTuple<TypeList<T, Ts...>> {
using Type = typename TypeListPush<
T, typename TypeListUnwrapDeluxeTuple<TypeList<Ts...>>::Type>::Type;
};
///@}
/// \defgroup IsTuple Implementation of \c rosa::deluxe::IsTuple
///
/// \brief Tells if a type is a tuple as in it can be converted to \c
/// rosa::deluxe::DeluxeTuple.
///
/// \see \c rosa::deluxe::MatchingDeluxeTuple
///
/// Whether a type \c T is a tuple can be checked as \code
/// IsTuple<T>::Value
/// \endcode
///@{
/// Declaration of the template.
///
/// \tparam T type to check
template <typename T> struct IsTuple;
/// Specialization for the case when the type is an instance of \c std::tuple.
template <typename... Ts> struct IsTuple<std::tuple<Ts...>> {
static constexpr bool Value = true;
};
/// Specialization for the case when the type is an instance of \c std::tuple.
template <typename... Ts> struct IsTuple<DeluxeTuple<Ts...>> {
static constexpr bool Value = true;
};
/// Implementation for a general case of type \p T.
template <typename T> struct IsTuple { static constexpr bool Value = false; };
///@}
/// \defgroup IsDeluxeTuple Implementation of \c rosa::deluxe::IsDeluxeTuple
///
/// \brief Tells if a type is an instance of \c rosa::deluxe::DeluxeTuple.
///
/// Whether a type \c T is an instance of \c rosa::deluxe::DeluxeTuple can be
/// checked as \code
/// IsDeluxeTuple<T>::Value
/// \endcode
///
/// \note `!IsDeluxeTuple<T>::Value || IsTuple<T>::Value`
///@{
/// Declaration of the template.
///
/// \tparam T type to check
template <typename T> struct IsDeluxeTuple;
/// Specialization for the case when the type is an instance of \c
/// rosa::deluxe::DeluxeTuple.
template <typename... Ts>
struct IsDeluxeTuple<DeluxeTuple<Ts...>> {
static constexpr bool Value = true;
};
/// Implementation for a general case of type \p T.
template <typename T>
struct IsDeluxeTuple {
static constexpr bool Value = false;
};
///@}
/// \defgroup MatchingDeluxeTuple Implementation of \c
/// rosa::deluxe::MatchingDeluxeTuple
///
/// \brief Gives the \c rosa::deluxe::DeluxeTuple type that matches a given
/// tuple type.
///
/// The matching \c rosa::deluxe::DeluxeTuple type for a tuple type \p T can be
/// obtained as \code
/// typename MatchingDeluxeTuple<T>::Type
/// \endcode
/// If \p T is \c rosa::deluxe::DeluxeTuple, the matching type is \p T itself.
/// If \p T is \c std::tuple, the matching type if \c rosa::deluxe::DeluxeTuple
/// with the same type parameters as \p T.
/// \c rosa::deluxe::MatchingDeluxeTuple is not defined for other type
/// parameters.
///
/// \note The template is defined for type \p T only if
/// `rosa::deluxe::IsTuple<T>::Value`. Values of such types can be used to
/// construct a new instance of the class \c rosa::deluxe::DeluxeTuple.
///
///\see \c rosa::deluxe::IsTuple
///@{
/// Declaration of the template.
///
/// \tparam T type to check
template <typename T> struct MatchingDeluxeTuple;
/// Specialization for the case when the type is an instance of \c
/// rosa::deluxe::DeluxeTuple.
template <typename... Ts> struct MatchingDeluxeTuple<DeluxeTuple<Ts...>> {
using Type = DeluxeTuple<Ts...>;
};
/// Specialization for the case when the type is an instance of \c
/// std::tuple.
template <typename... Ts> struct MatchingDeluxeTuple<std::tuple<Ts...>> {
using Type = DeluxeTuple<Ts...>;
};
///@}
/// Convenience template type alias for easy use of \c
/// rosa::deluxe::MatchingDeluxeTuple.
///
/// Converts a tuple type to the matching \c rosa::deluxe::DeluxeTuple type.
///
/// \tparam Tuple type to convert
template <typename Tuple>
using matching_deluxe_tuple_t = typename MatchingDeluxeTuple<Tuple>::Type;
/// \defgroup TypeListAllDeluxeTuple Implementation of
/// \c rosa::deluxe::TypeListAllDeluxeTuple
///
/// \brief Tells if all types in a \c rosa::TypeList is an instance of \c
/// rosa::deluxe::DeluxeTuple.
///
/// Whether a \c rosa::TypeList \c List contains instances of \c
/// rosa::deluxe::DeluxeTuple only can be checked as \code
/// TypeListAllDeluxeTuple<List>::Value
/// \endcode
///@{
/// Declaration of the template.
///
/// \tparam List \c rosa::TypeList to check
template <typename List> struct TypeListAllDeluxeTuple;
/// Specialization for \c rosa::EmptyTypeList.
template <> struct TypeListAllDeluxeTuple<EmptyTypeList> {
static constexpr bool Value = true;
};
/// Implementation for the general case when there is at leasst one element in
/// the list.
template <typename T, typename... Ts>
struct TypeListAllDeluxeTuple<TypeList<T, Ts...>> {
static constexpr bool Value =
IsDeluxeTuple<T>::Value && TypeListAllDeluxeTuple<TypeList<Ts...>>::Value;
};
///@}
} // End namespace deluxe
} // End namespace rosa
namespace std {
/// Dumps a \c rosa::deluxe::Deluxe instance to a given \c std::ostream.
///
/// \param [in,out] OS output stream to dump to
/// \param Tuple \c rosa::deluxe::Deluxe to dump
///
/// \return \p OS after dumping \p Tuple to it
template <typename... Ts>
ostream &operator<<(ostream &OS,
const rosa::deluxe::DeluxeTuple<Ts...> &Tuple) {
Tuple.dump(OS);
return OS;
}
} // End namespace std
#endif // ROSA_DELUXE_DELUXETUPLE_HPP

File Metadata

Mime Type
text/x-diff
Expires
Thu, Jul 3, 7:02 PM (13 h, 14 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
157310
Default Alt Text
(15 KB)

Event Timeline