LocalGuidance
A library that generates velocity references to follow a path.
std_utils Namespace Reference

Namespaces

 traits
 

Classes

class  CompileTimeKey
 
class  CompileTimeKeys
 Defines the compile time keys (ctk) as a variadic template. More...
 
class  CompileTimeKeys< Enum_, CompileTimeKey< Enum_, e_, Name_, id_ >, REST_... >
 
class  CompileTimeKeys< Enum_, KeyType_, REST_... >
 Defines the compile time keys (ctk) of enum type Enum_ but has wrong key entries. More...
 
class  CompileTimeKeys< Enum_, REST_... >
 Defines the compile time keys (ctk) of Enum_ type as a variadic template. More...
 
class  CompileTimeMap
 Defines the compile time map (ctm) as a variadic template. More...
 
class  CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, Key_, Value_ >, REST_... >
 
class  CompileTimeMap< KeyType_, ValueType_, KeyValueType_, REST_... >
 Defines the compile time map (ctm) that maps from KeyType_ to ValueType_ but has wrong key-value pairs. More...
 
class  CompileTimeMap< KeyType_, ValueType_, REST_... >
 Defines the compile time map (ctm) that maps from KeyType_ to ValueType_ as a variadic template. More...
 
class  CompileTimeSet
 Defines the compile time set (cts) as a variadic template. More...
 
class  CompileTimeSet< Type_ >
 Defines the compile time set (cts) that contains Type_ as a variadic template. More...
 
class  CompileTimeSet< Type_, Value_, REST_... >
 Defines the compile time set (cts) that contains Type_ as a variadic template. More...
 
struct  ctk_combine
 Default implementation of transforming keys to another enum type. More...
 
struct  ctk_combine< TransformedEnum_, CompileTimeKeys< Enum1_, Keys1_... >, CompileTimeKeys< Enum2_, Keys2_... >, CompileTimeMap< Enum1_, TransformedEnum_, KV1_... >, CompileTimeMap< Enum2_, TransformedEnum_, KV2_... > >
 Template specialization for CompileTimeKeys / CompileTimeMaps of matching enums. More...
 
struct  ctk_concatenate
 Default implementation of map concatenation. More...
 
struct  ctk_concatenate< Enum_, CompileTimeKeys< Enum_, Keys1_... >, CompileTimeKeys< Enum_, Keys2_... > >
 Template specialization for CompileTimeKeys of same Enum-type. More...
 
struct  ctk_erase
 Default implementation of deletion of a key in keys. More...
 
struct  ctk_erase< Enum_, CompileTimeKeys< Enum_, CompileTimeKey< Enum_, key_enum, key_name, key_id >, Keys_... >, erase_key >
 Template specialization for CompileTimeKeys of same Enum-type. More...
 
struct  ctk_erase< Enum_, CompileTimeKeys< Enum_, Keys_... >, erase_key >
 Template specialization for CompileTimeKeys of same Enum-type (recursion termination) More...
 
struct  ctk_increment_ids
 Default implementation of incrementing the ids of keys. More...
 
struct  ctk_increment_ids< Enum_, CompileTimeKeys< Enum_ >, Increment_ >
 Template specialization for CompileTimeKey of same Enum-type (recursion termination) More...
 
struct  ctk_increment_ids< Enum_, CompileTimeKeys< Enum_, CompileTimeKey< Enum_, key_enum, key_name, key_id >, Keys_... >, Increment_ >
 Template specialization for CompileTimeKey of same Enum-type. More...
 
struct  ctk_insert_back
 Default implementation of back insertion of a key into keys. More...
 
struct  ctk_insert_back< Enum_, CompileTimeKeys< Enum_, Keys_... >, CompileTimeKey< Enum_, key_enum, key_name, key_id > >
 Template specialization for CompileTimeKey of same Enum-type. More...
 
struct  ctk_insert_front
 Default implementation of front insertion of a key into keys. More...
 
struct  ctk_insert_front< Enum_, CompileTimeKeys< Enum_, Keys_... >, CompileTimeKey< Enum_, key_enum, key_name, key_id > >
 Template specialization for CompileTimeKey of same Enum-type. More...
 
struct  ctk_pop_front
 Default implementation of pop a key from front of keys. More...
 
struct  ctk_pop_front< Enum_, CompileTimeKeys< Enum_, CompileTimeKey< Enum_, key_enum, key_name, key_id >, Keys_... > >
 Template specialization for CompileTimeKey of same Enum-type. More...
 
struct  ctk_pop_front_and_decrement
 Default implementation of popping first element and decrementing the ids of keys by 1. More...
 
struct  ctk_pop_front_and_decrement< Enum_, CompileTimeKeys< Enum_, Keys_... > >
 Template specialization for CompileTimeKeys of same Enum-type. More...
 
struct  ctk_transform
 Default implementation of transforming keys to another enum type. More...
 
struct  ctk_transform< TransformedEnum_, CompileTimeKeys< Enum_ >, CompileTimeMap< Enum_, TransformedEnum_, KV_... >, IdOffset_ >
 Template specialization for CompileTimeKeys of same Enum-type (recursion termination) More...
 
struct  ctk_transform< TransformedEnum_, CompileTimeKeys< Enum_, CompileTimeKey< Enum_, key_enum, key_name, key_id >, Keys_... >, CompileTimeMap< Enum_, TransformedEnum_, KV_... >, IdOffset_ >
 Template specialization for CompileTimeKeys of same Enum-type. More...
 
struct  ctm_add_to_values
 Default implementation of adding a given summand to all values in the map. More...
 
struct  ctm_add_to_values< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_ >, summand >
 Template specialization for CompileTimeMap with same ValueType as summand (recursion termination) More...
 
struct  ctm_add_to_values< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, Key_, Value_ >, Kv_... >, summand >
 Template specialization for CompileTimeMap with same ValueType as summand. More...
 
struct  ctm_combine
 Default implementation of combining two map of different key-value types. More...
 
struct  ctm_combine< KeyType_, ValueType_, CompileTimeMap< KeyType1_, ValueType1_, KV1_... >, CompileTimeMap< KeyType2_, ValueType2_, KV2_... >, CompileTimeMap< KeyType1_, KeyType_, KVKeys1_... >, CompileTimeMap< KeyType2_, KeyType_, KVKeys2_... >, CompileTimeMap< ValueType1_, ValueType_, KVValues1_... >, CompileTimeMap< ValueType2_, ValueType_, KVValues2_... > >
 Template specialization for proper KeyMaps and ValueMaps. More...
 
struct  ctm_combine< KeyType_, ValueType_, CompileTimeMap< KeyType1_, ValueType_, KV1_... >, CompileTimeMap< KeyType2_, ValueType_, KV2_... >, CompileTimeMap< KeyType1_, KeyType_, KVKeys1_... >, CompileTimeMap< KeyType2_, KeyType_, KVKeys2_... >, void, void >
 Template specialization for proper KeyMaps and empty ValueMaps. More...
 
struct  ctm_concatenate
 Default implementation of map concatenation. More...
 
struct  ctm_concatenate< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, Kv1_... >, CompileTimeMap< KeyType_, ValueType_, Kv2_... > >
 Template specialization for CompileTimeMaps of same KV-type. More...
 
struct  ctm_erase
 Default implementation of erasing a kv-pair from a map. More...
 
struct  ctm_erase< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, key, value >, KV_... >, erase_key >
 Template specialization for CompileTimeMap with same KeyType as erase_key. More...
 
struct  ctm_erase< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, KV_... >, erase_key >
 Template specialization for CompileTimeMap with same KeyType as erase_key (recursion termination) More...
 
struct  ctm_from_sets
 Default implementation of creating a map out of two sets. More...
 
struct  ctm_from_sets< KeyType_, ValueType_, CompileTimeSet< KeyType_ >, CompileTimeSet< ValueType_ > >
 Template specialization for CompileTimeSets with proper KeyType_/ValueType_ (Recursion termination) More...
 
struct  ctm_from_sets< KeyType_, ValueType_, CompileTimeSet< KeyType_, key, keys... >, CompileTimeSet< ValueType_, value, values... > >
 Template specialization for CompileTimeSets with proper KeyType_/ValueType_. More...
 
struct  ctm_from_subenum
 Default implementation of combining two map of different key-value types. More...
 
struct  ctm_insert_back
 Default implementation of back insertion of a kv-pair into a map. More...
 
struct  ctm_insert_back< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, Kv_... >, KeyValuePair< KeyType_, ValueType_, key, value > >
 Template specialization for CompileTimeMap with same KV Types as KeyValuePair. More...
 
struct  ctm_insert_front
 Default implementation of front insertion of a kv-pair into a map. More...
 
struct  ctm_insert_front< KeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, Kv_... >, KeyValuePair< KeyType_, ValueType_, key, value > >
 Template specialization for CompileTimeMap with same KV Types as KeyValuePair. More...
 
struct  ctm_invert
 Default implementation of inverting a unique map. More...
 
struct  ctm_invert< InvertedKeyType_, InvertedValueType_, CompileTimeMap< InvertedValueType_, InvertedKeyType_ > >
 Template specialization for CompileTimeMap with proper KeyType_ and ValueType_. More...
 
struct  ctm_invert< InvertedKeyType_, InvertedValueType_, CompileTimeMap< InvertedValueType_, InvertedKeyType_, KeyValuePair< InvertedValueType_, InvertedKeyType_, InvertedValue_, InvertedKey_ >, Kv_... > >
 Template specialization for CompileTimeMap with proper KeyType_ and ValueType_. More...
 
struct  ctm_transform
 Default implementation of transforming map to different key-value types. More...
 
struct  ctm_transform< KeyType_, TransformedValueType_, CompileTimeMap< KeyType_, ValueType_ >, void, CompileTimeMap< ValueType_, TransformedValueType_, Values_... > >
 Template specialization for empty KeyMap_ and proper ValueMap_ (recursion termination) More...
 
struct  ctm_transform< KeyType_, TransformedValueType_, CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, Key_, Value_ >, KV_... >, void, CompileTimeMap< ValueType_, TransformedValueType_, Values_... > >
 Template specialization for empty KeyMap_ and proper ValueMap_. More...
 
struct  ctm_transform< TransformedKeyType_, TransformedValueType_, CompileTimeMap< KeyType_, ValueType_ >, CompileTimeMap< KeyType_, TransformedKeyType_, Keys_... >, CompileTimeMap< ValueType_, TransformedValueType_, Values_... > >
 Template specialization for proper KeyMap_ and ValueMap_ (recursion termination) More...
 
struct  ctm_transform< TransformedKeyType_, TransformedValueType_, CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, Key_, Value_ >, KV_... >, CompileTimeMap< KeyType_, TransformedKeyType_, Keys_... >, CompileTimeMap< ValueType_, TransformedValueType_, Values_... > >
 Template specialization for proper KeyMap_ and ValueMap_. More...
 
struct  ctm_transform< TransformedKeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_ >, CompileTimeMap< KeyType_, TransformedKeyType_, Keys_... >, void >
 Template specialization for proper KeyMap_ and empty ValueMap_ (recursion termination) More...
 
struct  ctm_transform< TransformedKeyType_, ValueType_, CompileTimeMap< KeyType_, ValueType_, KeyValuePair< KeyType_, ValueType_, Key_, Value_ >, KV_... >, CompileTimeMap< KeyType_, TransformedKeyType_, Keys_... >, void >
 Template specialization for proper KeyMap_ and empty ValueMap_. More...
 
struct  cts_concatenate
 Default implementation of set concatenation. More...
 
struct  cts_concatenate< Type_, CompileTimeSet< Type_, Values1_... >, CompileTimeSet< Type_, Values2_... > >
 Template specialization for CompileTimeSets of same type. More...
 
struct  cts_erase
 Default implementation of erasing a value from a set. More...
 
struct  cts_erase< Type_, CompileTimeSet< Type_, t, Values_... >, erase_type >
 Template specialization for CompileTimeSet with same Type as erase_type. More...
 
struct  cts_erase< Type_, CompileTimeSet< Type_, Values_... >, erase_type >
 Template specialization for CompileTimeSet with same Type as erase_type (recursion termination) More...
 
struct  cts_from_enum
 Default implementation of generation of a set from an consecutive enum. More...
 
struct  cts_from_sequence
 Default implementation of generation of a set from an index sequence. More...
 
struct  cts_from_sequence< Type_, index_sequence< Ints... > >
 Template specialization for CompileTimeSet with same Type as Value. More...
 
struct  cts_insert_back
 Default implementation of back insertion of a value into a set. More...
 
struct  cts_insert_back< Type_, CompileTimeSet< Type_, Values_... >, value >
 Template specialization for CompileTimeSet with same Type as Value. More...
 
struct  cts_insert_front
 Default implementation of front insertion of a value into a set. More...
 
struct  cts_insert_front< Type_, CompileTimeSet< Type_, Values_... >, value >
 Template specialization for CompileTimeSet with same Type as Value. More...
 
struct  cts_insert_front_if
 Default implementation of conditional front insertion of a value into a set. More...
 
struct  cts_insert_front_if< Type_, CompileTimeSet< Type_, Values_... >, value, Condition_ >
 Template specialization for CompileTimeSet with same Type as Value. More...
 
class  double_less
 
class  enum_iterator
 
class  EnumArray
 
struct  EnumClassHash
 
class  EnumMap
 
struct  integer_sequence
 
struct  is_compile_time_key
 isCompileTimeKey false type More...
 
struct  is_compile_time_key< CompileTimeKey< Enum_, e, Name_, id > >
 isCompileTimeKey true type More...
 
struct  is_compile_time_keys
 isCompileTimeKeys false type More...
 
struct  is_compile_time_keys< CompileTimeKeys< REST_... > >
 isCompileTimeKeys true type More...
 
struct  is_compile_time_map
 isCompileTimeMap false type More...
 
struct  is_compile_time_map< CompileTimeMap< REST_... > >
 isCompileTimeMap true type More...
 
struct  is_compile_time_set
 is_compile_time_set false type More...
 
struct  is_compile_time_set< CompileTimeSet< REST_... > >
 is_compile_time_set true type More...
 
struct  is_enum_array
 is_enum_array false type More...
 
struct  is_enum_array< EnumArray< Enum_, Item_, Size_ > >
 is_enum_array true type More...
 
struct  is_fullsize_enum_array
 is_fullsize_enum_array false type More...
 
struct  is_fullsize_enum_array< EnumArray< Enum_, Item_, static_cast< int >(Enum_::SIZE)> >
 is_fullsize_enum_array true type More...
 
class  Key
 Constexpr type that stores relation of name, id and enum. More...
 
class  KeyArray
 Array of elements. More...
 
struct  KeyValuePair
 Defines the compile time map (ctm) key-value pairs. Ctm consist of a set of key-value pairs. More...
 
struct  KeyValueType
 Defines the types (e.g. int, myEnum) for a compile-time map (ctm) key-value pair. Functions as a base class to KeyValuePair. Used to check the validity of the key-value pairs of the ctm. More...
 
struct  make_integer_sequence
 
struct  make_integer_sequence< T, 0, Is... >
 
struct  make_integer_sequence_range
 
struct  make_integer_sequence_range< T, From, From, Is... >
 
class  MultiKeyContainer
 
class  observer_ptr
 An object which wraps around a pointer without taking ownership. More...
 
class  smart_pointer_iterator
 An iterator for smart pointers which skips the smart pointer layer by exposing a pointer to the internal type. Can used in range-based for loops. More...
 
class  smart_pointer_pair_iterator
 
struct  typestring
 

Typedefs

template<typename Enum_ , typename Keys1_ , typename Keys2_ >
using ctk_concatenate_t = typename ctk_concatenate< Enum_, Keys1_, Keys2_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ , typename Key_ >
using ctk_insert_back_t = typename ctk_insert_back< Enum_, Keys_, Key_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ , typename Key_ >
using ctk_insert_front_t = typename ctk_insert_front< Enum_, Keys_, Key_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ , Enum_ erase_key>
using ctk_erase_t = typename ctk_erase< Enum_, Keys_, erase_key >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ >
using ctk_pop_front_t = typename ctk_pop_front< Enum_, Keys_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ , int Increment_>
using ctk_increment_ids_t = typename ctk_increment_ids< Enum_, Keys_, Increment_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys_ >
using ctk_pop_front_and_decrement_t = typename ctk_pop_front_and_decrement< Enum_, Keys_ >::type
 Helper. More...
 
template<typename TransformedEnum_ , typename Keys_ , typename EnumMap_ , int IdOffset_ = 0>
using ctk_transform_t = typename ctk_transform< TransformedEnum_, Keys_, EnumMap_, IdOffset_ >::type
 Helper. More...
 
template<typename Enum_ , typename Keys1_ , typename Keys2_ , typename MapKeys1_ , typename MapKeys2_ >
using ctk_combine_t = typename ctk_combine< Enum_, Keys1_, Keys2_, MapKeys1_, MapKeys2_ >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map1_ , typename Map2_ >
using ctm_concatenate_t = typename ctm_concatenate< KeyType_, ValueType_, Map1_, Map2_ >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map_ , typename Kv_ >
using ctm_insert_back_t = typename ctm_insert_back< KeyType_, ValueType_, Map_, Kv_ >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map_ , typename Kv_ >
using ctm_insert_front_t = typename ctm_insert_front< KeyType_, ValueType_, Map_, Kv_ >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map_ , KeyType_ erase_key>
using ctm_erase_t = typename ctm_erase< KeyType_, ValueType_, Map_, erase_key >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map_ , ValueType_ summand>
using ctm_add_to_values_t = typename ctm_add_to_values< KeyType_, ValueType_, Map_, summand >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename KeySet_ , typename ValueSet_ >
using ctm_from_sets_t = typename ctm_from_sets< KeyType_, ValueType_, KeySet_, ValueSet_ >::type
 Helper. More...
 
template<typename TransformedKeyType_ , typename TransformedValueType_ , typename Map_ , typename KeyMap_ , typename ValueMap_ = void>
using ctm_transform_t = typename ctm_transform< TransformedKeyType_, TransformedValueType_, Map_, KeyMap_, ValueMap_ >::type
 Helper. More...
 
template<typename KeyType_ , typename ValueType_ , typename Map1_ , typename Map2_ , typename Map1Keys_ , typename Map2Keys_ , typename Map1Values_ = void, typename Map2Values_ = void>
using ctm_combine_t = typename ctm_combine< KeyType_, ValueType_, Map1_, Map2_, Map1Keys_, Map2Keys_, Map1Values_, Map2Values_ >::type
 Helper. More...
 
template<typename Enum_ , typename SubEnum_ , std::size_t Offset_ = 0, std::size_t Skip_ = 0>
using ctm_from_subenum_t = typename ctm_from_subenum< Enum_, SubEnum_, Offset_, Skip_ >::type
 Helper. More...
 
template<typename InvertedKeyType_ , typename InvertedValueType_ , typename Map_ >
using ctm_invert_t = typename ctm_invert< InvertedKeyType_, InvertedValueType_, Map_ >::type
 Helper. More...
 
template<typename Type_ , typename Set1_ , typename Set2_ >
using cts_concatenate_t = typename cts_concatenate< Type_, Set1_, Set2_ >::type
 Helper. More...
 
template<typename Type_ , typename Set_ , Type_ value>
using cts_insert_back_t = typename cts_insert_back< Type_, Set_, value >::type
 Helper. More...
 
template<typename Type_ , typename Set_ , Type_ value>
using cts_insert_front_t = typename cts_insert_front< Type_, Set_, value >::type
 Helper. More...
 
template<typename Type_ , typename Set_ , Type_ erase_type>
using cts_erase_t = typename cts_erase< Type_, Set_, erase_type >::type
 Helper. More...
 
template<typename Type_ , typename Set_ , Type_ value, bool Condition_>
using cts_insert_front_if_t = typename cts_insert_front_if< Type_, Set_, value, Condition_ >::type
 Helper. More...
 
template<typename Type_ , typename Sequence_ >
using cts_from_sequence_t = typename cts_from_sequence< Type_, Sequence_ >::type
 Helper. More...
 
template<typename Type_ , Type_ Terminator_ = Type_::SIZE>
using cts_from_enum_t = typename cts_from_enum< Type_, Terminator_ >::type
 
template<typename... T>
using tycat = decltype(tycat_(T()...))
 
template<typename Key >
using HashType = typename std::conditional< std::is_enum< Key >::value, EnumClassHash, std::hash< Key >>::type
 
template<typename element_type_ , template< typename... > class smart_pointer_ = std::unique_ptr, template< typename... > class container_ = std::vector>
using smart_pointer_container = internal::smart_pointer_container< element_type_, internal::wrapper_vec< container_ >, smart_pointer_ >
 A class wrapping an STL container of smart pointers. More...
 
template<typename key_type_ , typename element_type_ , template< typename... > class smart_pointer_ = std::unique_ptr, template< typename... > class container_ = std::map>
using smart_pointer_dictionary = internal::smart_pointer_container< element_type_, internal::wrapper_map< key_type_, container_ >, smart_pointer_ >
 A class wrapping a map or unordered map of smart pointers. More...
 
template<typename element_type >
using VectorOfUniquePtrs = std_utils::smart_pointer_container< element_type, std::unique_ptr, std::vector >
 A std::vector of std::unique_ptrs to element_type. More...
 
template<typename element_type >
using VectorOfSharedPtrs = std_utils::smart_pointer_container< element_type, std::shared_ptr, std::vector >
 A std::vector of std::shared_ptrs to element_type. More...
 
template<typename element_type >
using VectorOfObserverPtrs = std_utils::smart_pointer_container< element_type, std_utils::observer_ptr, std::vector >
 A std::vector of std_utils::observer_ptrs to element_type. More...
 
template<typename key_type , typename element_type >
using UnorderedMapOfUniquePtrs = std_utils::smart_pointer_dictionary< key_type, element_type, std::unique_ptr, std::unordered_map >
 A std::unordered_map of std::unique_ptrs to element_type. More...
 
template<std::size_t... Ints>
using index_sequence = integer_sequence< std::size_t, Ints... >
 
template<typename T , std::size_t N>
using make_integer_sequence_t = typename make_integer_sequence< T, N >::type
 
template<std::size_t N>
using make_index_sequence_t = typename make_integer_sequence< std::size_t, N >::type
 
template<typename T , std::size_t From, std::size_t To>
using make_integer_sequence_range_t = typename make_integer_sequence_range< T, From, To >::type
 
template<std::size_t From, std::size_t To>
using make_index_sequence_range_t = typename make_integer_sequence_range< std::size_t, From, To >::type
 
template<typename... T>
using index_sequence_for_t = make_index_sequence_t< sizeof...(T)>
 
typedef internal::ChronoTimer< std::chrono::steady_clock > SteadyClockTimer
 
typedef internal::ChronoTimer< std::chrono::system_clock > SystemClockTimer
 
typedef internal::ChronoTimer< std::chrono::high_resolution_clock > HighResolutionClockTimer
 

Functions

template<typename ArrayType , typename EnumeType >
static bool containsEnum (const ArrayType &dimVector, EnumeType dim)
 True if dim is a subset of dimVector. More...
 
template<typename ArrayType1 , typename ArrayType2 >
static bool containsEnums (const ArrayType1 &dimVector, const ArrayType2 &dims)
 True if dims is a subset of dimVector. More...
 
template<typename ArrayType1 , typename ArrayType2 >
static bool consistsOfEnums (const ArrayType1 &dimVector, const ArrayType2 &dims)
 True if dimVector is equal to dims. More...
 
constexpr bool strings_equal (char const *a, char const *b)
 
template<int N, int M>
constexpr char tygrab (char const (&c)[M]) noexcept
 
template<char... X>
auto typoke (typestring< X... >) -> typestring< X... >
 
template<char... X, char... Y>
auto typoke (typestring< X... >, typestring<'\0'>, typestring< Y >...) -> typestring< X... >
 
template<char A, char... X, char... Y>
auto typoke (typestring< X... >, typestring< A >, typestring< Y >...) -> decltype(typoke(typestring< X..., A >(), typestring< Y >()...))
 
template<char... C>
auto typeek (typestring< C... >) -> decltype(typoke(typestring< C >()...))
 
template<char... A, char... B, typename... X>
auto tycat_ (typestring< A... >, typestring< B... >, X...x) -> decltype(tycat_(typestring< A..., B... >(), x...))
 
template<char... X>
auto tycat_ (typestring< X... >) -> typestring< X... >
 
template<typename Enum_ >
constexpr Key< Enum_ > make_key (const Enum_ e, const char *name, const typename Key< Enum_ >::IdType id) noexcept
 C++17 will have template deduction for constructor parameters, until then this helper function is provided. More...
 
template<typename Enum_ >
constexpr Key< Enum_ > make_key (const Enum_ e, const char *name) noexcept
 
template<typename Item_ , typename Enum_ >
static void createMultiKeyContainerFromKeys (const std::list< std::tuple< std::string, unsigned int, Enum_ > > &keys, MultiKeyContainer< Item_, Enum_ > &container, const Item_ &defaultItem)
 
template<typename element_type_ , typename iterator_ >
smart_pointer_iterator< iterator_, element_type_ > dereference_iterator (iterator_ t, typename std::enable_if< std_utils::traits::is_smart_ptr< typename iterator_::value_type >::value >::type *=0)
 Get a smart_pointer_iterator from an iterator to an element of a container of smart pointers. More...
 
template<typename element_type_ , typename iterator_ >
smart_pointer_pair_iterator< iterator_, element_type_ > dereference_iterator (iterator_ t, typename std::enable_if< std_utils::traits::is_pair_of_smart_ptr< typename iterator_::value_type >::value >::type *=0)
 Get a smart_pointer_iterator from an iterator to an element of a container of smart pointers. More...
 
template<typename T , typename... Args>
std::unique_ptr< T > make_unique (Args &&...args)
 
template<class ForwardIt , class UnaryPredicate >
ForwardIt remove_first_if (ForwardIt first, ForwardIt last, UnaryPredicate p)
 

Typedef Documentation

template<typename Enum_ , typename Keys1_ , typename Keys2_ , typename MapKeys1_ , typename MapKeys2_ >
using std_utils::ctk_combine_t = typedef typename ctk_combine<Enum_, Keys1_, Keys2_, MapKeys1_, MapKeys2_>::type

Helper.

template<typename Enum_ , typename Keys1_ , typename Keys2_ >
using std_utils::ctk_concatenate_t = typedef typename ctk_concatenate<Enum_, Keys1_, Keys2_>::type

Helper.

template<typename Enum_ , typename Keys_ , Enum_ erase_key>
using std_utils::ctk_erase_t = typedef typename ctk_erase<Enum_, Keys_, erase_key>::type

Helper.

template<typename Enum_ , typename Keys_ , int Increment_>
using std_utils::ctk_increment_ids_t = typedef typename ctk_increment_ids<Enum_, Keys_, Increment_>::type

Helper.

template<typename Enum_ , typename Keys_ , typename Key_ >
using std_utils::ctk_insert_back_t = typedef typename ctk_insert_back<Enum_, Keys_, Key_>::type

Helper.

template<typename Enum_ , typename Keys_ , typename Key_ >
using std_utils::ctk_insert_front_t = typedef typename ctk_insert_front<Enum_, Keys_, Key_>::type

Helper.

template<typename Enum_ , typename Keys_ >
using std_utils::ctk_pop_front_and_decrement_t = typedef typename ctk_pop_front_and_decrement<Enum_, Keys_>::type

Helper.

template<typename Enum_ , typename Keys_ >
using std_utils::ctk_pop_front_t = typedef typename ctk_pop_front<Enum_, Keys_>::type

Helper.

template<typename TransformedEnum_ , typename Keys_ , typename EnumMap_ , int IdOffset_ = 0>
using std_utils::ctk_transform_t = typedef typename ctk_transform<TransformedEnum_, Keys_, EnumMap_, IdOffset_>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map_ , ValueType_ summand>
using std_utils::ctm_add_to_values_t = typedef typename ctm_add_to_values<KeyType_, ValueType_, Map_, summand>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map1_ , typename Map2_ , typename Map1Keys_ , typename Map2Keys_ , typename Map1Values_ = void, typename Map2Values_ = void>
using std_utils::ctm_combine_t = typedef typename ctm_combine<KeyType_, ValueType_, Map1_, Map2_, Map1Keys_, Map2Keys_, Map1Values_, Map2Values_>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map1_ , typename Map2_ >
using std_utils::ctm_concatenate_t = typedef typename ctm_concatenate<KeyType_, ValueType_, Map1_, Map2_>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map_ , KeyType_ erase_key>
using std_utils::ctm_erase_t = typedef typename ctm_erase<KeyType_, ValueType_, Map_, erase_key>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename KeySet_ , typename ValueSet_ >
using std_utils::ctm_from_sets_t = typedef typename ctm_from_sets<KeyType_, ValueType_, KeySet_, ValueSet_>::type

Helper.

template<typename Enum_ , typename SubEnum_ , std::size_t Offset_ = 0, std::size_t Skip_ = 0>
using std_utils::ctm_from_subenum_t = typedef typename ctm_from_subenum<Enum_, SubEnum_, Offset_, Skip_>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map_ , typename Kv_ >
using std_utils::ctm_insert_back_t = typedef typename ctm_insert_back<KeyType_, ValueType_, Map_, Kv_>::type

Helper.

template<typename KeyType_ , typename ValueType_ , typename Map_ , typename Kv_ >
using std_utils::ctm_insert_front_t = typedef typename ctm_insert_front<KeyType_, ValueType_, Map_, Kv_>::type

Helper.

template<typename InvertedKeyType_ , typename InvertedValueType_ , typename Map_ >
using std_utils::ctm_invert_t = typedef typename ctm_invert<InvertedKeyType_, InvertedValueType_, Map_>::type

Helper.

template<typename TransformedKeyType_ , typename TransformedValueType_ , typename Map_ , typename KeyMap_ , typename ValueMap_ = void>
using std_utils::ctm_transform_t = typedef typename ctm_transform<TransformedKeyType_, TransformedValueType_, Map_, KeyMap_, ValueMap_>::type

Helper.

template<typename Type_ , typename Set1_ , typename Set2_ >
using std_utils::cts_concatenate_t = typedef typename cts_concatenate<Type_, Set1_, Set2_>::type

Helper.

template<typename Type_ , typename Set_ , Type_ erase_type>
using std_utils::cts_erase_t = typedef typename cts_erase<Type_, Set_, erase_type>::type

Helper.

template<typename Type_ , Type_ Terminator_ = Type_::SIZE>
using std_utils::cts_from_enum_t = typedef typename cts_from_enum<Type_, Terminator_>::type
template<typename Type_ , typename Sequence_ >
using std_utils::cts_from_sequence_t = typedef typename cts_from_sequence<Type_, Sequence_>::type

Helper.

template<typename Type_ , typename Set_ , Type_ value>
using std_utils::cts_insert_back_t = typedef typename cts_insert_back<Type_, Set_, value>::type

Helper.

template<typename Type_ , typename Set_ , Type_ value, bool Condition_>
using std_utils::cts_insert_front_if_t = typedef typename cts_insert_front_if<Type_, Set_, value, Condition_>::type

Helper.

template<typename Type_ , typename Set_ , Type_ value>
using std_utils::cts_insert_front_t = typedef typename cts_insert_front<Type_, Set_, value>::type

Helper.

template<typename Key >
using std_utils::HashType = typedef typename std::conditional<std::is_enum<Key>::value, EnumClassHash, std::hash<Key>>::type
typedef internal::ChronoTimer<std::chrono::high_resolution_clock> std_utils::HighResolutionClockTimer
template<std::size_t... Ints>
using std_utils::index_sequence = typedef integer_sequence<std::size_t, Ints...>
template<typename... T>
using std_utils::index_sequence_for_t = typedef make_index_sequence_t<sizeof...(T)>
template<std::size_t From, std::size_t To>
using std_utils::make_index_sequence_range_t = typedef typename make_integer_sequence_range<std::size_t, From, To>::type
template<std::size_t N>
using std_utils::make_index_sequence_t = typedef typename make_integer_sequence<std::size_t, N>::type
template<typename T , std::size_t From, std::size_t To>
using std_utils::make_integer_sequence_range_t = typedef typename make_integer_sequence_range<T, From, To>::type
template<typename T , std::size_t N>
using std_utils::make_integer_sequence_t = typedef typename make_integer_sequence<T, N>::type
template<typename element_type_ , template< typename... > class smart_pointer_ = std::unique_ptr, template< typename... > class container_ = std::vector>
using std_utils::smart_pointer_container = typedef internal::smart_pointer_container< element_type_, internal::wrapper_vec<container_>, smart_pointer_>

A class wrapping an STL container of smart pointers.

template<typename key_type_ , typename element_type_ , template< typename... > class smart_pointer_ = std::unique_ptr, template< typename... > class container_ = std::map>
using std_utils::smart_pointer_dictionary = typedef internal::smart_pointer_container< element_type_, internal::wrapper_map<key_type_, container_>, smart_pointer_>

A class wrapping a map or unordered map of smart pointers.

typedef internal::ChronoTimer<std::chrono::steady_clock> std_utils::SteadyClockTimer
typedef internal::ChronoTimer<std::chrono::system_clock> std_utils::SystemClockTimer
template<typename... T>
using std_utils::tycat = typedef decltype(tycat_(T()...))
template<typename key_type , typename element_type >
using std_utils::UnorderedMapOfUniquePtrs = typedef std_utils::smart_pointer_dictionary<key_type, element_type, std::unique_ptr, std::unordered_map>

A std::unordered_map of std::unique_ptrs to element_type.

template<typename element_type >
using std_utils::VectorOfObserverPtrs = typedef std_utils::smart_pointer_container<element_type, std_utils::observer_ptr, std::vector>

A std::vector of std_utils::observer_ptrs to element_type.

template<typename element_type >
using std_utils::VectorOfSharedPtrs = typedef std_utils::smart_pointer_container<element_type, std::shared_ptr, std::vector>

A std::vector of std::shared_ptrs to element_type.

template<typename element_type >
using std_utils::VectorOfUniquePtrs = typedef std_utils::smart_pointer_container<element_type, std::unique_ptr, std::vector>

A std::vector of std::unique_ptrs to element_type.

Function Documentation

template<typename ArrayType1 , typename ArrayType2 >
static bool std_utils::consistsOfEnums ( const ArrayType1 &  dimVector,
const ArrayType2 &  dims 
)
static

True if dimVector is equal to dims.

template<typename ArrayType , typename EnumeType >
static bool std_utils::containsEnum ( const ArrayType &  dimVector,
EnumeType  dim 
)
inlinestatic

True if dim is a subset of dimVector.

template<typename ArrayType1 , typename ArrayType2 >
static bool std_utils::containsEnums ( const ArrayType1 &  dimVector,
const ArrayType2 &  dims 
)
static

True if dims is a subset of dimVector.

template<typename Item_ , typename Enum_ >
static void std_utils::createMultiKeyContainerFromKeys ( const std::list< std::tuple< std::string, unsigned int, Enum_ > > &  keys,
MultiKeyContainer< Item_, Enum_ > &  container,
const Item_ &  defaultItem 
)
static
template<typename element_type_ , typename iterator_ >
smart_pointer_iterator<iterator_, element_type_> std_utils::dereference_iterator ( iterator_  t,
typename std::enable_if< std_utils::traits::is_smart_ptr< typename iterator_::value_type >::value >::type *  = 0 
)

Get a smart_pointer_iterator from an iterator to an element of a container of smart pointers.

template<typename element_type_ , typename iterator_ >
smart_pointer_pair_iterator<iterator_, element_type_> std_utils::dereference_iterator ( iterator_  t,
typename std::enable_if< std_utils::traits::is_pair_of_smart_ptr< typename iterator_::value_type >::value >::type *  = 0 
)

Get a smart_pointer_iterator from an iterator to an element of a container of smart pointers.

template<typename Enum_ >
constexpr Key<Enum_> std_utils::make_key ( const Enum_  e,
const char *  name,
const typename Key< Enum_ >::IdType  id 
)
noexcept

C++17 will have template deduction for constructor parameters, until then this helper function is provided.

template<typename Enum_ >
constexpr Key<Enum_> std_utils::make_key ( const Enum_  e,
const char *  name 
)
noexcept
template<typename T , typename... Args>
std::unique_ptr<T> std_utils::make_unique ( Args &&...  args)
template<class ForwardIt , class UnaryPredicate >
ForwardIt std_utils::remove_first_if ( ForwardIt  first,
ForwardIt  last,
UnaryPredicate  p 
)
constexpr bool std_utils::strings_equal ( char const *  a,
char const *  b 
)
template<char... A, char... B, typename... X>
auto std_utils::tycat_ ( typestring< A... >  ,
typestring< B... >  ,
X...  x 
) -> decltype(tycat_(typestring< A..., B... >(), x...))
template<char... X>
auto std_utils::tycat_ ( typestring< X... >  ) -> typestring< X... >
template<int N, int M>
constexpr char std_utils::tygrab ( char const (&)  c[M])
noexcept
template<char... C>
auto std_utils::typeek ( typestring< C... >  ) -> decltype(typoke(typestring< C >()...))
template<char... X>
auto std_utils::typoke ( typestring< X... >  ) -> typestring< X... >
template<char... X, char... Y>
auto std_utils::typoke ( typestring< X... >  ,
typestring<'\0'>  ,
typestring< Y >  ... 
) -> typestring< X... >
template<char A, char... X, char... Y>
auto std_utils::typoke ( typestring< X... >  ,
typestring< A >  ,
typestring< Y >  ... 
) -> decltype(typoke(typestring< X..., A >(), typestring< Y >()...))