Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

▼Nscl	Global namespace of the SCL
▼Nasync	Base namespace for asynchronous APIs
►Ndetails
Cchannel_actor_traits	Traits for actors that interact with the channel
Cchannel_transport_traits	Traits for the implementation of the transport of information in a scl::async::Channel
CChannelReceiver
CChannelSender	Class used to send data to a Channel
CActive	A class that allow task execution on a separate thread using RAII semantics
CAsyncQueue
CChannel	A channel to use for asynchronous communication of data in a queued manner
CMutexed	A wrapper class that protects a value with a lock
Cwith_traits	Traits for use with the scl::async::with function
Cwith_traits< Mutexed< T > >
Cwith_traits< std::mutex >
▼Nconcepts	A lightweight concept-like library for C++11
►Ndetails	Implementation details for concepts
C__is_concept
C__is_concept< T, scl::tools::meta ::enable_if_t< scl::tools::meta ::is_convertible< T, bool >() &&scl::tools::meta ::is_default_constructible< T >() > >
CAssignableWith	AssignableWith concept, a type U is assignable to a type T if operator=() is defined for both types (or implicit conversions)
CBinaryPredicate	BinaryPredicate concept, a type F is a binary predicate over T and U if it is an n-ary predicate over those types
CBoolean	Boolean concept, a type is boolean if it defines all boolean operations
CCharTraits	CharTraits concept
CConstructible	Constructible concept, a type is constructible with the given arguments if it is destructible and meta::is_constructible<T, Args...>() is true
CConvertibleTo	Conversion concept, a type From is convertible to another type To if meta::is_convertible<From, To>() is true
CCopyable	Copyable concept, a type is copyable if it is both copy constructible and copy assignable
CCopyAssignable	CopyAssignable concept, a type T is copy assignable if meta::is_copy_assignable<T>() is true
CCopyConstructible	CopyConstructible concept, a type T is copy constructible if meta::is_copy_constructible<T>() is true
CDefaultConstructible	DefaultConstructible concept, a type T is default constructible if it defines a default constructor
CDerivedFrom	DerivedFrom concept, a type Derived is derived from another type Base if Derived is a derives from Base
CDestructible	Destructible concept, a type T is destructible if it defines a destructor that won't throw
CEqualityComparable	EqualityComparable concept, a type T is equality comparable if it defines an operator== with itself
CEqualityComparableWith	EqualityComparableWith concept, a type T is equality comparable with another type U if it defines an operator== with U
CFunctionObject	FunctionObject concept, a type F is a function object that accepts Args..
CHash	Hash concept, a type T is an hash for Key if it is a function object, copy constructible, destructible, and the return type of its invocation w/ a Key is std::size_t
CInequalityComparable	InequalityComparable concept, a type T is equality comparable if it defines an operator!= with itself
CInequalityComparableWith	InequalityComparableWith concept, a type T is equality comparable with another type U if it defines an operator!= with U
CIntegral	Intergal concept, a type T is integral if meta:is_integral<T>() is true
CInvocable	Invocable concept, a type F is invocable with Args if meta::is_invocable<F, Args...>() is true
CIterator	Iterator concept, a type is an iterator if it is copyable, destructible, swappable, has well-defined iterator_traits and can be incremented and dereferenced
CLessThanComparable	LessThanComparable concept, a type T is less than comparable if it defines an operator< with itself
CLessThanComparableWith	LessThanComparableWith concept, a type T is equality comparable with another type U if it defines an operator< with U
CMovable	Movable concept, a type is movable if it is both move constructible and move assignable
CMoveAssignable	MoveAssignable concept, a type T is move assignable if meta::is_move_assignable<T>() is true
CMoveConstructible	MoveConstructible concept, a type T is move constructible if meta::is_move_constructible<T>() is true
CNonCopyable	NonCopyable concept, a type is non copyable if it is neither copy constructible nor copy assignable
CNonMovable	NonMovable concept, a type is non movable if it is neither move constructible nor move assignable
CNullablePointer	NullablePointer concept, a type is said to be a nullable pointer type if its interactions w/ nullptr are defined and can be compared using operator!=
CPredicate	Predicate concept, a type F is a predicate with Args if it is RegularInvocable and its result is Boolean
CRegular	Regular concept, a type is Regular if it is SemiRegular and EqualityCOmparable
CRegularInvocable	RegularInvocable concept, a type F is regular invocable with Args if it is Invocable and is equality preserving and does not modify its arguments
CRelation	Relation concept, a type R is a relation between T and U if it defines the 4 combinations
CSame	Same concept, two types Lhs and Rhs are considered the same if meta::is_same<Lhs, Rhs>() is true
CSemiRegular	SemiRegular concept, a type is semi regular if it is Copyable and DefaultConstructible
CSigned	Signed concept, a type T is signed if meta::is_signed<T>() is true
CSignedIntegral	SignedIntegral concept, a type is a signed integral if it is both Integral and Signed
CSwappable	Swappable concept, a type is swappable if it defines swapping mecanisms
CUnsigned	Unsigned concept, a type T is unsigned if meta::is_unsigned<T>() is true
CUnsignedIntegral	UnsignedIntegral concept, a type is an unsigned integral if it is both Integral and Unsigned
CValueSwappable	ValueSwappable concept, a type is value swappable if it is an iterator type and its value type is swappable
▼Ndetect	Namespace for detecting features, platform, etc..
►Nplatform	Namespace for platform detection
▼Nexceptions	The namespace englobing all exception types
CEmptyOptionalAccess	Exception class used when attempting to access the value of an empty scl::utils::Optional
CException	Base class for all regular exceptions
CInvalidAnyCast	Exception class used when attempting to cast an Any to the wrong type
CInvalidArgument	Exception class used when passing an argument that does not respect the preconditions
CInvalidCast	Exception class used when a conversion is impossible
CInvalidEitherAccess	Exception class used when attempting to access the wrong type stored in an scl::utils::Either
CInvalidResource	Exception class used when a resource is used without specialized traits
CInvalidResultAccess	Exception class used when attempting to access the wrong type stored in an scl::utils::Either
CNonNullViolation
COutOfBound	Exception class used when attempting to access elements out of bounds (eg
CRuntimeException	Base class for exceptions that could never be checked at compile-time
CThrowable	Base class of all throwable objects
CUninitializedMemoryAccess	Exception class used when trying to access uninitialized memory
▼Nhttp	Namespace for the HTTP components
CStatusCode
CVersion	A pseudo enum class that describes the version of the HTTP Protocol
▼Nstream	Namespace of the stream API
►Ncreators	Namespace for functions and utilities that create streams (lazy)
►Ndetails	Implementation details of creators
CByLine	Class that exposes custom logic for reading a file line by line for use with std::istream_iterator
CByLineIterator	Istream iterator for reading line by line with conversion to std::basic_string
CFromArrayIterator	Creator for std::array
CFromStlIterator	Creator for an iterator-based range
CRangeCreator	Creator for a numeric range
►Ndetails	Implementation details for the stream API
►Niterator	Iterators abstract classes
CBaseStreamIterator	A class for iterators that start a stream chain
CEndStreamIterator	A class for iterators used in end operations
COpStreamIterator	Iterator powering an intermediate operation
CStlAdapter	An adapter for STL-like iterators from stream iterators
CStreamIterator	Abstract base class for stream iterators defining the required behavior
CInvalidValue
CStreamIteratorPayload	A class representing a stream iterator's payload
►Noperators	Namespace for intermediate operations on streams (lazy)
►Ndetails	Namespace for implementation details of operators
Cfilter_toolbox	Tag type for filter operations
CFilterOperator	Filter operation
Cmap_toolbox	Tag type that allows operation piping for map operations
CMapOperator	Mapping operation
Cunique_toolbox	Toolbox tag for unique operations
CuniqueBy_toolbox	Toolbox tag type for unique by operations
CUniqueByOperator	Unique by operation
►Nterminators	Namespace for stream terminal/final operations (eager)
►Ndetails	Namespace for implementation details of terminators
Cfor_each_toolbox	ForEach toolbox tag
CForEachTerminator	For each terminator
►Npack	A namespace for packing operations (getting a result as a container)
►Ndetails	Implementation details for packing operations
CSetPacker	Class that allows packing to a std::set
Cto_set_toolbox	Tag type to pack into a std::set w/ default template parameters
Cto_set_toolbox_alloc	Tag type to pack into a std::set w/ control over template parameters
Cto_vector_toolbox	Tag type to pack into a vector w/ default template parameters
Cto_vector_toolbox_alloc	Tag type to pack into a vector w/ control over the allocator
CVectorPacker	Class that allows packing to a std::vector
CStream	Class representing a stream of data
▼Ntools	General purpose tooling
►Niostream	Namespace for the iostream oriented tools
►Nlog	Logging utilities
►Nmeta	A namespace englobing all the TMP tools
►Ndetails	Namespace for implementation details for TMP
C__exists
C__exists< T, void_t< T > >
C__is_instance
C__is_instance< U, U< T... > >
C__is_swappable
C__is_swappable< T, enable_if_t< !is_same< T, add_lvalue_reference_t< T > >() &&is_swappable_with< T &, T & >() > >
C__is_swappable_with
C__is_swappable_with< T, U, void_t< enable_if_t< exists< decltype(std::swap(std::declval< T & >(), std::declval< U & >()))>() &&exists< decltype(std::swap(std::declval< U & >(), std::declval< T & >()))>() > > >
C__ostream_op_defined
C__ostream_op_defined< T, void_t< decltype(operator<<(std::declval< std::ostream & >(), std::declval< const T & >())) > >
C__to_string_defined
C__to_string_defined< T, void_t< decltype(std::to_string(std::declval< const T & >())) > >
C__toStringDefined
C__toStringDefined< T, void_t< scl::utils::ToString< T > > >
CNoOp	Type construct that exposes a single type that is its type argument
Cfn
Cfn< F, decltype(&F::operator())>
Cfn< R(*)(Args...), void >
Cfn< R(Class::*const)(Args...), std::nullptr_t >
Cfn< R(Class::*const)(Args...), void >
Cfunction_traits	Traits for callable types
Cfunction_traits< std::function< R(Args...)> >	Specialization for std::function
Creal_const	Get the appropriate const version of a type
Creal_const< T *, void >	Specialization for pointers
▼Nutils	Utility classes (and rare functions)
►Ndetails	Implementation details for the utility classes
C__any__impl
C__any_base
Cresult_error
Cresult_value	//
CAny	Class that can hold any value type (and change value type mid lifetime)
►CEither	Alternative type that stores one or the other
Clhs_tag	Tag used to construct the LHS member (in case both are convertible types)
Cpayload_t	Payload type that encapsulates both alternatives
Crhs_tag	Tag used to construct the RHS member (in case both are convertible types)
CNone	An empty class serving as the type of an empty Optional<T>
COptional	A class that allows the use of optional types (might be there)
CPlaceholder	Class representing parameter/return argument placholders
CRawStorage	Class that handles raw storage (and manual memory management) for a variable type
CResult
CToString
CToString< None >	A specialization of ToString for None type
CToString< Optional< T >, scl::tools::meta ::enable_if_t< scl::tools::meta ::defines_scl_to_string< T >() > >
CToString< scl::http::StatusCode >
CToString< scl::http::Version, void >
CToString< T, scl::tools::meta ::enable_if_t< scl::tools::meta ::defines_std_to_string< T >() > >	Specialization for types that define std::to_string
CToString< T, scl::tools::meta ::enable_if_t< scl::tools::meta ::is_base_of< scl::exceptions::Throwable, T >() > >	Specialization of ToString for Throwable types
CToString< T, scl::tools::meta ::enable_if_t< scl::tools::meta ::is_same< T, char >()||scl::tools::meta ::is_same< T, const char * >()||scl::tools::meta ::is_same< T, std::string >() > >	Specialization for types convertible to string
▼Nstd	STL namespace
Ctuple_size< scl::async::Channel< T, Lock, Guard, Container > >