Class Index

A | B | C | D | E | F | I | M | N | O | P | Q | R | S | T | U | V | Z

A

adapter (sl::nullables)

adapter_null_t (sl::nullables)

add_type_const (sl)

add_type_const< T & > (sl)

add_type_const< T && > (sl)

add_type_const< T * > (sl)

add_type_const< T *const > (sl)

add_type_const< T *const volatile > (sl)

add_type_const< T *volatile > (sl)

add_type_cv (sl)

add_type_volatile (sl)

add_type_volatile< T & > (sl)

add_type_volatile< T && > (sl)

add_type_volatile< T * > (sl)

add_type_volatile< T *const > (sl)

add_type_volatile< T *const volatile > (sl)

add_type_volatile< T *volatile > (sl)

Algorithm (sl::nullables)

append (sl::type_list)

append< Container< Elements... >, Types... > (sl::type_list)

apply_result (sl::tuple)

B

back (sl::type_list)

back< Container< Element > > (sl::type_list)

back< Container< First, Others... > > (sl::type_list)

BasicClosure (sl::functional)

C

cartesian_product_as (sl::type_list)

cartesian_product_as< TargetContainer, Container< Elements... > > (sl::type_list)

cartesian_product_as< TargetContainer, Container< Elements... >, OtherLists... > (sl::type_list)

cartesian_product_result (sl::tuple)

cat_result (sl::tuple)

closure_template (sl::functional)

closure_template< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > > (sl::functional)

common_container (sl::type_list)

common_container< Container< Elements... > > (sl::type_list)

common_container< Container< LhsElements... >, Container< RhsElements... >, Others... > (sl::type_list)

Composition (sl::functional)

concat (sl::type_list)

concat< LhsContainer< LhsElements... >, RhsContainer< RhsElements... >, Others... > (sl::type_list)

concat< List > (sl::type_list)

ConjunctionOperator (sl::functional)

ConjunctionStrategy (sl::functional)

contains (sl::type_list)

contains< Container< Elements... >, Query > (sl::type_list)

count (sl::type_list)

count< Query, Container< Elements... > > (sl::type_list)

CRTPBase (sl)

cv_qualified_type (sl)

cv_qualified_type< T > (sl)

D

default_delete_action (sl)

difference_as (sl::type_list)

difference_as< TargetContainer, First, Second > (sl::type_list)

DisjunctionOperator (sl::functional)

DisjunctionStrategy (sl::functional)

E

envelop_elements_result (sl::tuple)

equal (sl::type_list)

equal< First > (sl::type_list)

equal< FirstContainer< Elements... >, SecondContainer< Elements... >, Others... > (sl::type_list)

EqualityOperator (sl::functional)

EqualityStrategy (sl::functional)

F

filter (sl::type_list)

filter< Container< Elements... >, Filter > (sl::type_list)

frexp_result (sl::math)

front (sl::type_list)

front< Container< First, Others... > > (sl::type_list)

I

in_place_null_t (sl::nullables)

index_of (sl::type_list)

index_of< List, front_t< List > > (sl::type_list)

intersection_as (sl::type_list)

is_composition (sl::functional)

is_composition< Composition< CompositionStrategy, Fns... > > (sl::functional)

M

modf_result (sl::math)

N

NegationOperator (sl::functional)

nullhandle_t (sl)

O

Overloaded (sl::functional)

P

PipeOperator (sl::functional)

PipeStrategy (sl::functional)

populated_from (sl::type_list)

populated_from< TargetContainer, SourceContainer< Elements... > > (sl::type_list)

prepend (sl::type_list)

prepend< Container< Elements... >, Types... > (sl::type_list)

Q

qualified_category_as (sl)

R

remove (sl::type_list)

remove_at (sl::type_list)

remove_at< List, 0 > (sl::type_list)

remove_type_const (sl)

remove_type_const< T & > (sl)

remove_type_const< T && > (sl)

remove_type_const< T * > (sl)

remove_type_const< T *const > (sl)

remove_type_const< T *const volatile > (sl)

remove_type_const< T *volatile > (sl)

remove_type_cv (sl)

remove_type_volatile (sl)

remove_type_volatile< T & > (sl)

remove_type_volatile< T && > (sl)

remove_type_volatile< T * > (sl)

remove_type_volatile< T *const > (sl)

remove_type_volatile< T *const volatile > (sl)

remove_type_volatile< T *volatile > (sl)

remquo_result (sl::math)

reverse (sl::type_list)

reverse< Container<> > (sl::type_list)

S

symmetric_difference_as (sl::type_list)

T

tail (sl::type_list)

tail< Container< First, Others... > > (sl::type_list)

tail< Container<> > (sl::type_list)

traits (sl::nullables)

traits< adapter< TNull, TAdapted > > (sl::nullables)

traits< std::optional< TArgs... > > (sl::nullables)

traits< std::shared_ptr< TArgs... > > (sl::nullables)

traits< std::unique_ptr< TArgs... > > (sl::nullables)

traits< T > (sl::nullables)

traits< unique_handle< T, TDeleteAction > > (sl::nullables)

transform (sl::type_list)

transform< UnaryOperation, Container< Elements... > > (sl::type_list)

tuple_element< index, sl::type_list::TypeList< Types... > > (std)

tuple_size< sl::type_list::TypeList< Types... > > (std)

type_constness_as (sl)

type_qualification_as (sl)

type_volatileness_as (sl)

TypeList (sl::type_list)

U

unified_base (sl)

unique (sl::type_list)

unique< List > (sl::type_list)

unique_handle (sl)

unordered_equal (sl::type_list)

unordered_equal< First, OtherLists... > (sl::type_list)

unordered_equal< FirstContainer<>, OtherLists... > (sl::type_list)

unwrap_functional (sl::functional)

unwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & > (sl::functional)

unwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && > (sl::functional)

unwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & > (sl::functional)

unwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && > (sl::functional)

V

value_category_as (sl)

value_category_as< To, From & > (sl)

value_category_as< To, From && > (sl)

Z

zip_as (sl::type_list)

zip_nth_elements_as (sl::type_list)

zip_result (sl::tuple)