instigate::stl::implementation Namespace Reference

The namespace contains all auxiliary functions. More...

Classes
struct	category_mapping_aux
	Get iterator category. More...
struct	category_mapping_aux< std::output_iterator_tag >
struct	category_mapping_aux< std::input_iterator_tag >
struct	category_mapping_aux< std::forward_iterator_tag >
struct	category_mapping_aux< std::bidirectional_iterator_tag >
struct	category_mapping_aux< std::random_access_iterator_tag >
class	Temporary_buffer
	Implementation of "Temporary buffer". More...
Functions
template<typename F, typename O, typename T>
O	adjacent_difference_aux (F b, F e, O r, T *)
	Implementation of the first version of the adjacent_difference algorithm.
template<typename F, typename O, typename T, typename BF>
O	adjacent_difference_aux (F b, F e, O r, T *, BF f)
	Implementation of the second version of the adjacent_difference algorithm.
template<typename I, typename D>
void	advance_aux (I &, D, stl::single_pass_iterator::tag)
template<typename I, typename D>
void	advance_aux (I &, D, stl::bidirectional_iterator::tag)
template<typename I, typename D>
void	advance_aux (I &, D, stl::random_access_iterator::tag)
template<typename T>
void	destroy_disp (T b, T e, instigate::stl::false_type)
	Dispatch destroy() function in case of trivial destructor absence.
template<typename T>
void	destroy_disp (T, T, instigate::stl::true_type)
	Dispatch destroy() function in case of trivial destructor existence.
template<typename I, typename O>
O	__copy (I, I, O, instigate::stl::single_pass_iterator::tag)
template<typename I, typename O>
O	__copy (I, I, O, instigate::stl::random_access_iterator::tag)
template<typename T>
T *	copy_trivial (const T *f, const T *l, T *r)
	Helper function copy_trivial to replace calls to copy with memmove.
template<typename I, typename O>
O	copy_aux (I, I, O, false_type)
template<typename I, typename O>
O	copy_aux (I, I, O, true_type)
template<typename T>
T *	copy_aux (const T *, const T *, T *, true_type)
template<typename B_1, typename B_2>
B_2	__copy_backward (B_1, B_1, B_2, instigate::stl::bidirectional_iterator::tag)
template<typename R, typename B>
B	__copy_backward (R, R, B, instigate::stl::random_access_iterator::tag)
template<typename I, typename S, typename O, typename P>
void	__copy_n (I, S, O, P &, instigate::stl::single_pass_iterator::tag)
template<typename I, typename S, typename O, typename P>
void	__copy_n (I, S, O, P &, instigate::stl::random_access_iterator::tag)
template<typename I>
stl::single_pass_iterator::interface < I >::difference_type	distance_aux (I, I, stl::single_pass_iterator::tag)
template<typename I>
stl::random_access_iterator::interface < I >::difference_type	distance_aux (I, I, stl::random_access_iterator::tag)
template<typename F, typename L, typename D, typename P>
void	equal_range_aux (F b, F e, const L &v, D *, P &p)
	Implementation of the first version of the equal_range algorithm.
template<typename F, typename L, typename C, typename D, typename P>
void	equal_range_aux (F b, F e, const L &v, C c, D *, P &p)
	Implementation of the second version of the equal_range algorithm.
template<typename F1, typename F2>
F1	find_end_aux (F1 b, F1 e, F2 f, F2 l, instigate::stl::forward_iterator::tag, instigate::stl::forward_iterator::tag)
template<typename B1, typename B2>
B1	find_end_aux (B1 b, B1 e, B2 f, B2 l, instigate::stl::bidirectional_iterator::tag, instigate::stl::bidirectional_iterator::tag)
template<typename F1, typename F2, typename BP>
F1	find_end_aux (F1 b, F1 e, F2 f, F2 l, BP p, instigate::stl::forward_iterator::tag, instigate::stl::forward_iterator::tag)
template<typename B1, typename B2, typename BP>
B1	find_end_aux (B1 b, B1 e, B2 f, B2 l, BP p, instigate::stl::bidirectional_iterator::tag, instigate::stl::bidirectional_iterator::tag)
template<typename B1, typename B2, typename BP>
B1	search_end (B1 b, B1 e, B2 f, B2 l, BP p)
template<typename I, typename P>
I	find_if_aux (I b, I e, P p, instigate::stl::random_access_iterator::tag)
template<typename I, typename P>
I	find_if_aux (I b, I e, P p, instigate::stl::single_pass_iterator::tag)
template<typename B1, typename B2, typename D>
B1	rotate_adaptive (B1 b, B1 m, B1 e, D len1, D l2, B2 buffer, D buffer_size)
	Helper function rotate_adaptive to implement the first version of the inplace_merge algorithm.
template<typename B1, typename B2, typename B3>
B3	merge_backward (B1 b, B1 e, B2 f, B2 l, B3 r)
	Helper function merge_ backward to implement the first version of the inplace_merge algorithm.
template<typename B, typename D, typename Pointer>
void	merge_adaptive (B b, B m, B e, D len1, D l2, Pointer buffer, D buffer_size)
	Helper function merge_adaptive to implement the first version of the inplace_merge algorithm.
template<typename B, typename D>
void	merge_without_buffer (B b, B m, B e, D len1, D l2)
	Helper function merge_without_buffer to implement the first version of the inplace_merge algorithm.
template<typename B, typename TP, typename D>
void	inplace_merge_aux (B b, B m, B e, TP *, D *)
	Helper function inplace_merge_aux to implement the first version of the inplace_merge algorithm.
template<typename B1, typename B2, typename B3, typename BP>
B3	merge_backward (B1 b, B1 e, B2 f, B2 l, B3 r, BP p)
	Helper function merge_backward to implement the second version of the inplace_merge algorithm.
template<typename B, typename D, typename Pointer, typename BP>
void	merge_adaptive (B b, B m, B e, D len1, D l2, Pointer buffer, D buffer_size, BP bp)
	Helper function merge_adaptive to implement the second version of the inplace_merge algorithm.
template<typename B, typename D, typename BP>
void	merge_without_buffer (B b, B m, B e, D len1, D l2, BP p)
	Helper function merge_without to implement the second version of the inplace_merge algorithm.
template<typename B, typename TP, typename D, typename BP>
void	inplace_merge_aux (B b, B m, B e, TP *, D *, BP p)
	Helper function inplace_merge_aux to implement the second version of the inplace_merge algorithm.
template<typename F, typename L, typename D>
F	lower_bound_aux (F b, F e, const L &v, D *)
	Implementation of the lower_bound algorithm for the first version.
template<typename F, typename L, typename C, typename D>
F	lower_bound_aux (F b, F e, const L &v, C c, D *)
	Implementation of the lower_bound algorithm for the second version.
template<typename R, typename TP>
void	partial_sort_aux (R b, R m, R e, TP *)
	Implementation of the first version of the partial_sort algorithm.
template<typename R, typename TP, typename BP>
void	partial_sort_aux (R b, R m, R e, TP *, BP p)
	Implementation of the second version of the partial_sort algorithm.
template<typename I, typename R, typename D, typename Tp>
R	partial_sort_copy_aux (I b, I e, R f, R l, D *, Tp *)
	Implementation of the first version of the partial_sort_copy algorithm.
template<typename I, typename R, typename BP, typename D, typename Tp>
R	partial_sort_copy_aux (I b, I e, R f, R l, BP p, D *, Tp *)
	Implementation of the second version of the partial_sort_copy algorithm.
template<typename I, typename O, typename T>
O	partial_sum_aux (I b, I e, O r, T *)
	Implementation of the first version of the partial_sum algorithm.
template<typename I, typename O, typename T, typename F>
O	partial_sum_aux (I b, I e, O r, T *, F f)
	Implementation of the second version of the partial_sum algorithm.
template<typename F, typename P>
F	partition_aux (F b, F e, P p, instigate::stl::forward_iterator::tag)
template<typename B, typename P>
B	partition_aux (B b, B e, P p, instigate::stl::bidirectional_iterator::tag)
template<typename I, typename D, typename T>
void	adjust_heap_aux (I, D, D, T)
template<typename I, typename D, typename T, typename C>
void	adjust_heap_aux (I, D, D, T, C)
template<typename I, typename T>
void	pop_heap_aux (I, I, I, T)
template<typename I, typename T, typename C>
void	pop_heap_aux (I, I, I, T, C)
template<typename T, typename I, typename M>
T	power_aux (T, I, M)
template<typename I, typename D, typename T>
void	push_heap_aux (I b, D h, D t, T v)
	Implementation of the first version of the push_heap algorithm.
template<typename I, typename D, typename T, typename C>
void	push_heap_aux (I b, D h, D t, T v, C c)
	Implementation of the second version of the push_heap algorithm.
template<typename I, typename R, typename D>
R	random_sample_aux (I b, I e, R o, const D n)
	Implementation of the first version of the random_sample algorithm.
template<typename I, typename R, typename G, typename D>
R	random_sample_aux (I b, I e, R o, G &g, const D n)
	Implementation of the second version of the random_sample algorithm.
template<typename B>
void	reverse_aux (B b, B e, instigate::stl::bidirectional_iterator::tag)
template<typename R>
void	reverse_aux (R b, R e, instigate::stl::random_access_iterator::tag)
template<typename I>
I	rotate_aux (I, I, I, stl::forward_iterator::tag)
template<typename I>
I	rotate_aux (I, I, I, stl::bidirectional_iterator::tag)
template<typename R>
R	rotate_aux (R, R, R, stl::random_access_iterator::tag)
template<typename T>
T	gcd (T, T)
template<typename R, typename T>
void	unguarded_linear_insert (R, T)
	Helper function used in sort algorithm.
template<typename R, typename T, typename C>
void	unguarded_linear_insert (R, T, C)
	Helper function used in sort algorithm.
template<typename R>
void	linear_insert (R, R)
	Helper function used in sort algorithm.
template<typename R, typename C>
void	linear_insert (R, R, C)
	Helper function used in sort algorithm.
template<typename R>
void	insertion_sort (R, R)
	Helper function used in sort algorithm.
template<typename R, typename C>
void	insertion_sort (R, R, C)
	Helper function used in sort algorithm.
template<typename R>
void	unguarded_insertion_sort (R, R)
	Helper function used in sort algorithm.
template<typename R, typename C>
void	unguarded_insertion_sort (R, R, C)
	Helper function used in sort algorithm.
template<typename R>
void	final_insertion_sort (R, R)
	Helper function used in sort algorithm.
template<typename R, typename C>
void	final_insertion_sort (R, R, C)
	Helper function used in sort algorithm.
template<typename S>
S	lg (S)
	Helper function used in sort algorithm.
template<typename R, typename S>
void	introsort_loop (R, R, S)
	Helper function used in sort algorithm.
template<typename R, typename S, typename C>
void	introsort_loop (R, R, S, C)
	Helper function used in sort algorithm.
template<typename F, typename P, typename Dist>
F	inplace_stable_partition (F b, F e, P p, Dist l)
	Helper function inplace_stable_partition to implement the algorithm if no auxiliary memory is available.
template<typename F, typename Ptr, typename P, typename Dist>
F	stable_partition_adaptive (F b, F e, P p, Dist l, Ptr buff, Dist buff_size)
	Helper function stable_partition_adaptive to implement the algorithm if a large enough auxiliary memory buffer is available.
template<typename F, typename P, typename T, typename Dist>
F	stable_partition_aux (F b, F e, P p, T *, Dist *)
	Helper function to implement the stable_partition algorithm.
template<typename R, typename T>
R	unguarded_partition (R b, R e, T p)
	The first version of the unguarded_partition algorithm.
template<typename R, typename T, typename C>
R	unguarded_partition (R b, R e, T p, C c)
	The second version of the unguarded_partition algorithm.
template<typename R>
void	inplace_stable_sort (R b, R e)
	Helper function used in stable_sort algorithm.
template<typename R, typename BP>
void	inplace_stable_sort (R b, R e, BP p)
	Helper function used in stable_sort algorithm.
template<typename R, typename P, typename D>
void	stable_sort_adaptive (R b, R e, P buffer, D s)
	Helper function used in stable_sort algorithm.
template<typename R, typename P, typename D, typename BP>
void	stable_sort_adaptive (R b, R e, P buffer, D s, BP p)
	Helper function used in stable_sort algorithm.
template<typename R1, typename R2, typename D>
void	merge_sort_loop (R1 b, R1 e, R2 r, D step_size)
	Helper function used in stable_sort algorithm.
template<typename R1, typename R2, typename D, typename BP>
void	merge_sort_loop (R1 b, R1 e, R2 r, D step_size, BP p)
	Helper function used in stable_sort algorithm.
template<typename R, typename D>
void	chunk_insertion_sort (R b, R e, D chunk_size)
	Helper function used in stable_sort algorithm.
template<typename R, typename D, typename BP>
void	chunk_insertion_sort (R b, R e, D chunk_size, BP p)
	Helper function used in stable_sort algorithm.
template<typename R, typename P, typename D>
void	merge_sort_with_buffer (R b, R e, P buffer, D *)
	Helper function used in stable_sort algorithm.
template<typename R, typename P, typename D, typename BP>
void	merge_sort_with_buffer (R b, R e, P buffer, D *, BP p)
	Helper function used in stable_sort algorithm.
template<typename R, typename T, typename D>
void	stable_sort_aux (R b, R e, T *, D *)
	Helper function used in stable_sort algorithm.
template<typename R, typename T, typename D, typename BP>
void	stable_sort_aux (R b, R e, T *, D *, BP p)
	Helper function used in stable_sort algorithm.
template<typename I, typename O>
O	unique_copy_aux (I b, I e, O r, instigate::stl::forward_iterator::tag)
template<typename I, typename O>
O	unique_copy_aux (I b, I e, O r, instigate::stl::incrementable_iterator::tag)
template<typename I, typename O, typename Tp>
O	unique_copy_aux (I b, I e, O r, Tp *)
template<typename I, typename O, typename BP>
O	unique_copy_aux (I b, I e, O r, BP p, instigate::stl::forward_iterator::tag)
template<typename I, typename O, typename BP>
O	unique_copy_aux (I b, I e, O r, BP p, instigate::stl::incrementable_iterator::tag)
template<typename I, typename O, typename BP, typename Tp>
O	unique_copy_aux (I b, I e, O r, BP p, Tp *)
template<typename F, typename L, typename D>
F	upper_bound_aux (F b, F e, const L &v, D *)
template<typename F, typename L, typename C, typename D>
F	upper_bound_aux (F b, F e, const L &v, C c, D *)
Variables
const int	stl_threshold = 16
	This variable used in sort algorithm.
const int	stl_chunk_size = 7
	This variable used in stable_sort algorithm.

---

Detailed Description

The namespace contains all auxiliary functions.

Implementation of the namespace.

Here are all helper functions to implement copy algorithm.

Here are all helper functions to implement the algorithms.

---

Function Documentation

template<typename I, typename O>

O instigate::stl::implementation::__copy	(	I	f,
		I	l,
		O	r,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the copy algorithm for the instigate::stl::random_access_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::dereference_assign(), and instigate::stl::increment().

template<typename I, typename O>

O instigate::stl::implementation::__copy	(	I	f,
		I	l,
		O	r,
		instigate::stl::single_pass_iterator::tag
	)			[inline]

Implementation of the copy algorithm for the instigate::stl::single_pass_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::equal(), and instigate::stl::increment().

Referenced by copy_aux().

template<typename R, typename B>

B instigate::stl::implementation::__copy_backward	(	R	f,
		R	l,
		B	r,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the copy_backward algorithm for the instigate::stl::random_access_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::decrement(), and instigate::stl::dereference_assign().

template<typename B_1, typename B_2>

B_2 instigate::stl::implementation::__copy_backward	(	B_1	f,
		B_1	l,
		B_2	r,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the copy_backward algorithm for the instigate::stl::bidirectional_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::decrement(), instigate::stl::dereference_assign(), and instigate::stl::equal().

Referenced by instigate::stl::copy_backward().

template<typename I, typename S, typename O, typename P>

void instigate::stl::implementation::__copy_n	(	I	f,
		S	c,
		O	r,
		P &	ob_pair,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the copy_n algorithm for the instigate::stl::random_access_iterator::tag category

References instigate::stl::advance(), instigate::stl::assign(), instigate::stl::copy(), instigate::stl::copy_constructor(), instigate::stl::pair::interface< T >::set_first(), and instigate::stl::pair::interface< T >::set_second().

template<typename I, typename S, typename O, typename P>

void instigate::stl::implementation::__copy_n	(	I	f,
		S	c,
		O	r,
		P &	ob_pair,
		instigate::stl::single_pass_iterator::tag
	)			[inline]

Implementation of copy_n algorithm for the instigate::stl::single_pass_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::increment(), instigate::stl::pair::interface< T >::set_first(), and instigate::stl::pair::interface< T >::set_second().

Referenced by instigate::stl::copy_n().

template<typename I, typename D, typename T, typename C>

void instigate::stl::implementation::adjust_heap_aux	(	I	b,
		D	h,
		D	l,
		T	v,
		C	c
	)			[inline]

Helper function adjust_heap_aux for the implementation of the second version of the pop_heap algorithm

References instigate::stl::advance(), instigate::stl::assign(), instigate::stl::dereference(), instigate::stl::equal(), instigate::stl::invoke_predicate(), instigate::stl::iter_swap(), instigate::stl::less_than(), and push_heap_aux().

Referenced by instigate::stl::make_heap(), and pop_heap_aux().

template<typename I, typename D, typename T>

void instigate::stl::implementation::adjust_heap_aux	(	I	b,
		D	holeIndex,
		D	len,
		T	value
	)			[inline]

Helper function adjust_heap_aux for the implementation of the first version of the pop_heap algorithm

References instigate::stl::advance(), instigate::stl::assign(), instigate::stl::const_dereference(), instigate::stl::equal(), instigate::stl::iter_swap(), instigate::stl::less_than(), and push_heap_aux().

Referenced by partial_sort_copy_aux().

template<typename I, typename D>

void instigate::stl::implementation::advance_aux	(	I &	i,
		D	n,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the advance iterator function for instigate::stl::random_access_iterator::tag category

References instigate::stl::advance(), and CHECK.

Referenced by instigate::stl::advance().

template<typename I, typename D>

void instigate::stl::implementation::advance_aux	(	I &	i,
		D	n,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the advance iterator function for instigate::stl::bidirectional_iterator::tag category

References CHECK, instigate::stl::decrement(), and instigate::stl::increment().

template<typename I, typename D>

void instigate::stl::implementation::advance_aux	(	I &	i,
		D	n,
		instigate::stl::single_pass_iterator::tag
	)			[inline]

Implementation of the advance iterator function for instigate::stl::single_pass_iterator::tag category

References instigate::stl::increment(), and instigate::stl::less_than().

template<typename T>

T * instigate::stl::implementation::copy_aux	(	const T *	f,
		const T *	l,
		T *	r,
		true_type
	)			[inline]

Helper function copy_aux to implement copy algorithm for type that has a trivial assignment operator

References copy_trivial().

template<typename I, typename O>

O instigate::stl::implementation::copy_aux	(	I	f,
		I	l,
		O	r,
		true_type
	)			[inline]

Helper function copy_aux to implement copy algorithm for type that has a trivial assignment operator

References __copy().

template<typename I, typename O>

O instigate::stl::implementation::copy_aux	(	I	f,
		I	l,
		O	r,
		false_type
	)			[inline]

Helper function copy_aux to implement copy algorithm for type that has not a trivial assignment operator

References __copy().

Referenced by instigate::stl::copy().

template<typename I>

instigate::stl::random_access_iterator::interface< I >::difference_type instigate::stl::implementation::distance_aux	(	I	b,
		I	e,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the distance algorithm for the instigate::stl::random_access_iterator::tag category

References CHECK, and instigate::stl::distance().

Referenced by instigate::stl::distance().

template<typename I>

instigate::stl::single_pass_iterator::interface< I >::difference_type instigate::stl::implementation::distance_aux	(	I	b,
		I	e,
		instigate::stl::single_pass_iterator::tag
	)			[inline]

Implementation of the distance algorithm for the instigate::stl::single_pass_iterator::tag category

References instigate::stl::equal(), and instigate::stl::increment().

template<typename B1, typename B2, typename BP>

B1 instigate::stl::implementation::find_end_aux	(	B1	b,
		B1	e,
		B2	f,
		B2	l,
		BP	p,
		instigate::stl::bidirectional_iterator::tag	,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the second version of find_end algorithm for instigate::stl::bidirectional_iterator::tag

References CHECK, and search_end().

Referenced by instigate::stl::find_end().

template<typename F1, typename F2, typename BP>

F1 instigate::stl::implementation::find_end_aux	(	F1	b,
		F1	e,
		F2	f,
		F2	l,
		BP	p,
		instigate::stl::forward_iterator::tag	,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the second version of find_end algorithm for instigate::stl::forward_iterator::tag

References instigate::stl::assign(), CHECK, CHECK_CONVERTIBILITY, instigate::stl::copy_constructor(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::search().

template<typename B1, typename B2>

B1 instigate::stl::implementation::find_end_aux	(	B1	b,
		B1	e,
		B2	f,
		B2	l,
		instigate::stl::bidirectional_iterator::tag	,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the first version of find_end algorithm for instigate::stl::bidirectional_iterator::tag

References instigate::stl::advance(), instigate::stl::assign(), CHECK, instigate::stl::copy_constructor(), instigate::stl::distance, instigate::stl::equal(), and instigate::stl::search().

template<typename F1, typename F2>

F1 instigate::stl::implementation::find_end_aux	(	F1	b,
		F1	e,
		F2	f,
		F2	l,
		instigate::stl::forward_iterator::tag	,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the first version of find_end algorithm for instigate::stl::forward_iterator::tag

References instigate::stl::assign(), CHECK, instigate::stl::copy_constructor(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::search().

template<typename I, typename P>

I instigate::stl::implementation::find_if_aux	(	I	b,
		I	e,
		P	p,
		instigate::stl::single_pass_iterator::tag
	)			[inline]

Implementation of the find_if algorithm for the instigate::stl::single_pass_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::invoke_predicate().

template<typename I, typename P>

I instigate::stl::implementation::find_if_aux	(	I	b,
		I	e,
		P	p,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the find_if algorithm for the instigate::stl::random_access_iterator::tag category

References instigate::stl::assign(), instigate::stl::const_dereference(), instigate::stl::distance, instigate::stl::increment(), and instigate::stl::invoke_predicate().

Referenced by instigate::stl::find_if().

template<typename T>

T instigate::stl::implementation::gcd	(	T	m,
		T	n
	)			[inline]

Calculates greatest common factor, of two non-zero integers, is the largest positive integer that divides both numbers without remainder.

Referenced by rotate_aux().

template<typename B, typename P>

B instigate::stl::implementation::partition_aux	(	B	b,
		B	e,
		P	p,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the partition algorithm for the instigate::stl::bidirectional_iterator::tag

References instigate::stl::decrement(), instigate::stl::dereference(), instigate::stl::equal(), instigate::stl::increment(), instigate::stl::invoke_predicate(), and instigate::stl::iter_swap().

template<typename F, typename P>

F instigate::stl::implementation::partition_aux	(	F	b,
		F	e,
		P	p,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the partition algorithm for the instigate::stl::forward_iterator::tag

References instigate::stl::assign(), instigate::stl::copy_constructor(), instigate::stl::dereference(), instigate::stl::equal(), instigate::stl::increment(), instigate::stl::invoke_predicate(), and instigate::stl::swap().

Referenced by instigate::stl::partition().

template<typename I, typename T, typename C>

void instigate::stl::implementation::pop_heap_aux	(	I	b,
		I	e,
		I	r,
		T	v,
		C	c
	)			[inline]

Helper function pop_heap_aux for the implementation of the second version of the pop_heap algorithm

References adjust_heap_aux(), instigate::stl::distance(), and instigate::stl::iter_swap().

Referenced by instigate::stl::pop_heap().

template<typename I, typename T>

void instigate::stl::implementation::pop_heap_aux	(	I	b,
		I	e,
		I	r,
		T	v
	)			[inline]

Helper function pop_heap_aux for the implementation of the first version of the pop_heap algorithm

References adjust_heap_aux(), instigate::stl::distance(), and instigate::stl::iter_swap().

Referenced by partial_sort_aux().

template<typename T, typename I, typename M>

T instigate::stl::implementation::power_aux	(	T	a,
		I	n,
		M	o
	)			[inline]

Implementation of the power algorithm. Multiplies<T> is passed to the "power_aux" function as the monoid operation for the second version of the algorithm.

References instigate::stl::assign(), instigate::stl::equal(), and instigate::stl::invoke().

Referenced by instigate::stl::power().

template<typename R>

void instigate::stl::implementation::reverse_aux	(	R	b,
		R	e,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the reverse algorithm for the instigate::stl::random_access_iterator::tag category

References CHECK, instigate::stl::decrement(), instigate::stl::increment(), instigate::stl::iter_swap(), and instigate::stl::less_than().

Referenced by instigate::stl::reverse(), and rotate_aux().

template<typename B>

void instigate::stl::implementation::reverse_aux	(	B	b,
		B	e,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the reverse algorithm for the instigate::stl::bidirectional_iterator::tag category

References CHECK, instigate::stl::decrement(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::iter_swap().

template<typename R>

R instigate::stl::implementation::rotate_aux	(	R	b,
		R	m,
		R	e,
		instigate::stl::random_access_iterator::tag
	)			[inline]

Implementation of the rotate algorithm for the instigate::stl::bidirectional_iterator::tag category

References instigate::stl::advance(), instigate::stl::assign(), instigate::stl::copy_constructor(), instigate::stl::dereference(), instigate::stl::dereference_assign(), instigate::stl::distance, gcd(), instigate::stl::increment(), instigate::stl::less_than(), and instigate::stl::swap_ranges().

Referenced by instigate::stl::rotate().

template<typename I>

I instigate::stl::implementation::rotate_aux	(	I	b,
		I	m,
		I	e,
		instigate::stl::bidirectional_iterator::tag
	)			[inline]

Implementation of the rotate algorithm for the instigate::stl::bidirectional_iterator::tag category

References CHECK, instigate::stl::decrement(), instigate::stl::dereference(), instigate::stl::equal(), instigate::stl::increment(), reverse_aux(), and instigate::stl::swap().

template<typename I>

I instigate::stl::implementation::rotate_aux	(	I	b,
		I	m,
		I	e,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the rotate algorithm for the instigate::stl::forward_iterator::tag category

References instigate::stl::assign(), instigate::stl::copy_constructor(), instigate::stl::dereference(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::swap().

template<typename B1, typename B2, typename BP>

B1 instigate::stl::implementation::search_end	(	B1	b,
		B1	e,
		B2	f,
		B2	l,
		BP	p
	)			[inline]

Helper function for find_end algorithm

References _find(), instigate::stl::assign(), instigate::stl::const_dereference(), instigate::stl::copy_constructor(), instigate::stl::decrement(), instigate::stl::equal(), and instigate::stl::invoke_predicate().

Referenced by find_end_aux().

template<typename R, typename T, typename C>

R instigate::stl::implementation::unguarded_partition	(	R	b,
		R	e,
		T	p,
		C	c
	)			[inline]

The second version of the unguarded_partition algorithm.

Unguarded_partition is much like partition: it reorders the elements in the range [b, e) based on the binary_predicate c, such that all of the elements that satisfy c(*i, p) appear before all of the elements that fail to satisfy it. The postcondition is that, for some iterator middle in the range [b, e), c(*i,p) is true for every iterator i in the range [b, middle) and false for every iterator i in the range [middle,e).

Parameters:

	b	- the lower bound of the range
	e	- the upper bound of the range
	p	- the comparable value
	c	- the binary predicate to be checked

Returns:

The return value of stable_partition is middle.

Requirements on types:

• The type R is a model of instigate::stl::random_access_iterator

• The type C is a model of instigate::stl::binary_predicate

• R's value type is convertible to C's argument type.

• T is convertible to C's argument type.

Precondition:

[b, e] is a valid range.

References CHECK, instigate::stl::decrement(), instigate::stl::dereference(), instigate::stl::increment(), instigate::stl::invoke_predicate(), instigate::stl::iter_swap(), and instigate::stl::less_than().

template<typename R, typename T>

R instigate::stl::implementation::unguarded_partition	(	R	b,
		R	e,
		T	p
	)			[inline]

The first version of the unguarded_partition algorithm.

Unguarded_partition reorders the elements in the range [b, e) based on the less_than() method, such that all of the elements that less than p appear before all of the elements that fail to satisfy it. The postcondition is that,for some iterator middle in the range [b, e), less_than(*i,p) is true for every iterator i in the range [b, middle) and false for every iterator i in the range [middle,e).

Parameters:

	b	- the lower bound of the range
	e	- the upper bound of the range
	p	- the comparable value

Returns:

The return value of stable_partition is middle.

Requirements on types:

• The type R is a model of instigate::stl::random_access_iterator

Precondition:

[b, e] is a valid range.

References CHECK, instigate::stl::decrement(), instigate::stl::dereference(), instigate::stl::increment(), instigate::stl::iter_swap(), and instigate::stl::less_than().

Referenced by introsort_loop().

template<typename I, typename O, typename BP, typename Tp>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		BP	p,
		Tp *
	)			[inline]

Implementation of the unique_copy auxiliary function for the second version of the unique_copy algorithm

References instigate::stl::assign(), instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::invoke_predicate().

Referenced by instigate::stl::unique_copy().

template<typename I, typename O, typename BP>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		BP	p,
		instigate::stl::incrementable_iterator::tag
	)			[inline]

Implementation of the unique_copy auxiliary function for the second version of the unique_copy algorithm for the instigate::stl::incrementable_iterator::tag category

References unique_copy_aux().

template<typename I, typename O, typename BP>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		BP	p,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the unique_copy auxiliary function for the second version of the unique_copy algorithm for the instigate::stl::forward_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::equal(), instigate::stl::increment(), and instigate::stl::invoke_predicate().

template<typename I, typename O, typename Tp>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		Tp *
	)			[inline]

Implementation of the unique_copy_aux function for the first version of the unique_copy algorithm

References instigate::stl::assign(), instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::equal(), and instigate::stl::increment().

template<typename I, typename O>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		instigate::stl::incrementable_iterator::tag
	)			[inline]

Implementation of the unique_copy auxiliary function for the first version of the unique_copy algorithm for the instigate::stl::incrementable_iterator::tag category

References unique_copy_aux().

template<typename I, typename O>

O instigate::stl::implementation::unique_copy_aux	(	I	b,
		I	e,
		O	r,
		instigate::stl::forward_iterator::tag
	)			[inline]

Implementation of the unique_copy auxiliary function for the first version of the unique_copy algorithm for the instigate::stl::forward_iterator::tag category

References instigate::stl::const_dereference(), instigate::stl::dereference_assign(), instigate::stl::equal(), and instigate::stl::increment().

Referenced by unique_copy_aux().

template<typename F, typename L, typename C, typename D>

F instigate::stl::implementation::upper_bound_aux	(	F	b,
		F	e,
		const L &	v,
		C	c,
		D *
	)			[inline]

Implementation of the upper_bound_aux function for the second version of the algorithm

References instigate::stl::advance(), instigate::stl::assign(), CHECK_CONVERTIBILITY, instigate::stl::const_dereference(), instigate::stl::distance, instigate::stl::increment(), and instigate::stl::invoke_predicate().

template<typename F, typename L, typename D>

F instigate::stl::implementation::upper_bound_aux	(	F	b,
		F	e,
		const L &	v,
		D *
	)			[inline]

Implementation of the upper_bound_aux function for the first version of the algorithm

References instigate::stl::advance(), instigate::stl::assign(), CHECK_CONVERTIBILITY, instigate::stl::const_dereference(), instigate::stl::distance, instigate::stl::increment(), and instigate::stl::less_than().

Referenced by instigate::stl::upper_bound().