dtk Namespace Reference

Data Structures
struct	DynamicExtent
	Numeric wrapping type denoting the dynamic nature of a size. More...
class	Span
class	Span< T, DynamicExtent::value >
	Lightweight view over a contiguous sequence of objects. More...

Typedefs
typedef Span< char const >	ConstBuffer
typedef Span< char >	MutableBuffer

Functions
template<typename T , class Predicate >
bool	all_of (const Dtk_tab< T > &tab, Predicate Pred)
	Test condition on all elements in range, and returns true if pred returns true for all the elements in the range [first,last] or if the range is empty, and false otherwise. More...
template<class InputIterator , class Predicate >
bool	all_of (InputIterator first, InputIterator last, Predicate Pred)
	Test condition on all elements in range, and returns true if pred returns true for all the elements in the range [first,last] or if the range is empty, and false otherwise. More...
template<typename T , class Predicate >
bool	any_of (const Dtk_tab< T > &tab, Predicate Pred)
	Test if any element in range fulfills condition, returns true if pred returns true for any of the elements in the range [first,last], and false otherwise or if the range is empty. More...
template<class InputIterator , class Predicate >
bool	any_of (InputIterator first, InputIterator last, Predicate Pred)
	Test if any element in range fulfills condition, returns true if pred returns true for any of the elements in the range [first,last], and false otherwise or if the range is empty. More...
template<class Range >
auto	as_buffer (Range &&range) -> decltype(as_buffer(std::forward< Range >(range).data(), std::forward< Range >(range).size()))
template<class T >
auto	as_buffer (T *data, std::size_t n) DTK_NOEXCEPT -> MutableBuffer
template<class T >
auto	as_buffer (T const *data, std::size_t n) DTK_NOEXCEPT -> ConstBuffer
template<class Range >
auto	as_const_buffer (Range &&range) -> ConstBuffer
template<class T >
auto	as_const_buffer (T *data, std::size_t n) DTK_NOEXCEPT -> ConstBuffer
template<class T >
auto	as_const_buffer (T const *data, std::size_t n) DTK_NOEXCEPT -> ConstBuffer
template<class Range >
auto	as_const_span (Range &&range) -> Span< typename std::add_const< typename std::remove_pointer< decltype(std::forward< Range >(range).data())>::type >::type >
template<class T >
auto	as_const_span (T *data, std::size_t n) DTK_NOEXCEPT -> Span< T const >
template<class T >
auto	as_const_span (T const *data, std::size_t n) DTK_NOEXCEPT -> Span< T const >
template<class Range >
auto	as_span (Range &&range) -> Span< typename std::remove_pointer< decltype(std::forward< Range >(range).data())>::type >
template<class T >
auto	as_span (T *data, std::size_t n) DTK_NOEXCEPT -> Span< T >
template<class T >
auto	as_span (T const *data, std::size_t n) DTK_NOEXCEPT -> Span< T const >
template<typename T , class Predicate >
bool	none_of (const Dtk_tab< T > &tab, Predicate Pred)
	Test if no elements fulfill condition, returns true if pred returns false for all the elements in the range [first,last] or if the range is empty, and false otherwise. More...
template<class InputIterator , class Predicate >
bool	none_of (InputIterator first, InputIterator last, Predicate Pred)
	Test if no elements fulfill condition, returns true if pred returns false for all the elements in the range [first,last] or if the range is empty, and false otherwise. More...

Typedef Documentation

ConstBuffer

typedef Span<char const> dtk::ConstBuffer

MutableBuffer

typedef Span<char> dtk::MutableBuffer

Function Documentation

all_of() [1/2]

template<typename T , class Predicate >

bool dtk::all_of	(	const Dtk_tab< T > &	tab,
		Predicate	Pred
	)

Test condition on all elements in range, and returns true if pred returns true for all the elements in the range [first,last] or if the range is empty, and false otherwise.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

Specialized version for Dtk_tab.

     {
          for(Dtk_Size_t i = 0; i < tab.size(); ++i)
               if(!Pred(tab[i]))
                    return false;
          return true;
     }

all_of() [2/2]

template<class InputIterator , class Predicate >

bool dtk::all_of	(	InputIterator	first,
		InputIterator	last,
		Predicate	Pred
	)

Test condition on all elements in range, and returns true if pred returns true for all the elements in the range [first,last] or if the range is empty, and false otherwise.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

     {    // test if all elements satisfy _Pred
          for (; first != last; ++first)
               if (!Pred(*first))
                    return false;
          return true;
     }

any_of() [1/2]

template<typename T , class Predicate >

bool dtk::any_of	(	const Dtk_tab< T > &	tab,
		Predicate	Pred
	)

Test if any element in range fulfills condition, returns true if pred returns true for any of the elements in the range [first,last], and false otherwise or if the range is empty.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

Specialized version for Dtk_tab.

     {
          for(Dtk_Size_t i = 0; i < tab.size(); ++i)
               if(Pred(tab[i]))
                    return true;
          return false;
     }

any_of() [2/2]

template<class InputIterator , class Predicate >

bool dtk::any_of	(	InputIterator	first,
		InputIterator	last,
		Predicate	Pred
	)

Test if any element in range fulfills condition, returns true if pred returns true for any of the elements in the range [first,last], and false otherwise or if the range is empty.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

     {
          for(; first != last; ++first)
               if(Pred(*first))
                    return true;
          return false;
     }

as_buffer() [1/3]

template<class Range >

auto dtk::as_buffer

(

Range &&

range

)

-> decltype( as_buffer( std::forward<Range>( range ).data(), std::forward<Range>( range ).size() ) )

     {
          return as_buffer( std::forward<Range>( range ).data(), std::forward<Range>( range ).size() );
     }

as_buffer() [2/3]

template<class T >

auto dtk::as_buffer	(	T *	data,
		std::size_t	n
	)		-> MutableBuffer

     {
          return MutableBuffer( reinterpret_cast<char*>( data ), n * sizeof( T ) );
     }

as_buffer() [3/3]

template<class T >

auto dtk::as_buffer	(	T const *	data,
		std::size_t	n
	)		-> ConstBuffer

     {
          return ConstBuffer( reinterpret_cast<char const*>( data ), n * sizeof( T ) );
     }

as_const_buffer() [1/3]

template<class Range >

auto dtk::as_const_buffer

(

Range &&

range

)

-> ConstBuffer

     {
          typedef typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type Element;
          return ConstBuffer( reinterpret_cast< char const* >( std::forward<Range>( range ).data() ), std::forward<Range>( range ).size() * sizeof( Element ) );
     }

as_const_buffer() [2/3]

template<class T >

auto dtk::as_const_buffer	(	T *	data,
		std::size_t	n
	)		-> ConstBuffer

     {
          return ConstBuffer( reinterpret_cast< char const* >( data ), n * sizeof( T ) );
     }

as_const_buffer() [3/3]

template<class T >

auto dtk::as_const_buffer	(	T const *	data,
		std::size_t	n
	)		-> ConstBuffer

     {
          return ConstBuffer( reinterpret_cast< char const* >( data ), n * sizeof( T ) );
     }

as_const_span() [1/3]

template<class Range >

auto dtk::as_const_span

(

Range &&

range

)

-> Span<typename std::add_const<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>::type>

     {
          return Span<typename std::add_const<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>::type>( std::forward<Range>( range ) );
     }

as_const_span() [2/3]

template<class T >

auto dtk::as_const_span	(	T *	data,
		std::size_t	n
	)		-> Span<T const>

     {
          return Span<T const>( data, n );
     }

as_const_span() [3/3]

template<class T >

auto dtk::as_const_span	(	T const *	data,
		std::size_t	n
	)		-> Span<T const>

     {
          return Span<T const>( data, n );
     }

as_span() [1/3]

template<class Range >

auto dtk::as_span

(

Range &&

range

)

-> Span<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>

     {
          return Span<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>( std::forward<Range>( range ) );
     }

as_span() [2/3]

template<class T >

auto dtk::as_span	(	T *	data,
		std::size_t	n
	)		-> Span<T>

     {
          return Span<T>( data, n );
     }

as_span() [3/3]

template<class T >

auto dtk::as_span	(	T const *	data,
		std::size_t	n
	)		-> Span<T const>

     {
          return Span<T const>( data, n );
     }

none_of() [1/2]

template<typename T , class Predicate >

bool dtk::none_of	(	const Dtk_tab< T > &	tab,
		Predicate	Pred
	)

Test if no elements fulfill condition, returns true if pred returns false for all the elements in the range [first,last] or if the range is empty, and false otherwise.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

Specialized version for Dtk_tab.

     {
          for(Dtk_Size_t i = 0; i < tab.size(); ++i)
               if(Pred(tab[i]))
                    return false;
          return true;
     }

none_of() [2/2]

template<class InputIterator , class Predicate >

bool dtk::none_of	(	InputIterator	first,
		InputIterator	last,
		Predicate	Pred
	)

Test if no elements fulfill condition, returns true if pred returns false for all the elements in the range [first,last] or if the range is empty, and false otherwise.

Parameters

first	Input iterator to the initial position in a sequence
last	Input iterator to the final position in a sequence
Pred	Unary function that accepts an element in the range as argument and returns a value convertible to bool.

Remarks

Note that invalid parameters cause undefined behavior.

     {
          for (; first != last; ++first)
               if (Pred(*first))
                    return false;
          return true;
     }