Aleph-w 3.0
A C++ Library for Data Structures and Algorithms
Loading...
Searching...
No Matches
Static Public Member Functions | Static Public Attributes | List of all members
Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T > Struct Template Reference
Trees

Static Public Member Functions

template<typename U >
static auto test_select_const (int) -> decltype(std::declval< const U & >().select(std::declval< size_t >()), std::true_type())
 
template<typename >
static std::false_type test_select_const (...)
 
template<typename U >
static auto test_select_nonconst (int) -> decltype(std::declval< U & >().select(std::declval< size_t >()), std::true_type())
 
template<typename >
static std::false_type test_select_nonconst (...)
 
template<typename U >
static auto test_remove_pos (int) -> decltype(std::declval< U & >().remove_pos(std::declval< size_t >()), std::true_type())
 
template<typename >
static std::false_type test_remove_pos (...)
 
template<typename U >
static auto test_split_pos (int) -> decltype(std::declval< U & >().split_pos(std::declval< size_t >(), std::declval< U & >(), std::declval< U & >()), std::true_type())
 
template<typename >
static std::false_type test_split_pos (...)
 
template<typename U >
static auto test_position_const (int) -> decltype(std::declval< const U & >().position(std::declval< const Key & >()), std::true_type())
 
template<typename >
static std::false_type test_position_const (...)
 
template<typename U >
static auto test_position_nonconst (int) -> decltype(std::declval< U & >().position(std::declval< const Key & >()), std::true_type())
 
template<typename >
static std::false_type test_position_nonconst (...)
 
template<typename U >
static auto test_find_position_const (int) -> decltype(std::declval< const U & >().find_position(std::declval< const Key & >()), std::true_type())
 
template<typename >
static std::false_type test_find_position_const (...)
 
template<typename U >
static auto test_find_position_nonconst (int) -> decltype(std::declval< U & >().find_position(std::declval< const Key & >()), std::true_type())
 
template<typename >
static std::false_type test_find_position_nonconst (...)
 

Static Public Attributes

static constexpr bool has_select
 
static constexpr bool has_remove_pos
 
static constexpr bool has_split_pos
 
static constexpr bool has_position
 
static constexpr bool has_find_position
 

Detailed Description

template<typename Key, template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T>
struct Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >

Definition at line 283 of file tpl_dynSetTree.H.

Member Function Documentation

◆ test_find_position_const() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_find_position_const (   ...)
static

◆ test_find_position_const() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_find_position_const ( int  ) -> decltype(std::declval< const U & >().find_position(std::declval< const Key & >()), std::true_type())
static

◆ test_find_position_nonconst() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_find_position_nonconst (   ...)
static

◆ test_find_position_nonconst() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_find_position_nonconst ( int  ) -> decltype(std::declval< U & >().find_position(std::declval< const Key & >()), std::true_type())
static

◆ test_position_const() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_position_const (   ...)
static

◆ test_position_const() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_position_const ( int  ) -> decltype(std::declval< const U & >().position(std::declval< const Key & >()), std::true_type())
static

◆ test_position_nonconst() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_position_nonconst (   ...)
static

◆ test_position_nonconst() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_position_nonconst ( int  ) -> decltype(std::declval< U & >().position(std::declval< const Key & >()), std::true_type())
static

◆ test_remove_pos() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_remove_pos (   ...)
static

◆ test_remove_pos() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_remove_pos ( int  ) -> decltype(std::declval< U & >().remove_pos(std::declval< size_t >()), std::true_type())
static

◆ test_select_const() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_select_const (   ...)
static

◆ test_select_const() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_select_const ( int  ) -> decltype(std::declval< const U & >().select(std::declval< size_t >()), std::true_type())
static

◆ test_select_nonconst() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_select_nonconst (   ...)
static

◆ test_select_nonconst() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_select_nonconst ( int  ) -> decltype(std::declval< U & >().select(std::declval< size_t >()), std::true_type())
static

◆ test_split_pos() [1/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename >
static std::false_type Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_split_pos (   ...)
static

◆ test_split_pos() [2/2]

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
template<typename U >
static auto Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::test_split_pos ( int  ) -> decltype(std::declval< U & >().split_pos(std::declval< size_t >(), std::declval< U & >(), std::declval< U & >()), std::true_type())
static

Member Data Documentation

◆ has_find_position

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
constexpr bool Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::has_find_position
staticconstexpr
Initial value:
=
std::is_same_v<decltype(test_find_position_const<T>(0)), std::true_type> or
std::is_same_v<decltype(test_find_position_nonconst<T>(0)), std::true_type>
FunctionalMethods::maps
Aleph::DynList< __T > maps(Operation &op) const
Map the elements of the container.
Definition ah-dry.H:904

Definition at line 367 of file tpl_dynSetTree.H.

◆ has_position

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
constexpr bool Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::has_position
staticconstexpr
Initial value:
=
std::is_same_v<decltype(test_position_const<T>(0)), std::true_type> or
std::is_same_v<decltype(test_position_nonconst<T>(0)), std::true_type>

Definition at line 364 of file tpl_dynSetTree.H.

◆ has_remove_pos

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
constexpr bool Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::has_remove_pos
staticconstexpr
Initial value:
=
std::is_same_v<decltype(test_remove_pos<T>(0)), std::true_type>

Definition at line 360 of file tpl_dynSetTree.H.

◆ has_select

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
constexpr bool Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::has_select
staticconstexpr
Initial value:
=
std::is_same_v<decltype(test_select_const<T>(0)), std::true_type> or
std::is_same_v<decltype(test_select_nonconst<T>(0)), std::true_type>

Definition at line 357 of file tpl_dynSetTree.H.

◆ has_split_pos

template<typename Key , template< typename, class > class Tree = Avl_Tree, class Compare = Aleph::less<Key>>
template<typename T >
constexpr bool Aleph::DynSetTree< Key, Tree, Compare >::Has_Range_Methods< T >::has_split_pos
staticconstexpr
Initial value:
=
std::is_same_v<decltype(test_split_pos<T>(0)), std::true_type>

Definition at line 362 of file tpl_dynSetTree.H.

The documentation for this struct was generated from the following file: