|
Algorithms Library Toolkit
A toolkit for algorithms, especially for algorithms on formal languages
|
Namespaces | |
| namespace | detail |
| namespace | internal |
Data Structures | |
| class | all_of |
| class | any_of |
| class | AnyaryNode |
| Tree node with any but fixed number of children. More... | |
| class | array |
| Class extending the array class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | BaseNode |
| Base class for hierarchy of tree node types. The tree node types can be used to construct tree structures of different types of nodes. More... | |
| class | BasicLexer |
| class | BinaryNode |
| Binary node is specialisation of Anyary node to two children. More... | |
| class | bitset |
| Class extending the bitset class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | callback_iterator |
| Output iterator calling a callback function on assignment. More... | |
| struct | casional |
| struct | casional< > |
| struct | casional< std::false_type, R, Ts ... > |
| struct | casional< std::true_type, R, Ts ... > |
| struct | casional< T > |
| class | const_tuple_foreach |
| Class providing begin and end methods to allow simple use of packed iterators in foreach variant of the for loop. More... | |
| class | const_tuple_foreach_iterator |
| A class for packing a tuple of iterators and synchronizing them. All are incremented, decremented, dereferenced together. More... | |
| class | cow_shared_ptr |
| Specialisation of copy on write pointer for classes based with copy on write pointer base. More... | |
| class | deque |
| Class extending the deque class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | dereferencing_iterator |
| Adaptor iterator to additionally call second dereference on the iterator dereference result. More... | |
| class | fdaccessor |
| A class determining the used file descriptor from prefered (if available) and fallback file descriptor. More... | |
| class | fdstreambuf |
| Class representing buffered stream designed to work on defined file descriptor instead of usual file name. More... | |
| class | FixedaryNode |
| Fixedary node is tree node that when initialized does not permit change of the number of its children. More... | |
| class | forward_list |
| Class extending the forward_list class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | forward_tree |
| Class introducing a forward_tree with interface trying to be close to the interface of standard library containers. More... | |
| struct | has_clone |
| Type trait to determine existence of clone method. A boolean field namd value is set to true if provided class (possibly cv-qualified and via reference) has clone method. More... | |
| class | ifdstream |
| A class implementing an input stream interface, with destination specified by file descriptor. More... | |
| class | ifstream |
| struct | index_in |
| Trait to get index of type T is in a types pack. The trait provides field value set to an integral value equal to the position of type T is in the pack of types Ts ..., sizeof ... ( Ts ) otherwise. More... | |
| struct | index_in< T > |
| Specialisation for empty pack, in which case the field is set to false. More... | |
| struct | index_in< T, T, Ts ... > |
| Trait to test whether type T is in a types pack. The trait provides field value set to true if the type T is in pack of types Ts ..., false othervise. More... | |
| struct | index_in< T, U, Ts ... > |
| Specialisation for non-empty pack where the first type in the pack is different from the tested type, in which case the field is set to result of the recursive test on shorter pack. More... | |
| class | Init |
| Class responsible for initialisation of std extensions and standard library changes. More... | |
| class | istream |
| class | istringstream |
| class | iterator_range |
| Implementation of iterator_range, i.e. pair of iterators. The class provides most notably begin and end methods to allow the class be used in foreach context. More... | |
| class | key_iterator |
| class | Lexer |
| class | linear_set |
| Implementation of set mimicking the iterface of the standard library set. The inner representation is using sorted vector of unique value. More... | |
| class | list |
| Class extending the list class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | managed_linear_set |
| Implementation of set mimicking the iterface of the standard library set. The inner representation is using sorted vector of unique value. More... | |
| class | managed_value |
| Implementation of managed value mimicking the behavior of the underlying value. The class is designed to fire change events when the value is modified. More... | |
| class | map |
| Class extending the map class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | map_move_iterator |
| Adaptor iterator to allow values to be moved from a map. Internaly calls reinterpret cast to dereference result of underlying map iterator. More... | |
| class | multimap |
| Class extending the multimap class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | multiset |
| class | none_of |
| class | NullaryNode |
| Nullary node is specialisation of Anyary node to no children. More... | |
| class | ofdstream |
| A class implementing an output stream interface, with destination specified by file descriptor. More... | |
| class | ofstream |
| class | optional_ref |
| class | ostream |
| class | ostringstream |
| class | pair |
| Class extending the pair class from the standard library. Original reason is to allow printing of the pair with overloaded operator <<. More... | |
| class | PolyComp |
| class | ptr_array |
| Implementation of array storing dynamicaly allocated instances of given type. The class mimicks the iterface of the standard library array, but effectively allows polymorphic objects to be stored inside. More... | |
| class | ptr_tuple |
| Implementation of tuple storing dynamicaly allocated instances of given type. The class mimicks the iterface of the standard library tuple, but effectively allows polymorphic objects to be stored inside. More... | |
| class | ptr_value |
| Class representing wrapper of dynamically allocated object behaving like rvalue reference. More... | |
| class | ptr_vector |
| Implementation of vector storing dynamicaly allocated instances of given type. The class mimicks the iterface of the standard library vector, but effectively allows polymorphic objects to be stored inside. More... | |
| class | random_devices |
| Definition of randomness sources. Provided sources are c++ builtin random_device and own semirandom_device. The random device is the best randomness source but its generation is slow. Semirandom device is good enough and it provices random values fast. Given a seed the semirandom device can also provide reproducible sequence any number of times. More... | |
| class | reference_mover |
| Adaptor class to change begin and end behavior for rvalue qualified begin and end. This class keeps rvalue reference of the adapted instance. More... | |
| class | reference_wrapper |
| Class extending the reference wrapper class from the standard library. Original reason is to allow its use with standard stream aggregation class. More... | |
| class | Register |
| class | Register< void > |
| class | reverser |
| Adaptor class to change begin and end behavior for reverse begin and reverse end and vise versa. More... | |
| class | sequence |
| Representation of integer sequence usable in foreach form of for loop. More... | |
| class | set |
| class | set_move_iterator |
| Adaptor iterator to allow values to be moved from a set. Internaly calls const cast to dereference result of underlying set iterator. More... | |
| class | SigHandler |
| Singleton class providing interupt or segmentation fault signal handler. More... | |
| class | SliceComp |
| class | smart_ptr |
| Managed pointer simulating value like behavior. More... | |
| class | string |
| struct | strip_reference_wrapper |
| struct | strip_reference_wrapper< std::reference_wrapper< T > > |
| struct | supports |
| struct | supports< F(Ts ...) > |
| class | TernaryNode |
| Ternany node is specialisation of Anyary node to three children. More... | |
| class | tree |
| Class introducing a tree with interface trying to be close to the interface of standard library containers. More... | |
| class | trie |
| Class introducing a trie with interface trying to be close to the interface of standard library containers. More... | |
| class | tuple |
| Class extending the tuple class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | type_index |
| class | UnaryNode |
| Unary node is specialisation of Anyary node to one child. More... | |
| class | unordered_map |
| Class extending the unordered_map class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | value_iterator |
| class | value_mover |
| Adaptor class to change begin and end behavior for rvalue qualified begin and end. This class takes ownership of the adapted instance by move construction. More... | |
| class | VararyNode |
| Varary node is tree node that can hold any number of children. More... | |
| class | variant |
| Implementation of the variant class allowing to store any type of those listed in the template parameters. Void type is allowed, multiply specified same type is irrelevant. More... | |
| struct | variant_builder_impl |
| Class to help building of the variant type or, in case variant is requested to be constructed from single type or more types but all the same, that concrete type. More... | |
| struct | variant_builder_impl< std::variant< ResTs ... > > |
| Recursion ending specialisation of the helper class to build the variant type. The last type T is added as last type to the variant parameters. More... | |
| struct | variant_builder_impl< std::variant< ResTs ... >, T, Ts ... > |
| Recursive step of class to build the variant type. More... | |
| struct | variant_builder_start |
| class | vector |
| Class extending the vector class from the standard library. Original reason is to allow printing of the container with overloaded operator <<. More... | |
| class | virtual_pointer_to_integer |
| Class wrapping an integral type, but with pointer iterface. More... | |
Concepts | |
| concept | Included |
| Concept to test whether type T is in a types pack. The trait provides field value set to true if the type T is in pack of types Ts ..., false othervise. | |
Typedefs | |
| template<class ... Ts> | |
| using | std_variant = typename variant_builder_start< Ts ... >::std_variant |
| template<typename T , typename ... Ts> | |
| using | is_in = std::integral_constant< bool,(std::is_same< T, Ts >::value||...) > |
| Trait to test whether type T is in a types pack. The trait provides field value set to true if the type T is in pack of types Ts ..., false othervise. More... | |
| template<bool value> | |
| using | boolean = typename std::conditional< value, std::true_type, std::false_type >::type |
Functions | |
| int | callback (struct dl_phdr_info *info, size_t, void *data) |
| void | simpleStacktrace (std::ostream &, unsigned int) |
| void | simpleStacktrace (ext::ostream &out, unsigned int max_frames=1000) |
| Analyzes the backtrace (stack trace) and creates its sring representation, one function call per line. More... | |
| std::ostream & | operator<< (ext::reference_wrapper< std::ostream > &os, std::ostream &(*func)(std::ostream &)) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ostream class. More... | |
| std::ostream & | operator<< (ext::reference_wrapper< std::ostream > &os, std::ios_base &(*func)(std::ios_base &)) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ios_base class. More... | |
| ext::ostream & | operator<< (ext::reference_wrapper< ext::ostream > &os, std::ostream &(*func)(std::ostream &)) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ostream class. More... | |
| ext::ostream & | operator<< (ext::reference_wrapper< ext::ostream > &os, std::ios_base &(*func)(std::ios_base &)) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ios_base class. More... | |
| std::istream & | operator>> (ext::reference_wrapper< std::istream > &is, std::istream &(*func)(std::istream &)) |
| Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of istream class. More... | |
| std::istream & | operator>> (ext::reference_wrapper< std::istream > &is, std::ios_base &(*func)(std::ios_base &)) |
| Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of ios_base class. More... | |
| ext::istream & | operator>> (ext::reference_wrapper< ext::istream > &is, std::istream &(*func)(std::istream &)) |
| Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of istream class. More... | |
| ext::istream & | operator>> (ext::reference_wrapper< ext::istream > &is, std::ios_base &(*func)(std::ios_base &)) |
| Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of ios_base class. More... | |
| template<class T > | |
| std::ostream & | operator<< (ext::reference_wrapper< std::ostream > &os, const T &data) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for constant lvalue referenced objects. More... | |
| template<class T > | |
| std::ostream & | operator<< (ext::reference_wrapper< std::ostream > &os, T &&data) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for rvalue referenced objects. More... | |
| template<class T > | |
| ext::ostream & | operator<< (ext::reference_wrapper< ext::ostream > &os, const T &data) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for constant lvalue referenced objects. More... | |
| template<class T > | |
| ext::ostream & | operator<< (ext::reference_wrapper< ext::ostream > &os, T &&data) |
| Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for rvalue referenced objects. More... | |
| template<class T > | |
| std::istream & | operator>> (ext::reference_wrapper< std::istream > &is, T &data) |
| Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for lvalue referenced objects. More... | |
| template<class InputIt1 , class InputIt2 , class Compare > | |
| bool | excludes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp) |
| Tests two sorted ranges wheter all elements from the second are not present in the first. More... | |
| template<class InputIt1 , class InputIt2 > | |
| bool | excludes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) |
| Tests two sorted ranges wheter all elements from the second are not present in the first. More... | |
| template<class InputIterator1 , class InputIterator2 , class OutputIterator1 , class OutputIterator2 , class Compare > | |
| void | set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator1 result1, OutputIterator2 result2, Compare comp) |
| Constructs sorted ranges beginning in the location pointed by result1 and result2 with the set differences of the two sorted ranges [first1,last1) and [first2,last2). More... | |
| template<class InputIterator1 , class InputIterator2 , class OutputIterator1 , class OutputIterator2 > | |
| void | set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator1 result1, OutputIterator2 result2) |
| Constructs sorted ranges beginning in the location pointed by result1 and result2 with the set differences of the two sorted ranges [first1,last1) and [first2,last2). More... | |
| template<class ResType , class InType , typename ... Ts, template< typename ... > class ContainerType, class Callback > | |
| ContainerType< ResType > | transform (const ContainerType< InType, Ts ... > &in, Callback transform) |
In container tranformation of all elements according to the tranform. More... | |
| template<class InputIt , class Element > | |
| bool | contains (InputIt first, InputIt last, const Element &elem) |
| Linear version of search in a range of values. More... | |
| template<class InputIt , class Element > | |
| bool | binary_contains (InputIt first, InputIt last, const Element &elem) |
| Logaritmic version of search in a range of sorted values. More... | |
| template<class Iterator , class Value > | |
| std::pair< Iterator, Iterator > | find_range_internal (Iterator begin, Iterator end, const Value &open, const Value &close) |
Function to locate pair of iterators (openPos, closePos), i.e. both openPos and closePos are included in the range, where * openPos == open and closePos == closePos, or openPos = closePos = begin if no range can be found. More... | |
| template<class Iterator , class Value > | |
| std::pair< Iterator, Iterator > | find_range (Iterator begin, Iterator end, const Value &open, const Value &close) |
Function to locate pair of iterators (openPos, closePos] where * openPos == open and closePos == closePos, or openPos = closePos = begin if no range can be found. More... | |
| template<typename T > | |
| constexpr const T & | max (const T &a) |
| Root case of maximum computation. The maximum from one value is the value itself. More... | |
| template<typename T , typename ... Args> | |
| constexpr const T & | max (const T &a, const T &b, const Args &... args) |
| Root case of maximum computation. The maximum from one value is the value itself. More... | |
| template<typename T > | |
| constexpr const T & | min (const T &a) |
| template<typename T , typename ... Args> | |
| constexpr const T & | min (const T &a, const T &b, const Args &... args) |
| Root case of minimum computation. The minimum from one value is the value itself. More... | |
| template<typename ForwardIterator , typename BinaryPredicate > | |
| ForwardIterator | adjacent_find_internal (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred) |
| Internal function of standard library. More... | |
| template<typename ForwardIterator , typename BinaryPredicate > | |
| ForwardIterator | unique_internal (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred) |
| Internal function of standard library tuned to handle swapping of pointers. More... | |
| template<typename ForwardIterator > | |
| ForwardIterator | unique (ForwardIterator first, ForwardIterator last) |
| Shuffles values in a sequece so that consecutive duplicate values are pushed to the front and others to the back. More... | |
| template<typename ForwardIterator , typename BinaryPredicate > | |
| ForwardIterator | unique (ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred) |
| Shuffles values in a sequece so that consecutive duplicate values are pushed to the front and others to the back. More... | |
| template<class ForwardIteratorBegin , class ForwardIteratorEnd , class ForwardCandidateIterator > | |
| bool | range_contains_iterator (ForwardIteratorBegin from, const ForwardIteratorEnd &end, const ForwardCandidateIterator &candidate) |
determines if iterator candidate is in range [from, to). More... | |
| template<class T > | |
| auto | clone (T &&tmp) |
| Wrapper around clone by means of using copy constructor or clone method if available. More... | |
| template<class Tuple , class Callable > | |
| void | foreach (Tuple &&t, Callable callback) |
| template<class T , std::size_t N> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::array< T, N > &array) |
| Operator to print the array to the output stream. More... | |
| template<typename Base , typename ... Types> | |
| constexpr array< typename std::remove_reference< Base >::type, sizeof ...(Types)+1 > | make_array (Base &&first, Types &&... other) |
| Equivalent to the make_array from standard library but produces the ext::array. More... | |
| template<typename Base > | |
| constexpr array< typename std::remove_reference< Base >::type, 0 > | make_array () |
| Special case of make_array handling zero parameters. Technically calls default constructor. More... | |
| template<size_t N> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::bitset< N > &bitset) |
| Operator to print the bitset to the output stream. More... | |
| template<class T , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::deque< T, Ts ... > &list) |
| Operator to print the deque to the output stream. More... | |
| template<class T , class ... Ts> | |
| std::ostream & | operator<< (std::ostream &out, const ext::forward_list< T, Ts ... > &forward_list) |
| Operator to print the forward_list to the output stream. More... | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const forward_tree< T > &t) |
| Operator to print the forward_tree to the output stream. More... | |
| template<class T , class Compare , class Alloc > | |
| void | swap (ext::linear_set< T, Compare, Alloc > &x, ext::linear_set< T, Compare, Alloc > &y) |
| Specialisation of swap for linear set. More... | |
| template<class T , class ... Ts> | |
| std::ostream & | operator<< (std::ostream &out, const ext::linear_set< T, Ts ... > &value) |
| Operator to print the set to the output stream. More... | |
| template<class T , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::list< T, Ts ... > &list) |
| Operator to print the list to the output stream. More... | |
| template<class T , class ... Ts> | |
| std::ostream & | operator<< (std::ostream &out, const ext::managed_linear_set< T, Ts ... > &value) |
| Operator to print the set to the output stream. More... | |
| template<class T > | |
| void | swap (ext::managed_value< T > &x, ext::managed_value< T > &y) |
| Specialisation of swap for linear set. More... | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const ext::managed_value< T > &value) |
| Operator to print the set to the output stream. More... | |
| template<class T , class R , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::map< T, R, Ts ... > &map) |
| Operator to print the map to the output stream. More... | |
| template<class T , class R , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::multimap< T, R, Ts ... > &multimap) |
| Operator to print the multimap to the output stream. More... | |
| template<class T , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::multiset< T, Ts ... > &list) |
| Operator to print the multiset to the output stream. More... | |
| template<class T > | |
| ext::multiset< T > | operator+ (const ext::multiset< T > &first, const ext::multiset< T > &second) |
| Implementation of union of two multisets. More... | |
| template<class T > | |
| ext::ostream & | operator<< (ext::ostream &out, const std::optional< T > &optional) |
| Operator to print the optional to the output stream. More... | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const ext::optional_ref< T > &optional) |
| Operator to print the optional to the output stream. More... | |
| template<typename T1 , typename T2 > | |
| constexpr auto | make_pair (T1 &&x, T2 &&y) |
| template<class T , class R > | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::pair< T, R > &pair) |
| Operator to print the pair to the output stream. More... | |
| template<class T , std::size_t N> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::ptr_array< T, N > &ptr_array) |
| Operator to print the array to the output stream. More... | |
| template<typename Base , typename ... Types> | |
| constexpr ptr_array< typename std::remove_reference< Base >::type, sizeof ...(Types)+1 > | make_ptr_array (Base &&first, Types &&... other) |
| Array construction helper. Array is constructed from provided values, type of stored elements is deduced from the first parameter-. More... | |
| template<typename Base > | |
| constexpr ptr_array< typename std::remove_reference< Base >::type, 0 > | make_ptr_array () |
| Specialisation of array construction helper for empty array. The type parameter of the array must be provided explicitly. More... | |
| template<class... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::ptr_tuple< Ts... > &tuple) |
| Operator to print the tuple to the output stream. More... | |
| template<typename... Elements> | |
| constexpr auto | make_ptr_tuple (Elements &&... args) |
| Helper of pointer tuple construction. The tuple is constructed from values pack, types are deduced. More... | |
| template<class T > | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::ptr_vector< T > &ptr_vector) |
| Operator to print the vector to the output stream. More... | |
| template<class T , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::set< T, Ts ... > &list) |
| Operator to print the set to the output stream. More... | |
| template<class T > | |
| ext::set< T > | operator+ (const ext::set< T > &first, const ext::set< T > &second) |
| Implementation of union of two sets. More... | |
| template<> | |
| std::string | from_string (const std::string &) |
| Predeclaration of from string method. The from string methods are supposed to convert string representation of a given type to that type. More... | |
| ext::vector< std::string > | explode (const std::string &source, const std::string &delimiter) |
| Splits the string to substrings based on delimiter. More... | |
| std::string | implode (const std::vector< std::string > &source, const std::string &delimiter) |
| Merges strings using the delimiter. More... | |
| template<typename T > | |
| std::string | to_string (const T &value) |
| To string method designated for objects that can be casted to string. More... | |
| bool | isspace (int ch) |
| isspace method. More... | |
| bool | not_isspace (int ch) |
| Inverse of isspace method. More... | |
| std::string_view | ltrim (std::string_view s) |
| Trims spaces inside the string from the left. More... | |
| std::string_view | rtrim (std::string_view s) |
| Trims spaces inside the string from the right. More... | |
| std::string_view | trim (std::string_view s) |
| Trims spaces inside the string from both sides. More... | |
| std::string_view | make_string_view (std::string::const_iterator begin, std::string::const_iterator end) |
| template<class T > | |
| ext::ostream & | operator<< (ext::ostream &out, const tree< T > &t) |
| Operator to print the tree to the output stream. More... | |
| template<class Key , class Value > | |
| ext::ostream & | operator<< (ext::ostream &out, const trie< Key, Value > &t) |
| Operator to print the trie to the output stream. More... | |
| template<class... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::tuple< Ts... > &tuple) |
| Operator to print the tuple to the output stream. More... | |
| template<typename ... Elements> | |
| constexpr auto | make_tuple (Elements &&... args) |
| Helper of extended tuple construction. The tuple is constructed from values pack, types are deduced. More... | |
| template<typename ... Elements> | |
| constexpr tuple< Elements &... > | tie (Elements &... args) noexcept |
| Helper of extended tuple of references construction. The tuple is constructed to reffer to values in the parameter pack, types are deduced. More... | |
| template<class T , class R , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::unordered_map< T, R, Ts ... > &unordered_map) |
| Operator to print the unordered_map to the output stream. More... | |
| template<class Visitor , class... Variants> | |
| constexpr auto | visit (Visitor &&vis, Variants &&... vars) |
| template<class T , class ... Ts> | |
| ext::ostream & | operator<< (ext::ostream &out, const ext::vector< T, Ts ... > &vector) |
| Operator to print the vector to the output stream. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > & | operator|= (ext::vector< bool, Ts ... > &A, const ext::vector< bool, Ts ... > &B) |
| Support for assigning or operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator| (ext::vector< bool, Ts ... > A, const ext::vector< bool, Ts ... > &B) |
| Support for or operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > & | operator&= (ext::vector< bool, Ts ... > &A, const ext::vector< bool, Ts ... > &B) |
| Support for assigning and operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator& (ext::vector< bool, Ts ... > A, const ext::vector< bool, Ts ... > &B) |
| Support for and operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > & | operator^= (ext::vector< bool, Ts ... > &A, const ext::vector< bool, Ts ... > &B) |
| Support for assigning xor operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator^ (ext::vector< bool, Ts ... > A, const ext::vector< bool, Ts ... > &B) |
| Support for xor operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator~ (ext::vector< bool, Ts ... > A) |
| Support for not operator. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > & | operator<<= (ext::vector< bool, Ts ... > &A, size_t dist) |
| Support for assigning bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator<< (ext::vector< bool, Ts ... > A, size_t dist) |
| Support for bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > & | operator>>= (ext::vector< bool, Ts ... > &A, size_t dist) |
| Support for assigning bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged. More... | |
| template<class ... Ts> | |
| ext::vector< bool, Ts ... > | operator>> (ext::vector< bool, Ts ... > A, size_t dist) |
| Support for bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged. More... | |
| template<class ... Ts> | |
| bool | any (const ext::vector< bool, Ts ... > &v) |
| Tests the vector of booleans whether at least one bit inside is set. More... | |
| template<class ... Ts> | |
| void | fill (ext::vector< bool, Ts ... > &v) |
| Sets all bits in the vector of booleans. More... | |
| template<class ... Ts> | |
| void | clear (ext::vector< bool, Ts ... > &v) |
| Clears all bits in the vector of booleans. More... | |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator== (const U &u, const T &a) noexcept(noexcept(a==u)) |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator!= (const U &u, const T &a) noexcept(noexcept(a !=u)) |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator> (const U &u, const T &a) noexcept(noexcept(a< u)) |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator>= (const U &u, const T &a) noexcept(noexcept(a<=u)) |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator< (const U &u, const T &a) noexcept(noexcept(a > u)) |
| template<typename U , typename T > requires ( std::is_base_of_v<internal::logical_tuple_base, T> && ! std::is_base_of_v < internal::logical_tuple_base, U > ) | |
| constexpr auto | operator<= (const U &u, const T &a) noexcept(noexcept(a >=u)) |
| template<typename ... T> | |
| any_of (T &&...) -> any_of< T... > | |
| template<typename ... T> | |
| none_of (T &&...) -> none_of< T... > | |
| template<typename ... T> | |
| all_of (T &&...) -> all_of< T... > | |
| template<class ... Iterators> | |
| const_tuple_foreach_iterator< Iterators ... > | make_tuple_foreach_iterator (Iterators ... its) |
| Function construction of the tuple iterator. More... | |
| template<class ... Types> | |
| const_tuple_foreach< Types ... > | make_tuple_foreach (const Types &... args) |
| Function construction of foreach tuple pack helper. More... | |
| template<class T > | |
| PolyComp< T > | poly_comp (const T &inst) |
| template<class ... Ts> | |
| SliceComp< Ts ... > | slice_comp (const Ts &... inst) |
| unsigned | fromBase26 (const std::string &rep) |
| Function to convert sequence of uppercase letters to a number. More... | |
| std::string | toBase26 (unsigned n) |
| Function to convert a number to sequence of uppercase letters. More... | |
| unsigned | bijectiveFromBase26 (const std::string &rep) |
| Function to convert sequence of uppercase letters to a number. More... | |
| std::string | bijectiveToBase26 (unsigned n) |
| Function to convert a number to sequence of uppercase letters. More... | |
| istream | cin (std::cin.rdbuf()) |
| ostream | cout (std::cout.rdbuf()) |
| ostream | cerr (std::cerr.rdbuf()) |
| ostream | clog (std::clog.rdbuf()) |
| istream & | operator>> (istream &os, std::istream &(*fn)(std::istream &)) |
| istream & | operator>> (istream &os, std::ios_base &(*fn)(std::ios_base &)) |
| ext::istream & | oprr (ext::istream &in, const std::string &str, bool start) |
| ext::istream & | operator>> (ext::istream &in, const std::string &str) |
Read into a constant string. The implementation tests whether exact same sequence represented as str is in the in stream. In case it is, it reads it. In case it is not the stream is not advanced and fail bit is set. More... | |
| template<class Iterator > | |
| set_move_iterator< Iterator > | make_set_move_iterator (Iterator it) |
| Move from set iterator adaptor construction function. More... | |
| template<class T , class R , class Iterator > | |
| map_move_iterator< Iterator, T, R > | make_map_move_iterator (Iterator it) |
| Move from map iterator adaptor construction function. More... | |
| template<class T > | |
| reference_mover< T > | make_mover (T ¶m) |
| Move adaptor construction function specialized to lvalue reference parameter. More... | |
| template<class T > | |
| value_mover< T > | make_mover (T &¶m) |
| Move adaptor construction function specialized to rvalue reference paramter. More... | |
| template<class T > | |
| reverser< T > | make_reverse (T &&container) |
| Reverese adaptor construction function. More... | |
| template<class Iterator > | |
| dereferencing_iterator< Iterator > | dereferencer (Iterator iter) |
| Dereferencing adaptor construction function. More... | |
| template<typename InputIterator , typename Distance > | |
| constexpr void | retractInternal (InputIterator &i, Distance n, std::input_iterator_tag) |
| Implementation of retract function specific to input iterators. More... | |
| template<typename BidirectionalIterator , typename Distance > | |
| constexpr void | retractInternal (BidirectionalIterator &i, Distance n, std::bidirectional_iterator_tag) |
| Implementation of retract function specific to bidrectional iterators. More... | |
| template<typename RandomAccessIterator , typename Distance > | |
| constexpr void | retractInternal (RandomAccessIterator &i, Distance n, std::random_access_iterator_tag) |
| Implementation of retract function specific to random access iterators. More... | |
| template<typename Iterator , typename Distance > | |
| constexpr void | retract (Iterator &i, Distance n) |
| A generalization of pointer arithmetic. More... | |
| template<class Container > | |
| auto | begin (Container &&cont) -> decltype(std::forward(cont).begin()) |
| template<class Container > | |
| auto | end (Container &&cont) -> decltype(std::forward(cont).end()) |
| template<class T > | |
| callback_iterator< T > | make_callback_iterator (T callback) |
| template<typename map_type > | |
| key_iterator< map_type > | key_begin (const map_type &m) |
| template<typename map_type > | |
| key_iterator< map_type > | key_end (const map_type &m) |
| template<typename map_type > | |
| value_iterator< map_type > | value_begin (const map_type &m) |
| template<typename map_type > | |
| value_iterator< map_type > | value_end (const map_type &m) |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const ext::cow_shared_ptr< T > &ptr) |
| Operator to print the copy on write shared pointer to the output stream. More... | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const ext::smart_ptr< T > &ptr) |
| Operator to print the smart pointer to the output stream. More... | |
| ostream & | operator<< (ostream &os, std::ostream &(*fn)(std::ostream &)) |
| template<typename Iter > | |
| iterator_range< Iter > | make_iterator_range (Iter begin, Iter end) |
| Helper to create iterator_range from two iterators. More... | |
| template<class Container > | |
| auto | range (Container &&cont) -> decltype(std::forward< Container >(cont).range()) |
| template<class F , class ... Ts, typename = decltype ( std::declval < F > ( ) ( std::declval < Ts > ( ) ... ) )> | |
| std::true_type | supports_test (const F &, const Ts &...) |
| Positive supports test implementation. The test is designed to detect call availability on callable F with parameters Ts ... More... | |
| std::false_type | supports_test (...) |
| Negative supports test implementation. The test is designed to be callback when the positive test failed. More... | |
| std::ostream & | operator<< (std::ostream &os, const ext::type_index &type) |
| Operator to print the type_index to the output stream. More... | |
| int | operator- (const ext::type_index &first, const ext::type_index &second) |
| Implementation of three way comparison helper. More... | |
| std::string | erase_template_info (std::string str) |
| ext::vector< std::string > | get_template_info (const std::string &str) |
| bool | is_same_type (const std::string &first, const std::string &second) |
| Compares two types specified by their string names not looking at template params and unspecified segments. More... | |
| bool | are_same_types (const std::vector< std::string > &first, const std::vector< std::string > &second) |
| template<class T > | |
| std::string | to_string () |
| Overload of to_string function. For type specified by template parameter. More... | |
| template<typename T > | |
| bool | is_same_type (const std::string &name) |
| template<class T > | |
| auto | move_copy (const T ¶m) |
| Allow moving of copied instance of the source. More... | |
| template<std::size_t N, class F > | |
| void | constexpr_switch (const std::size_t i, F &&f) |
Variables | |
| const int | CERR_FD = 2 |
| The number of standard error stream descriptor. Expected to be 2. More... | |
| const int | CMEASURE_FD = 5 |
| The number of measurement stream descriptor. Expected to be 5. More... | |
| const int | CLOG_FD = 4 |
| The number of logging stream descriptor. Expected to be 4. More... | |
| const int | FAIL_FD = -1 |
| The number of descriptor when binding to the predefined one fails. More... | |
| ofdstream | cmeasure (CMEASURE_FD, CERR_FD) |
| Instance of the cmeasure stream. Default behavior is output to cout, but when the descriptor number 5 is redirected the cmeasure destination is to that descriptor. More... | |
| Init | relinkio |
| istream | cin |
| ostream | cout |
| ostream | cerr |
| ostream | clog |
This file is part of Algorithms library toolkit. Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
Algorithms library toolkit is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
Algorithms library toolkit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with Algorithms library toolkit. If not, see http://www.gnu.org/licenses/.
https://gist.github.com/tibordp/6909880
This file is part of Algorithms library toolkit. Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
Algorithms library toolkit is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
Algorithms library toolkit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with Algorithms library toolkit. If not, see http://www.gnu.org/licenses/.
https://gist.github.com/tibordp/6909880 Modified: Jan Travnicek
| using ext::boolean = typedef typename std::conditional < value, std::true_type, std::false_type >::type |
| using ext::is_in = typedef std::integral_constant < bool, ( std::is_same < T, Ts >::value || ... ) > |
Trait to test whether type T is in a types pack. The trait provides field value set to true if the type T is in pack of types Ts ..., false othervise.
| T | the type to look for |
| Ts | ... the types pack to look in |
| using ext::std_variant = typedef typename variant_builder_start < Ts ... >::std_variant |
| ForwardIterator ext::adjacent_find_internal | ( | ForwardIterator | first, |
| ForwardIterator | last, | ||
| BinaryPredicate | binary_pred | ||
| ) |
Internal function of standard library.
| ext::all_of | ( | T && | ... | ) | -> all_of< T... > |
| bool ext::any | ( | const ext::vector< bool, Ts ... > & | v | ) |
Tests the vector of booleans whether at least one bit inside is set.
| Ts | ... additional parameters of vector of booleans |
| v | the tested instance |
//TODO make a method of vector of booleans
| ext::any_of | ( | T && | ... | ) | -> any_of< T... > |
| bool ext::are_same_types | ( | const std::vector< std::string > & | first, |
| const std::vector< std::string > & | second | ||
| ) |
| auto ext::begin | ( | Container && | cont | ) | -> decltype ( std::forward ( cont ).begin ( ) ) |
Generalization of begin for universaly referenced containers.
| cont | the container to call begin on |
| unsigned ext::bijectiveFromBase26 | ( | const std::string & | rep | ) |
Function to convert sequence of uppercase letters to a number.
The following translation is implemented:
Maps 1 -> A, 2 -> B, ..., 26 -> Z, 27 -> AA, AB -> 28, ..., ZZ -> 676, AAA -> 677, ... http://en.wikipedia.org/wiki/Hexavigesimal
| rep | string sequence of uppercase letters |
rep | std::string ext::bijectiveToBase26 | ( | unsigned | n | ) |
Function to convert a number to sequence of uppercase letters.
The following translation is implemented:
Maps 1 -> A, 2 -> B, ..., 26 -> Z, 27 -> AA, 28 -> AB, ..., 676 -> ZZ, 677 -> AAA, ... http://en.wikipedia.org/wiki/Hexavigesimal
| n | the number to convert |
n | bool ext::binary_contains | ( | InputIt | first, |
| InputIt | last, | ||
| const Element & | elem | ||
| ) |
Logaritmic version of search in a range of sorted values.
| first | the beginning of the range |
| second | the end of the range |
| elem | the searched element |
| InputIt | the type of the iterator |
| Element | the type of the searched element |
| int ext::callback | ( | struct dl_phdr_info * | info, |
| size_t | , | ||
| void * | data | ||
| ) |
| ostream ext::cerr | ( | std::cerr. | rdbuf() | ) |
| istream ext::cin | ( | std::cin. | rdbuf() | ) |
| void ext::clear | ( | ext::vector< bool, Ts ... > & | v | ) |
Clears all bits in the vector of booleans.
| Ts | ... additional parameters of vector of booleans |
| v | the modified instance |
//TODO make a method of vector of booleans
| ostream ext::clog | ( | std::clog. | rdbuf() | ) |
| auto ext::clone | ( | T && | tmp | ) |
Wrapper around clone by means of using copy constructor or clone method if available.
| tmp | universal reference to a value to be cloned. |
| T | the type of cloned value |
| void ext::constexpr_switch | ( | const std::size_t | i, |
| F && | f | ||
| ) |
| bool ext::contains | ( | InputIt | first, |
| InputIt | last, | ||
| const Element & | elem | ||
| ) |
Linear version of search in a range of values.
| first | the beginning of the range |
| second | the end of the range |
| elem | the searched element |
| InputIt | the type of the iterator |
| Element | the type of the searched element |
| ostream ext::cout | ( | std::cout. | rdbuf() | ) |
| dereferencing_iterator< Iterator > ext::dereferencer | ( | Iterator | iter | ) |
Dereferencing adaptor construction function.
| T | the type of iterator to adapt |
| iter | source iterator for inner dereferencing |
| auto ext::end | ( | Container && | cont | ) | -> decltype ( std::forward ( cont ).end ( ) ) |
Generalization of end for universaly referenced containers.
| cont | the container to call end on |
| std::string ext::erase_template_info | ( | std::string | str | ) |
| bool ext::excludes | ( | InputIt1 | first1, |
| InputIt1 | last1, | ||
| InputIt2 | first2, | ||
| InputIt2 | last2 | ||
| ) |
Tests two sorted ranges wheter all elements from the second are not present in the first.
Complexity linear in minimum of sizes of the two ranges.
The elements of the ranges are compared by the default less operator
| first1 | the begining of the first range |
| first2 | the end of the first range |
| second1 | the begining of the second range |
| second2 | the end of the second range |
| ImputIt1 | type of the first iterator |
| ImputIt2 | type of the second iterator |
| bool ext::excludes | ( | InputIt1 | first1, |
| InputIt1 | last1, | ||
| InputIt2 | first2, | ||
| InputIt2 | last2, | ||
| Compare | comp | ||
| ) |
Tests two sorted ranges wheter all elements from the second are not present in the first.
Complexity linear in minimum of sizes of the two ranges.
| first1 | the begining of the first range |
| first2 | the end of the first range |
| second1 | the begining of the second range |
| second2 | the end of the second range |
| comp | the comparator of range elements |
| ext::vector< std::string > ext::explode | ( | const std::string & | source, |
| const std::string & | delimiter | ||
| ) |
Splits the string to substrings based on delimiter.
| source | the string to split |
| delimiter | the string to split by |
| void ext::fill | ( | ext::vector< bool, Ts ... > & | v | ) |
Sets all bits in the vector of booleans.
| Ts | ... additional parameters of vector of booleans |
| v | the modified instance |
//TODO make a method of vector of booleans
| std::pair< Iterator, Iterator > ext::find_range | ( | Iterator | begin, |
| Iterator | end, | ||
| const Value & | open, | ||
| const Value & | close | ||
| ) |
Function to locate pair of iterators (openPos, closePos] where * openPos == open and closePos == closePos, or openPos = closePos = begin if no range can be found.
The found range either does not contain nested range or the range it contains is recursively satisfying this definition.
In order for the function to find all ranges satisfying the above condition, the range (begin, end] must contain corretly nested ranges delimited by open and close.
| begin | the begining of the examined range |
| end | the end of the examined range |
| open | the opening parenthesis |
| end | the value of closing parenthesis |
| Iterator | the type of range denoting iterator |
| Value | the type of open and close delimiters |
| std::pair< Iterator, Iterator > ext::find_range_internal | ( | Iterator | begin, |
| Iterator | end, | ||
| const Value & | open, | ||
| const Value & | close | ||
| ) |
Function to locate pair of iterators (openPos, closePos), i.e. both openPos and closePos are included in the range, where * openPos == open and closePos == closePos, or openPos = closePos = begin if no range can be found.
The found range either does not contain nested range or the range it contains is recursively satisfying this definition.
In order for the function to find all ranges satisfying the above condition, the range (begin, end] must contain corretly nested ranges delimited by open and close.
| begin | the begining of the examined range |
| end | the end of the examined range |
| open | the opening parenthesis |
| end | the value of closing parenthesis |
| Iterator | the type of range denoting iterator |
| Value | the type of open and close delimiters |
| void ext::foreach | ( | Tuple && | t, |
| Callable | callback | ||
| ) |
| double ext::from_string | ( | const std::string & | ) |
Predeclaration of from string method. The from string methods are supposed to convert string representation of a given type to that type.
Specialisation of from string method for double result.
Specialisation of from string method for unsigned long long result.
Specialisation of from string method for unsigned long result.
Specialisation of from string method for unsigned result.
Specialisation of from string method for long long result.
Specialisation of from string method for long result.
Specialisation of from string method for booleans result.
Specialisation of from string method for integer result.
Specialisation of from string method for string result to make the interface complete.
| the | requested result type |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| the | string representation |
| unsigned ext::fromBase26 | ( | const std::string & | rep | ) |
Function to convert sequence of uppercase letters to a number.
The following translation is implemented:
Maps A -> 0, B -> 0, ..., Z -> 25, AB -> 26, AC -> 27, ..., ZZ -> 675, BAA -> 676, ... http://en.wikipedia.org/wiki/Hexavigesimal
| rep | string sequence of uppercase letters |
rep | ext::vector< std::string > ext::get_template_info | ( | const std::string & | str | ) |
| std::string ext::implode | ( | const std::vector< std::string > & | source, |
| const std::string & | delimiter | ||
| ) |
Merges strings using the delimiter.
| source | the vector of strings to merge |
| delimiter | the connection string |
| bool ext::is_same_type | ( | const std::string & | first, |
| const std::string & | second | ||
| ) |
Compares two types specified by their string names not looking at template params and unspecified segments.
Example foo < aaa >::bb::cc is equal to foo::::cc
| bool ext::is_same_type | ( | const std::string & | name | ) |
|
inline |
isspace method.
| ch | the tested character |
| key_iterator< map_type > ext::key_begin | ( | const map_type & | m | ) |
Helper to create begin key_iterator for map.
| map_type | the map |
| m | the iterated map |
| key_iterator< map_type > ext::key_end | ( | const map_type & | m | ) |
Helper to create end key_iterator for map.
| map_type | the map |
| m | the iterated map |
|
inline |
Trims spaces inside the string from the left.
| s | the trimed string |
|
constexpr |
Special case of make_array handling zero parameters. Technically calls default constructor.
| Base | the type of array values |
|
constexpr |
Equivalent to the make_array from standard library but produces the ext::array.
| first | the required value of the array |
| other | ... other values to be placed to the array |
| Base | the type of the first value |
| Types | the types of remaining types (they should be the same or convertible to Base type) |
| callback_iterator< T > ext::make_callback_iterator | ( | T | callback | ) |
Function to create callback iterator from the callback.
| T | the type of value accepted by the callback. |
| iterator_range< Iter > ext::make_iterator_range | ( | Iter | begin, |
| Iter | end | ||
| ) |
Helper to create iterator_range from two iterators.
| map_move_iterator< Iterator, T, R > ext::make_map_move_iterator | ( | Iterator | it | ) |
Move from map iterator adaptor construction function.
| Iterator | the type of iterator to adapt |
| KeyType | the key type of adapted map's iterator |
| ValueType | the value type of adapted map's iterator |
| it | iterator for adaptation |
| value_mover< T > ext::make_mover | ( | T && | param | ) |
Move adaptor construction function specialized to rvalue reference paramter.
| T | the type of class having rvalue qualified begin and end methods |
| container | the instance of an adapted class |
| reference_mover< T > ext::make_mover | ( | T & | param | ) |
Move adaptor construction function specialized to lvalue reference parameter.
| T | the type of class having rvalue qualified begin and end methods |
| container | the instance of an adapted class |
|
constexpr |
|
constexpr |
Specialisation of array construction helper for empty array. The type parameter of the array must be provided explicitly.
| Base | the type parameter of the constructed array |
|
constexpr |
Array construction helper. Array is constructed from provided values, type of stored elements is deduced from the first parameter-.
| Base | the type of the first parameter |
| Types | ... pack of remaining parameter types |
| first | the first parameter |
| other | ... pack of remaining parameters |
|
constexpr |
Helper of pointer tuple construction. The tuple is constructed from values pack, types are deduced.
| Elements | of types inside the tuple |
| args | the pointer tuple content |
| reverser< T > ext::make_reverse | ( | T && | container | ) |
Reverese adaptor construction function.
| T | the type of class having rbegin and rend methods |
| container | the instance of an adapted class |
| set_move_iterator< Iterator > ext::make_set_move_iterator | ( | Iterator | it | ) |
Move from set iterator adaptor construction function.
| Iterator | the type of iterator to adapt |
| it | iterator for adaptation |
|
inline |
|
constexpr |
Helper of extended tuple construction. The tuple is constructed from values pack, types are deduced.
| Elements | of types inside the tuple |
| args | the tuple content |
| const_tuple_foreach< Types ... > ext::make_tuple_foreach | ( | const Types &... | args | ) |
Function construction of foreach tuple pack helper.
| Types | ... the types of begin/end source classes |
| args | ... the actual begin/end source classes |
| const_tuple_foreach_iterator< Iterators ... > ext::make_tuple_foreach_iterator | ( | Iterators ... | its | ) |
Function construction of the tuple iterator.
| Iterators | ... the types of interators to pack |
| its | ... the actual iterators to pack |
|
constexpr |
Root case of maximum computation. The maximum from one value is the value itself.
| a | the value to compute maximum from |
| T | the type of the value to compute maximum from |
|
constexpr |
Root case of maximum computation. The maximum from one value is the value itself.
| a | the first value to compute maximum from |
| b | the second value to compute maximum from |
| args | ... the other values to compute maximum from |
| T | the type of the values to compute maximum from |
| Args | ... type of other values not yet processed here. Technically these types should be same as T |
|
constexpr |
Root case of minimum computation. The minimum from one value is the value itself.
| a | the value to compute minimum from |
| T | the type of the value to compute minimum from |
|
constexpr |
Root case of minimum computation. The minimum from one value is the value itself.
| a | the first value to compute minimum from |
| b | the second value to compute minimum from |
| args | ... the other values to compute minimum from |
| T | the type of the values to compute minimum from |
| Args | ... type of other values not yet processed here. Technically these types should be same as T |
|
inline |
Allow moving of copied instance of the source.
| T | the type of processed instance |
| param | the source instance |
| ext::none_of | ( | T && | ... | ) | -> none_of< T... > |
|
inline |
Inverse of isspace method.
| ch | the tested character |
|
constexprnoexcept |
| ext::vector< bool, Ts ... > ext::operator& | ( | ext::vector< bool, Ts ... > | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for and operator.
| Ts | ... additional parameters of vector of booleans |
| A | the first source instance |
| B | the second source instance |
| ext::vector< bool, Ts ... > & ext::operator&= | ( | ext::vector< bool, Ts ... > & | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for assigning and operator.
| Ts | ... additional parameters of vector of booleans |
| A | the destination instance |
| B | the source instance |
| ext::multiset< T > ext::operator+ | ( | const ext::multiset< T > & | first, |
| const ext::multiset< T > & | second | ||
| ) |
Implementation of union of two multisets.
| T | the type of values stored in unioned multisets |
| first | the first multiset to union |
| second | the second multiset to union |
| ext::set< T > ext::operator+ | ( | const ext::set< T > & | first, |
| const ext::set< T > & | second | ||
| ) |
Implementation of union of two sets.
| T | the type of values stored in unioned sets |
| first | the first set to union |
| second | the second set to union |
|
inline |
Implementation of three way comparison helper.
|
constexprnoexcept |
| ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::array< T, N > & | array | ||
| ) |
Operator to print the array to the output stream.
| out | the output stream |
| array | the array to print |
| T | the type of values inside the array |
| N | the size of the array |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::bitset< N > & | bitset | ||
| ) |
Operator to print the bitset to the output stream.
| out | the output stream |
| bitset | the bitset to print |
| N | the size of the bitset |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::deque< T, Ts ... > & | list | ||
| ) |
Operator to print the deque to the output stream.
| out | the output stream |
| deque | the deque to print |
| T | the type of values inside the deque |
| Ts | ... remaining unimportant template parameters of the deque |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::list< T, Ts ... > & | list | ||
| ) |
Operator to print the list to the output stream.
| out | the output stream |
| list | the list to print |
| T | the type of values inside the list |
| Ts | ... remaining unimportant template parameters of the list |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::map< T, R, Ts ... > & | map | ||
| ) |
Operator to print the map to the output stream.
| out | the output stream |
| map | the map to print |
| T | the type of keys inside the map |
| R | the type of values inside the map |
| Ts | ... remaining unimportant template parameters of the map |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::multimap< T, R, Ts ... > & | multimap | ||
| ) |
Operator to print the multimap to the output stream.
| out | the output stream |
| multimap | the multimap to print |
| T | the type of keys inside the multimap |
| R | the type of values inside the multimap |
| Ts | ... remaining unimportant template parameters of the multimap |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::multiset< T, Ts ... > & | list | ||
| ) |
Operator to print the multiset to the output stream.
| out | the output stream |
| multiset | the multiset to print |
| T | the type of keys inside the multiset |
| R | the type of values inside the multiset |
| Ts | ... remaining unimportant template parameters of the multiset |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::pair< T, R > & | pair | ||
| ) |
Operator to print the pair to the output stream.
| out | the output stream |
| pair | the pair to print |
| T | the type of the first value inside the pair |
| R | the type of the second value inside the pair |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::ptr_array< T, N > & | ptr_array | ||
| ) |
Operator to print the array to the output stream.
| out | the output stream |
| array | the array to print |
| T | the type of values inside the array |
| N | the size of the array |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::ptr_tuple< Ts... > & | tuple | ||
| ) |
Operator to print the tuple to the output stream.
| out | the output stream |
| tuple | the tuple to print |
| Ts | ... the pack of value type of the tuple |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::ptr_vector< T > & | ptr_vector | ||
| ) |
Operator to print the vector to the output stream.
| out | the output stream |
| vector | the vector to print |
| T | the type of values inside the vector |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::set< T, Ts ... > & | list | ||
| ) |
Operator to print the set to the output stream.
| out | the output stream |
| set | the set to print |
| T | the type of keys inside the set |
| R | the type of values inside the set |
| Ts | ... remaining unimportant template parameters of the set |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::tuple< Ts... > & | tuple | ||
| ) |
Operator to print the tuple to the output stream.
| out | the output stream |
| tuple | the tuple to print |
| Ts | ... the pack of value type of the tuple |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::unordered_map< T, R, Ts ... > & | unordered_map | ||
| ) |
Operator to print the unordered_map to the output stream.
| out | the output stream |
| unordered_map | the unordered_map to print |
| T | the type of keys inside the unordered_map |
| R | the type of values inside the unordered_map |
| Ts | ... remaining unimportant template parameters of the unordered_map |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const ext::vector< T, Ts ... > & | vector | ||
| ) |
Operator to print the vector to the output stream.
| out | the output stream |
| vector | the vector to print |
| T | the type of values inside the vector |
| Ts | ... remaining unimportant template parameters of the vector |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const std::optional< T > & | optional | ||
| ) |
Operator to print the optional to the output stream.
| out | the output stream |
| optional | the optional to print |
| T | the type of value inside the optional |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const tree< T > & | t | ||
| ) |
Operator to print the tree to the output stream.
| out | the output stream |
| tree | the tree to print |
| T | the type of values inside the tree |
out | ext::ostream & ext::operator<< | ( | ext::ostream & | out, |
| const trie< Key, Value > & | t | ||
| ) |
Operator to print the trie to the output stream.
| out | the output stream |
| trie | the trie to print |
| T | the type of values inside the trie |
out | ext::ostream & ext::operator<< | ( | ext::reference_wrapper< ext::ostream > & | os, |
| const T & | data | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for constant lvalue referenced objects.
| ext::ostream & ext::operator<< | ( | ext::reference_wrapper< ext::ostream > & | os, |
| std::ios_base &(*)(std::ios_base &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ios_base class.
| ext::ostream & ext::operator<< | ( | ext::reference_wrapper< ext::ostream > & | os, |
| std::ostream &(*)(std::ostream &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ostream class.
| ext::ostream & ext::operator<< | ( | ext::reference_wrapper< ext::ostream > & | os, |
| T && | data | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for rvalue referenced objects.
| std::ostream & ext::operator<< | ( | ext::reference_wrapper< std::ostream > & | os, |
| const T & | data | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for constant lvalue referenced objects.
| std::ostream & ext::operator<< | ( | ext::reference_wrapper< std::ostream > & | os, |
| std::ios_base &(*)(std::ios_base &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ios_base class.
| std::ostream & ext::operator<< | ( | ext::reference_wrapper< std::ostream > & | os, |
| std::ostream &(*)(std::ostream &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for modifiers from inside of ostream class.
| std::ostream & ext::operator<< | ( | ext::reference_wrapper< std::ostream > & | os, |
| T && | data | ||
| ) |
Overloaded function allowing same operations on wrapped output stream as on the actual output stream, specific for rvalue referenced objects.
| ext::vector< bool, Ts ... > ext::operator<< | ( | ext::vector< bool, Ts ... > | A, |
| size_t | dist | ||
| ) |
Support for bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged.
| Ts | ... additional parameters of vector of booleans |
| A | the source instance |
| dist | the distance to shift by |
| std::ostream & ext::operator<< | ( | std::ostream & | os, |
| const ext::type_index & | type | ||
| ) |
Operator to print the type_index to the output stream.
| out | the output stream |
| type | the type_index to print |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::cow_shared_ptr< T > & | ptr | ||
| ) |
Operator to print the copy on write shared pointer to the output stream.
| out | the output stream |
| map | the copy on write shared pointer to print |
| T | the type of managed instances inside the copy on write shared pointer |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::forward_list< T, Ts ... > & | forward_list | ||
| ) |
Operator to print the forward_list to the output stream.
| out | the output stream |
| forward_list | the forward_list to print |
| T | the type of values inside the forward_list |
| Ts | ... remaining unimportant template parameters of the forward_list |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::linear_set< T, Ts ... > & | value | ||
| ) |
Operator to print the set to the output stream.
| out | the output stream |
| value | the array to print |
| T | the type of values inside the array |
| Ts | ... remaining unimportant template parameters of the set |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::managed_linear_set< T, Ts ... > & | value | ||
| ) |
Operator to print the set to the output stream.
| out | the output stream |
| value | the array to print |
| T | the type of values inside the array |
| Ts | ... remaining unimportant template parameters of the set |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::managed_value< T > & | value | ||
| ) |
Operator to print the set to the output stream.
| out | the output stream |
| value | the array to print |
| T | the type of values inside the array |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::optional_ref< T > & | optional | ||
| ) |
Operator to print the optional to the output stream.
| out | the output stream |
| optional | the optional to print |
| T | the type of value inside the optional |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const ext::smart_ptr< T > & | ptr | ||
| ) |
Operator to print the smart pointer to the output stream.
| out | the output stream |
| map | the smart pointer to print |
| T | the type of managed instances inside the smart pointer |
out | std::ostream & ext::operator<< | ( | std::ostream & | out, |
| const forward_tree< T > & | t | ||
| ) |
Operator to print the forward_tree to the output stream.
| out | the output stream |
| forward_tree | the forward_tree to print |
| T | the type of values inside the forward_tree |
out | ext::vector< bool, Ts ... > & ext::operator<<= | ( | ext::vector< bool, Ts ... > & | A, |
| size_t | dist | ||
| ) |
Support for assigning bit shift to the left operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on lower indexes to higher indexes. The size of the vector is unchanged.
| Ts | ... additional parameters of vector of booleans |
| A | the source instance |
| dist | the distance to shift by |
|
constexprnoexcept |
|
constexprnoexcept |
|
constexprnoexcept |
|
constexprnoexcept |
| ext::istream & ext::operator>> | ( | ext::istream & | in, |
| const std::string & | str | ||
| ) |
Read into a constant string. The implementation tests whether exact same sequence represented as str is in the in stream. In case it is, it reads it. In case it is not the stream is not advanced and fail bit is set.
| in | the input stream |
| str | the string to test |
| ext::istream & ext::operator>> | ( | ext::reference_wrapper< ext::istream > & | is, |
| std::ios_base &(*)(std::ios_base &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of ios_base class.
| ext::istream & ext::operator>> | ( | ext::reference_wrapper< ext::istream > & | is, |
| std::istream &(*)(std::istream &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of istream class.
| std::istream & ext::operator>> | ( | ext::reference_wrapper< std::istream > & | is, |
| std::ios_base &(*)(std::ios_base &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of ios_base class.
| std::istream & ext::operator>> | ( | ext::reference_wrapper< std::istream > & | is, |
| std::istream &(*)(std::istream &) | func | ||
| ) |
Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for modifiers from inside of istream class.
| std::istream & ext::operator>> | ( | ext::reference_wrapper< std::istream > & | is, |
| T & | data | ||
| ) |
Overloaded function allowing same operations on wrapped input stream as on the actual input stream, specific for lvalue referenced objects.
| ext::vector< bool, Ts ... > ext::operator>> | ( | ext::vector< bool, Ts ... > | A, |
| size_t | dist | ||
| ) |
Support for bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged.
| Ts | ... additional parameters of vector of booleans |
| A | the source instance |
| dist | the distance to shift by |
| ext::vector< bool, Ts ... > & ext::operator>>= | ( | ext::vector< bool, Ts ... > & | A, |
| size_t | dist | ||
| ) |
Support for assigning bit shift to the right operator. The operator is intended to look at the vector of booleans as on the number where lower indexes represent less significant bits and higher indexes represent more significant bits. Therefore the shift is moving values on higher indexes to lower indexes. The size of the vector is unchanged.
| Ts | ... additional parameters of vector of booleans |
| A | the source instance |
| dist | the distance to shift by |
| ext::vector< bool, Ts ... > ext::operator^ | ( | ext::vector< bool, Ts ... > | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for xor operator.
| Ts | ... additional parameters of vector of booleans |
| A | the first source instance |
| B | the second source instance |
| ext::vector< bool, Ts ... > & ext::operator^= | ( | ext::vector< bool, Ts ... > & | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for assigning xor operator.
| Ts | ... additional parameters of vector of booleans |
| A | the destination instance |
| B | the source instance |
| ext::vector< bool, Ts ... > ext::operator| | ( | ext::vector< bool, Ts ... > | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for or operator.
| Ts | ... additional parameters of vector of booleans |
| A | the first source instance |
| B | the second source instance |
| ext::vector< bool, Ts ... > & ext::operator|= | ( | ext::vector< bool, Ts ... > & | A, |
| const ext::vector< bool, Ts ... > & | B | ||
| ) |
Support for assigning or operator.
| Ts | ... additional parameters of vector of booleans |
| A | the destination instance |
| B | the source instance |
| ext::vector< bool, Ts ... > ext::operator~ | ( | ext::vector< bool, Ts ... > | A | ) |
Support for not operator.
| Ts | ... additional parameters of vector of booleans |
| A | the source instance |
| ext::istream & ext::oprr | ( | ext::istream & | in, |
| const std::string & | str, | ||
| bool | start | ||
| ) |
| PolyComp< T > ext::poly_comp | ( | const T & | inst | ) |
| auto ext::range | ( | Container && | cont | ) | -> decltype ( std::forward < Container > ( cont ).range ( ) ) |
Generalization of range for universaly referenced containers.
| cont | the container to call end on |
|
inline |
determines if iterator candidate is in range [from, to).
| from | the beginning of the tested range |
| end | the ending of the tested range |
| candidate | the tested iterator |
|
inlineconstexpr |
A generalization of pointer arithmetic.
| Iterator | the type of retracted iterator |
| Distance | the type of distance to retract |
| i | An instance of some iterator. |
| n | The delta by which to change i. |
For random access and bidirectional iterators, n may be positive, in which case i is decremented. For random access, bidirectional, and input iterators, n may be negative, in which case i is incremented.
For random access iterators, this uses their + and - operations and are constant time. For other iterator classes they are linear time.
|
inlineconstexpr |
Implementation of retract function specific to bidrectional iterators.
| Iterator | the type of retracted iterator |
| Distance | the type of distance to retract |
| i | the retracted iterator |
| n | the distance to retract |
|
inlineconstexpr |
Implementation of retract function specific to input iterators.
| Iterator | the type of retracted iterator |
| Distance | the type of distance to retract |
| i | the retracted iterator |
| n | the distance to retract |
|
inlineconstexpr |
Implementation of retract function specific to random access iterators.
| Iterator | the type of retracted iterator |
| Distance | the type of distance to retract |
| i | the retracted iterator |
| n | the distance to retract |
|
inline |
Trims spaces inside the string from the right.
| s | the trimed string |
| void ext::set_symmetric_difference | ( | InputIterator1 | first1, |
| InputIterator1 | last1, | ||
| InputIterator2 | first2, | ||
| InputIterator2 | last2, | ||
| OutputIterator1 | result1, | ||
| OutputIterator2 | result2 | ||
| ) |
Constructs sorted ranges beginning in the location pointed by result1 and result2 with the set differences of the two sorted ranges [first1,last1) and [first2,last2).
The symmetric difference of two sets is formed by the elements that are present in one of the sets, but not in the other. The result1 and result2 are each representing half of the symmetric difference, i.e. each being a set difference of the first range to the second and of the second range to the first. Among the equivalent elements in each range, those discarded are those that appear before in the existent order before the call. The existing order is also preserved for the copied elements.
The elements are compared using operator <. Two elements, a and b are considered equivalent if (!(a<b) && !(b<a)).
The elements in the ranges shall already be ordered according to this same criterion (operator< or comp). The resulting range is also sorted according to this.
| void ext::set_symmetric_difference | ( | InputIterator1 | first1, |
| InputIterator1 | last1, | ||
| InputIterator2 | first2, | ||
| InputIterator2 | last2, | ||
| OutputIterator1 | result1, | ||
| OutputIterator2 | result2, | ||
| Compare | comp | ||
| ) |
Constructs sorted ranges beginning in the location pointed by result1 and result2 with the set differences of the two sorted ranges [first1,last1) and [first2,last2).
The symmetric difference of two sets is formed by the elements that are present in one of the sets, but not in the other. The result1 and result2 are each representing half of the symmetric difference, i.e. each being a set difference of the first range to the second and of the second range to the first. Among the equivalent elements in each range, those discarded are those that appear before in the existent order before the call. The existing order is also preserved for the copied elements.
The elements are compared using comp callback. Two elements, a and b are considered equivalent if (!comp(a,b) && !comp(b,a)).
The elements in the ranges shall already be ordered according to this same criterion (operator< or comp). The resulting range is also sorted according to this.
| void ext::simpleStacktrace | ( | ext::ostream & | out, |
| unsigned int | max_frames = 1000 |
||
| ) |
Analyzes the backtrace (stack trace) and creates its sring representation, one function call per line.
| void ext::simpleStacktrace | ( | std::ostream & | , |
| unsigned int | |||
| ) |
| SliceComp< Ts ... > ext::slice_comp | ( | const Ts &... | inst | ) |
| std::false_type ext::supports_test | ( | ... | ) |
Negative supports test implementation. The test is designed to be callback when the positive test failed.
| std::true_type ext::supports_test | ( | const F & | , |
| const Ts & | ... | ||
| ) |
Positive supports test implementation. The test is designed to detect call availability on callable F with parameters Ts ...
| F | the type of callable |
| Ts | ... call parameter types |
| void ext::swap | ( | ext::linear_set< T, Compare, Alloc > & | x, |
| ext::linear_set< T, Compare, Alloc > & | y | ||
| ) |
Specialisation of swap for linear set.
| T | the value of the set \tpatam Compare the comparator |
| Alloc | the values Allocator |
| x | the first instance |
| y | the second instance |
| void ext::swap | ( | ext::managed_value< T > & | x, |
| ext::managed_value< T > & | y | ||
| ) |
Specialisation of swap for linear set.
| T | the value of the set |
| x | the first instance |
| y | the second instance |
|
constexprnoexcept |
Helper of extended tuple of references construction. The tuple is constructed to reffer to values in the parameter pack, types are deduced.
| Elements | of types of references inside the tuple |
| args | values to refer to |
| std::string ext::to_string | ( | ) |
Overload of to_string function. For type specified by template parameter.
Specialisation for class types. Can handle incomplete types.
| value | the type_index to be converted to string |
| std::string ext::to_string | ( | const T & | value | ) |
To string method designated for objects that can be casted to string.
| T | type of the casted instance |
| value | the casted instance |
| std::string ext::toBase26 | ( | unsigned | n | ) |
Function to convert a number to sequence of uppercase letters.
The following translation is implemented:
Maps 0 -> A, 1 -> B, ..., 25 -> Z, 26 -> AB, 27 -> AC, ..., 675 -> ZZ, 676 -> BAA, ... http://en.wikipedia.org/wiki/Hexavigesimal
| n | the number to convert |
n | ContainerType< ResType > ext::transform | ( | const ContainerType< InType, Ts ... > & | in, |
| Callback | transform | ||
| ) |
In container tranformation of all elements according to the tranform.
| in | the input container |
| transform | the callback |
| ResType | the result of the transformation |
| InType | the type of original element |
| Ts | ... additional types of the in container |
| ContainerType | the template parameter of the container |
| Callback | the type of the transformation callback |
The function needs redesign. Ranges and output iterator should be used instead of container construction.
|
inline |
Trims spaces inside the string from both sides.
| s | the trimed string |
|
inline |
Shuffles values in a sequece so that consecutive duplicate values are pushed to the front and others to the back.
| first | A forward iterator. |
| last | A forward iterator. |
All but the first element from each group of consecutive values that compare equal are pushed to the end of the sequence. unique() is stable, so the relative order of elements that are not pushed to the end is unchanged. Elements between the end of the resulting sequence and last are still present, but their order is unspecified.
|
inline |
Shuffles values in a sequece so that consecutive duplicate values are pushed to the front and others to the back.
| first | A forward iterator. |
| last | A forward iterator. |
| binary_pred | A binary predicate. |
All but the first element from each group of consecutive values for which binary_pred returns true are pushed to the end of the sequence. unique() is stable, so the relative order of elements that are not pushed to the end is unchanged. Elements between the end of the resulting sequence and last are still present, but their order is unspecified.
| ForwardIterator ext::unique_internal | ( | ForwardIterator | first, |
| ForwardIterator | last, | ||
| BinaryPredicate | binary_pred | ||
| ) |
Internal function of standard library tuned to handle swapping of pointers.
| value_iterator< map_type > ext::value_begin | ( | const map_type & | m | ) |
Helper to create begin value_iterator for map.
| map_type | the map |
| m | the iterated map |
| value_iterator< map_type > ext::value_end | ( | const map_type & | m | ) |
Helper to create end value_iterator for map.
| map_type | the map |
| m | the iterated map |
|
constexpr |
|
extern |
| const int ext::CERR_FD = 2 |
The number of standard error stream descriptor. Expected to be 2.
|
extern |
|
extern |
| const int ext::CLOG_FD = 4 |
The number of logging stream descriptor. Expected to be 4.
| ofdstream ext::cmeasure | ( | CMEASURE_FD | , |
| CERR_FD | |||
| ) |
Instance of the cmeasure stream. Default behavior is output to cout, but when the descriptor number 5 is redirected the cmeasure destination is to that descriptor.
| const int ext::CMEASURE_FD = 5 |
The number of measurement stream descriptor. Expected to be 5.
|
extern |
| const int ext::FAIL_FD = -1 |
The number of descriptor when binding to the predefined one fails.
| Init ext::relinkio |
1.9.2