stdx Namespace Reference

Classes
struct	ptr_iterator_tag
class	ptr_vec_iter_imp
class	ptr_vec_iter
class	const_ptr_vec_iter
class	ptr_vector
class	ptr_iter_util
class	ptr_vector_owner
Functions
template<typename T>
bool	operator< (const ptr_vector< T > &left, const ptr_vector< T > &right)
template<typename T>
T *	iter2ptr (stdx::ptr_vec_iter< T > ptrIter)
template<typename T>
const T *	iter2ptr (stdx::const_ptr_vec_iter< T > ptrIter)
template<typename T>
void	ptr_swap (stdx::ptr_vec_iter< T > first, stdx::ptr_vec_iter< T > second)
template<typename PtrBidirectionalIterator1, typename PtrBidirectionalIterator2>
PtrBidirectionalIterator2	swap_ranges (PtrBidirectionalIterator1 first1, PtrBidirectionalIterator1 last1, PtrBidirectionalIterator2 first2)
template<typename PtrBidirectionalIterator, typename T>
PtrBidirectionalIterator	remove (PtrBidirectionalIterator first, PtrBidirectionalIterator last, const T &value)
template<typename PtrBidirectionalIterator, typename Predicate>
PtrBidirectionalIterator	remove_if (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Predicate pred)
template<typename PtrBidirectionalIterator>
PtrBidirectionalIterator	unique (PtrBidirectionalIterator first, PtrBidirectionalIterator last)
template<typename PtrBidirectionalIterator, typename Predicate>
PtrBidirectionalIterator	unique (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Predicate pred)
template<typename PtrBidirectionalIterator>
void	reverse (PtrBidirectionalIterator first, PtrBidirectionalIterator last)
template<typename PtrForwardIterator>
void	rotate (PtrForwardIterator first, PtrForwardIterator middle, PtrForwardIterator last)
template<typename PtrRandomAccessIterator>
void	random_shuffle (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename RandomNumberGenerator>
void	random_shuffle (PtrRandomAccessIterator first, PtrRandomAccessIterator last, RandomNumberGenerator &rand)
template<typename PtrBidirectionalIterator, typename Predicate>
PtrBidirectionalIterator	partition (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Predicate pred)
template<typename PtrBidirectionalIterator, typename Predicate>
PtrBidirectionalIterator	stable_partition (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Predicate pred)
template<typename PtrRandomAccessIterator>
void	sort (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	sort (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	stable_sort (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	stable_sort (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	partial_sort (PtrRandomAccessIterator first, PtrRandomAccessIterator middle, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	partial_sort (PtrRandomAccessIterator first, PtrRandomAccessIterator middle, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	nth_element (PtrRandomAccessIterator first, PtrRandomAccessIterator nth, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	nth_element (PtrRandomAccessIterator first, PtrRandomAccessIterator nth, PtrRandomAccessIterator last, Compare comp)
template<typename PtrBidirectionalIterator>
void	inplace_merge (PtrBidirectionalIterator first, PtrBidirectionalIterator middle, PtrBidirectionalIterator last)
template<typename PtrBidirectionalIterator, typename Compare>
void	inplace_merge (PtrBidirectionalIterator first, PtrBidirectionalIterator middle, PtrBidirectionalIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	push_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	push_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	pop_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	pop_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	make_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	make_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrRandomAccessIterator>
void	sort_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last)
template<typename PtrRandomAccessIterator, typename Compare>
void	sort_heap (PtrRandomAccessIterator first, PtrRandomAccessIterator last, Compare comp)
template<typename PtrBidirectionalIterator>
bool	next_permutation (PtrBidirectionalIterator first, PtrBidirectionalIterator last)
template<typename PtrBidirectionalIterator, typename Compare>
bool	next_permutation (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Compare comp)
template<typename PtrBidirectionalIterator>
bool	prev_permutation (PtrBidirectionalIterator first, PtrBidirectionalIterator last)
template<typename PtrBidirectionalIterator, typename Compare>
bool	prev_permutation (PtrBidirectionalIterator first, PtrBidirectionalIterator last, Compare comp)

---

Detailed Description

stdx: namespace for classes, functions, and templates related to the C++ Standard library

---

Function Documentation

template<typename PtrBidirectionalIterator, typename Compare>

void stdx::inplace_merge	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	middle,
		PtrBidirectionalIterator	last,
		Compare	comp
	)			[inline]

See also:

std::inplace_merge

template<typename PtrBidirectionalIterator>

void stdx::inplace_merge	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	middle,
		PtrBidirectionalIterator	last
	)			[inline]

See also:

std::inplace_merge

template<typename T>

const T* stdx::iter2ptr

(

stdx::const_ptr_vec_iter< T >

ptrIter

)

[inline]

converts a ptr_vector<T>::const_iterator to a pointer to const

template<typename T>

T* stdx::iter2ptr

(

stdx::ptr_vec_iter< T >

ptrIter

)

[inline]

converts a ptr_vector<T>::iterator to a pointer

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::make_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::make_heap

template<typename PtrRandomAccessIterator>

void stdx::make_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::make_heap

template<typename PtrBidirectionalIterator, typename Compare>

bool stdx::next_permutation	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Compare	comp
	)			[inline]

See also:

std::next_permutation

template<typename PtrBidirectionalIterator>

bool stdx::next_permutation	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last
	)			[inline]

See also:

std::next_permutation

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::nth_element	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	nth,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::nth_element

template<typename PtrRandomAccessIterator>

void stdx::nth_element	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	nth,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::nth_element

template<typename T>

bool stdx::operator<	(	const ptr_vector< T > &	left,
		const ptr_vector< T > &	right
	)			[inline]

compares left to right element by element

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::partial_sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	middle,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::partial_sort

template<typename PtrRandomAccessIterator>

void stdx::partial_sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	middle,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::partial_sort

template<typename PtrBidirectionalIterator, typename Predicate>

PtrBidirectionalIterator stdx::partition	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Predicate	pred
	)			[inline]

See also:

std::partition

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::pop_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::pop_heap

template<typename PtrRandomAccessIterator>

void stdx::pop_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::pop_heap

template<typename PtrBidirectionalIterator, typename Compare>

bool stdx::prev_permutation	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Compare	comp
	)			[inline]

See also:

std::prev_permutation

template<typename PtrBidirectionalIterator>

bool stdx::prev_permutation	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last
	)			[inline]

See also:

std::prev_permutation

template<typename T>

void stdx::ptr_swap	(	stdx::ptr_vec_iter< T >	first,
		stdx::ptr_vec_iter< T >	second
	)			[inline]

swaps underlying pointers in the container(!) of given ptr_vector<T>::iterators

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::push_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::push_heap

template<typename PtrRandomAccessIterator>

void stdx::push_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::push_heap

template<typename PtrRandomAccessIterator, typename RandomNumberGenerator>

void stdx::random_shuffle	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		RandomNumberGenerator &	rand
	)			[inline]

See also:

std::random_shuffle

template<typename PtrRandomAccessIterator>

void stdx::random_shuffle	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::random_shuffle

template<typename PtrBidirectionalIterator, typename T>

PtrBidirectionalIterator stdx::remove	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		const T &	value
	)			[inline]

moves elements that are equal to value to the end of the range [first, last); in contrast to std::remove all elements initially within the range [first, last) remain valid after the call to stdx::remove (elements are not duplicated and not destroyed).
Complexity differs from std::remove

Returns:

end of resulting range

template<typename PtrBidirectionalIterator, typename Predicate>

PtrBidirectionalIterator stdx::remove_if	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Predicate	pred
	)			[inline]

moves elements for which pred is true to the end of the range [first, last); in contrast to std::remove_if all elements initially within the range [first, last) remain valid after the call to stdx::remove_if (elements are not duplicated and not destroyed).
Complexity differs from std::remove_if

Returns:

end of resulting range

template<typename PtrBidirectionalIterator>

void stdx::reverse	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last
	)			[inline]

See also:

std::reverse

template<typename PtrForwardIterator>

void stdx::rotate	(	PtrForwardIterator	first,
		PtrForwardIterator	middle,
		PtrForwardIterator	last
	)			[inline]

See also:

std::rotate

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::sort

template<typename PtrRandomAccessIterator>

void stdx::sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::sort

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::sort_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::sort_heap

template<typename PtrRandomAccessIterator>

void stdx::sort_heap	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::sort_heap

template<typename PtrBidirectionalIterator, typename Predicate>

PtrBidirectionalIterator stdx::stable_partition	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Predicate	pred
	)			[inline]

See also:

std::stable_partition

template<typename PtrRandomAccessIterator, typename Compare>

void stdx::stable_sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last,
		Compare	comp
	)			[inline]

See also:

std::stable_sort

template<typename PtrRandomAccessIterator>

void stdx::stable_sort	(	PtrRandomAccessIterator	first,
		PtrRandomAccessIterator	last
	)			[inline]

See also:

std::stable_sort

template<typename PtrBidirectionalIterator1, typename PtrBidirectionalIterator2>

PtrBidirectionalIterator2 stdx::swap_ranges	(	PtrBidirectionalIterator1	first1,
		PtrBidirectionalIterator1	last1,
		PtrBidirectionalIterator2	first2
	)			[inline]

See also:

std::swap_ranges

Returns:

first2 + (last1 - first1)

template<typename PtrBidirectionalIterator, typename Predicate>

PtrBidirectionalIterator stdx::unique	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last,
		Predicate	pred
	)			[inline]

moves duplicates in the range [first, last) sorted according to Predicate pred to the end of the range; in contrast to std::unique all elements initially within the range [first, last) remain valid after the call to stdx::unique (elements are not duplicated and not destroyed).
Complexity differs from std::unique

Returns:

end of resulting range

template<typename PtrBidirectionalIterator>

PtrBidirectionalIterator stdx::unique	(	PtrBidirectionalIterator	first,
		PtrBidirectionalIterator	last
	)			[inline]

moves duplicates in the sorted range [first, last) to the end of the range; in contrast to std::unique all elements initially within the range [first, last) remain valid after the call to stdx::unique (elements are not duplicated and not destroyed).
Complexity differs from std::unique

Returns:

end of resulting range

---