mirror of
https://github.com/boostorg/concept_check.git
synced 2026-05-19 23:34:52 +02:00
added tons of functions to stl_concept_covering.cpp
[SVN r8359]
This commit is contained in:
Jeremy Siek
+405
-87
@@ -10,12 +10,40 @@
|
||||
|
||||
/*
|
||||
|
||||
This file uses the archetype classes to verify whether the concept
|
||||
requirements documented for the STL algorithms actually *cover* the
|
||||
algorithms true requirements.
|
||||
This file uses the archetype classes to find out which concepts
|
||||
actually *cover* the algorithms true requirements. The
|
||||
archetypes/concepts chosen do not necessarily match the C++ standard
|
||||
or the SGI STL documentation, but instead were chosen based on the
|
||||
minimal concepts that current STL implementations require, which in
|
||||
many cases is less stringent than the standard. It is an open issue
|
||||
as to whether the C++ standard should be changed to reflect these
|
||||
weaker requirements.
|
||||
|
||||
*/
|
||||
|
||||
#define BOOST_HIDE_EXPECTED_ERRORS
|
||||
|
||||
// This is a special concept needed for std::swap_ranges.
|
||||
// It is mutually convertible, and also SGIAssignable
|
||||
template <class T>
|
||||
class mutually_convertible_archetype
|
||||
{
|
||||
private:
|
||||
mutually_convertible_archetype() { }
|
||||
public:
|
||||
mutually_convertible_archetype(const mutually_convertible_archetype&) { }
|
||||
mutually_convertible_archetype&
|
||||
operator=(const mutually_convertible_archetype&)
|
||||
{ return *this; }
|
||||
mutually_convertible_archetype(boost::detail::dummy_constructor) { }
|
||||
|
||||
template <class U>
|
||||
mutually_convertible_archetype&
|
||||
operator=(const mutually_convertible_archetype<U>&)
|
||||
{ return *this; }
|
||||
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
@@ -24,33 +52,22 @@ main()
|
||||
//===========================================================================
|
||||
// Non-mutating Algorithms
|
||||
{
|
||||
input_iterator_archetype< convertible_to_archetype< null_archetype > > in;
|
||||
unary_function_archetype< null_archetype, null_archetype> f;
|
||||
input_iterator_archetype<
|
||||
convertible_to_archetype< null_archetype<> > > in;
|
||||
unary_function_archetype< null_archetype<> , null_archetype<> >
|
||||
f(dummy_cons);
|
||||
std::for_each(in, in, f);
|
||||
}
|
||||
{
|
||||
/*
|
||||
SGI STL Docs and the C++ standard (25.1.2) requirements for
|
||||
std::for_each() are broken. They should be specified as follows:
|
||||
|
||||
template <class InputIterator, class T>
|
||||
InputIterator find(InputIterator first, InputIterator last,
|
||||
const T& value)
|
||||
{
|
||||
function_requires< InputIteratorConcept<InputIterator> >();
|
||||
typedef typename std::iterator_traits<InputIterator>::value_type
|
||||
value_type;
|
||||
function_requires< EqualityComparable2<value_type, T> >();
|
||||
...
|
||||
}
|
||||
*/
|
||||
input_iterator_archetype< null_archetype > in;
|
||||
left_equality_comparable_archetype< null_archetype > value(dummy_cons);
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
input_iterator_archetype< Left > in;
|
||||
equality_comparable2_second_archetype<> value(dummy_cons);
|
||||
in = std::find(in, in, value);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype< convertible_to_archetype< null_archetype > > in;
|
||||
unary_predicate_archetype< null_archetype > pred;
|
||||
input_iterator_archetype<
|
||||
convertible_to_archetype< null_archetype<> > > in;
|
||||
unary_predicate_archetype< null_archetype<> > pred(dummy_cons);
|
||||
in = std::find_if(in, in, pred);
|
||||
}
|
||||
{
|
||||
@@ -58,146 +75,447 @@ main()
|
||||
fo = std::adjacent_find(fo, fo);
|
||||
}
|
||||
{
|
||||
forward_iterator_archetype< convertible_to_archetype< null_archetype > > fo;
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
forward_iterator_archetype<
|
||||
convertible_to_archetype< null_archetype<> > > fo;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo = std::adjacent_find(fo, fo, pred);
|
||||
}
|
||||
{
|
||||
/* SGI STL documentation is wrong. The value type of the
|
||||
input iterator does not need to be equality comparable.
|
||||
*/
|
||||
input_iterator_archetype<null_archetype> in;
|
||||
typedef left_equality_comparable_archetype<null_archetype> Right;
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
input_iterator_archetype<Left> in;
|
||||
typedef equal_op_second_archetype<> Right;
|
||||
forward_iterator_archetype<Right> fo;
|
||||
in = std::find_first_of(in, in, fo, fo);
|
||||
}
|
||||
{
|
||||
typedef input_iterator_archetype<null_archetype> InIter;
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
typedef input_iterator_archetype<Left> InIter;
|
||||
InIter in;
|
||||
function_requires< InputIteratorConcept<InIter> >();
|
||||
left_equality_comparable_archetype<null_archetype> value(dummy_cons);
|
||||
equal_op_second_archetype<> value(dummy_cons);
|
||||
std::iterator_traits<InIter>::difference_type
|
||||
n = std::count(in, in, value);
|
||||
ignore_unused_variable_warning(n);
|
||||
}
|
||||
#if !defined(__KCC) && !defined(BOOST_HIDE_EXPECTED_ERRORS)
|
||||
{
|
||||
typedef input_iterator_archetype<null_archetype> InIter;
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
typedef input_iterator_archetype<Left> InIter;
|
||||
InIter in;
|
||||
left_equality_comparable_archetype<null_archetype> value(dummy_cons);
|
||||
equal_op_second_archetype<> value(dummy_cons);
|
||||
unsigned long n;
|
||||
std::count(in, in, value, n);
|
||||
}
|
||||
{
|
||||
typedef input_iterator_archetype< convertible_to_archetype<null_archetype> > InIter;
|
||||
input_iterator_archetype< convertible_to_archetype<null_archetype<> > > in;
|
||||
unary_predicate_archetype<null_archetype<> > pred;
|
||||
unsigned long n;
|
||||
std::count_if(in, in, pred, n);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
typedef input_iterator_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > InIter;
|
||||
InIter in;
|
||||
unary_predicate_archetype<null_archetype> pred;
|
||||
unary_predicate_archetype<null_archetype<> > pred(dummy_cons);
|
||||
std::iterator_traits<InIter>::difference_type
|
||||
n = std::count_if(in, in, pred);
|
||||
ignore_unused_variable_warning(n);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype< convertible_to_archetype<null_archetype> > in;
|
||||
unary_predicate_archetype<null_archetype> pred;
|
||||
unsigned long n;
|
||||
std::count_if(in, in, pred, n);
|
||||
}
|
||||
{
|
||||
/*
|
||||
SGI STL Documentation wrong. EqualityComparable not needed.
|
||||
*/
|
||||
typedef input_iterator_archetype<null_archetype> InIter1;
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
typedef input_iterator_archetype<Left> InIter1;
|
||||
InIter1 in1;
|
||||
typedef left_equality_comparable_archetype<null_archetype> Right;
|
||||
typedef equal_op_second_archetype<> Right;
|
||||
typedef input_iterator_archetype<Right> InIter2;
|
||||
InIter2 in2;
|
||||
std::pair<InIter1, InIter2> p = std::mismatch(in1, in1, in2);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
{
|
||||
typedef input_iterator_archetype< convertible_to_archetype<null_archetype> > InIter;
|
||||
typedef input_iterator_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > InIter;
|
||||
InIter in1, in2;
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: EqualityComparable not needed
|
||||
input_iterator_archetype<null_archetype> in1;
|
||||
typedef left_equality_comparable_archetype<null_archetype> Right;
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
input_iterator_archetype<Left> in1;
|
||||
typedef equality_comparable2_second_archetype<> Right;
|
||||
input_iterator_archetype<Right> in2;
|
||||
bool b = std::equal(in1, in1, in2);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype< convertible_to_archetype<null_archetype> > in1, in2;
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
input_iterator_archetype< convertible_to_archetype<null_archetype<> > >
|
||||
in1, in2;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
bool b = std::equal(in1, in1, in2, pred);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: EqualityComparable not needed
|
||||
forward_iterator_archetype<null_archetype> fo1;
|
||||
typedef left_equality_comparable_archetype<null_archetype> Right;
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<> Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
fo1 = std::search(fo1, fo1, fo2, fo2);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: LeftEqualityComparable missing
|
||||
// search() calls find()
|
||||
typedef convertible_to_archetype<null_archetype> Left;
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef convertible_to_archetype<null_archetype,
|
||||
left_equality_comparable_archetype<Left> > Right;
|
||||
typedef equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo1 = std::search(fo1, fo1, fo2, fo2, pred);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: EqualityComparable not needed
|
||||
forward_iterator_archetype<null_archetype> fo;
|
||||
left_equality_comparable_archetype<null_archetype> value(dummy_cons);
|
||||
int n;
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo;
|
||||
equality_comparable2_second_archetype<> value(dummy_cons);
|
||||
int n = 1;
|
||||
fo = std::search_n(fo, fo, n, value);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: EqualityComparable not needed
|
||||
forward_iterator_archetype< convertible_to_archetype<null_archetype> > fo;
|
||||
convertible_to_archetype<null_archetype> value(dummy_cons);
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
int n;
|
||||
forward_iterator_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > fo;
|
||||
convertible_to_archetype<null_archetype<> > value(dummy_cons);
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
int n = 1;
|
||||
fo = std::search_n(fo, fo, n, value, pred);
|
||||
}
|
||||
{
|
||||
forward_iterator_archetype<null_archetype> fo1;
|
||||
typedef left_equality_comparable_archetype<null_archetype> Right;
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<null_archetype<> > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
fo1 = std::find_end(fo1, fo1, fo2, fo2);
|
||||
}
|
||||
{
|
||||
// SGI STL docs: LeftEqualityComparable missing
|
||||
typedef convertible_to_archetype<null_archetype> Left;
|
||||
// equality comparable required because find_end() calls search
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef convertible_to_archetype<null_archetype,
|
||||
left_equality_comparable_archetype<Left> > Right;
|
||||
typedef equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
binary_predicate_archetype<null_archetype, null_archetype> pred;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo1 = std::find_end(fo1, fo1, fo2, fo2, pred);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Mutating Algorithms
|
||||
|
||||
// UNDER CONSTRUCTION
|
||||
|
||||
{
|
||||
// SGI STL docs missing CopyConstructible and Assignable
|
||||
typedef equality_comparable_archetype< copy_constructible_archetype<
|
||||
assignable_archetype<> > > T;
|
||||
typedef null_archetype<> OutT;
|
||||
typedef convertible_to_archetype<OutT> InT;
|
||||
input_iterator_archetype<InT> in;
|
||||
output_iterator_archetype<OutT> out;
|
||||
out = std::copy(in, in, out);
|
||||
}
|
||||
#if !defined(__KCC)
|
||||
{
|
||||
// Not in the C++ standard
|
||||
typedef null_archetype<> OutT;
|
||||
typedef convertible_to_archetype<OutT> InT;
|
||||
input_iterator_archetype<InT> in;
|
||||
output_iterator_archetype<OutT> out;
|
||||
int count = 1;
|
||||
std::pair<input_iterator_archetype<InT>,
|
||||
output_iterator_archetype<OutT> > result = std::copy_n(in, count, out);
|
||||
ignore_unused_variable_warning(result);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
typedef assignable_archetype<> OutT;
|
||||
typedef convertible_to_archetype<OutT> InT;
|
||||
bidirectional_iterator_archetype<InT> bid_in;
|
||||
bidirectional_iterator_archetype<OutT> bid_out;
|
||||
bid_out = std::copy_backward(bid_in, bid_in, bid_out);
|
||||
}
|
||||
{
|
||||
sgi_assignable_archetype<> a(dummy_cons), b(dummy_cons);
|
||||
std::swap(a, b);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
forward_iterator_archetype<T> a, b;
|
||||
std::iter_swap(a, b);
|
||||
}
|
||||
{
|
||||
typedef mutually_convertible_archetype<int> Tin;
|
||||
typedef mutually_convertible_archetype<char> Tout;
|
||||
forward_iterator_archetype<Tin> fi1;
|
||||
forward_iterator_archetype<Tout> fi2;
|
||||
fi2 = std::swap_ranges(fi1, fi1, fi2);
|
||||
}
|
||||
{
|
||||
typedef convertible_to_archetype<null_archetype<> > Tin;
|
||||
typedef null_archetype<> Tout;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
unary_function_archetype<null_archetype<> ,
|
||||
convertible_to_archetype<Tout> > op(dummy_cons);
|
||||
out = std::transform(in, in, out, op);
|
||||
}
|
||||
{
|
||||
typedef convertible_to_archetype<null_archetype<int> > Tin1;
|
||||
typedef convertible_to_archetype<null_archetype<char> > Tin2;
|
||||
typedef null_archetype<> Tout;
|
||||
input_iterator_archetype<Tin1> in1;
|
||||
input_iterator_archetype<Tin2> in2;
|
||||
output_iterator_archetype<Tout> out;
|
||||
binary_function_archetype<null_archetype<int>, null_archetype<char>,
|
||||
convertible_to_archetype<Tout> > op(dummy_cons);
|
||||
out = std::transform(in1, in1, in2, out, op);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<
|
||||
assignable_archetype<> > FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<FT> > value(dummy_cons);
|
||||
std::replace(fi, fi, value, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef assignable_archetype<
|
||||
convertible_to_archetype<PredArg> > FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
convertible_to_archetype<FT> value(dummy_cons);
|
||||
std::replace_if(fi, fi, pred, value);
|
||||
}
|
||||
{
|
||||
#if 0
|
||||
// Issue, the use of ?: inside replace_copy() complicates things
|
||||
typedef equal_op_first_archetype<> Tin;
|
||||
typedef null_archetype<> Tout;
|
||||
typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
T value(dummy_cons);
|
||||
out = std::replace_copy(in, in, out, value, value);
|
||||
#else
|
||||
typedef null_archetype<> Tout;
|
||||
typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
|
||||
// Adding convertible to T for Tin solves the problem, so would
|
||||
// making T convertible to Tin. Not sure what the right way to
|
||||
// express the requirement would be. Also, perhaps the
|
||||
// implementation's use of ?: is invalid.
|
||||
typedef equal_op_first_archetype< convertible_to_archetype<T> > Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
T value(dummy_cons);
|
||||
out = std::replace_copy(in, in, out, value, value);
|
||||
#endif
|
||||
}
|
||||
{
|
||||
// The issue of ?: also affects this function
|
||||
typedef null_archetype<int> PredArg;
|
||||
typedef null_archetype<char> Tout;
|
||||
typedef convertible_to_archetype<Tout,
|
||||
convertible_to_archetype<PredArg> > T;
|
||||
typedef convertible_to_archetype<PredArg,
|
||||
convertible_to_archetype<Tout,
|
||||
convertible_to_archetype<T> > > Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
T value(dummy_cons);
|
||||
out = std::replace_copy_if(in, in, out, pred, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
typedef convertible_to_archetype<FT> T;
|
||||
T value(dummy_cons);
|
||||
std::fill(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> T;
|
||||
output_iterator_archetype<Tout> out;
|
||||
T value(dummy_cons);
|
||||
int n = 1;
|
||||
out = std::fill_n(out, n, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
typedef convertible_to_archetype<FT> Ret;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
generator_archetype<Ret> gen;
|
||||
std::generate(fi, fi, gen);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
typedef convertible_to_archetype<FT> Ret;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
generator_archetype<Ret> gen;
|
||||
int n = 1;
|
||||
std::generate_n(fi, n, gen);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype< equality_comparable2_first_archetype<> > FT;
|
||||
typedef equality_comparable2_second_archetype<> T;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
fi = std::remove(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
typedef null_archetype<> PredArg;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
fi = std::remove_if(fi, fi, pred);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<Tout> > Tin;
|
||||
typedef equality_comparable2_second_archetype<> T;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
T value(dummy_cons);
|
||||
out = std::remove_copy(in, in, out, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Tout;
|
||||
typedef null_archetype<char> PredArg;
|
||||
typedef convertible_to_archetype<PredArg,
|
||||
convertible_to_archetype<Tout> > Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
out = std::remove_copy_if(in, in, out, pred);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype< equality_comparable_archetype<> > T;
|
||||
forward_iterator_archetype<T> fi;
|
||||
fi = std::unique(fi, fi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > > FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
|
||||
fi = std::unique(fi, fi, pred);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable_archetype< sgi_assignable_archetype<> > T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype out;
|
||||
output_iterator_archetype<T> out;
|
||||
out = std::unique_copy(in, in, out);
|
||||
}
|
||||
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef null_archetype<short> Tout;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Tout,
|
||||
convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > > > Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
|
||||
out = std::unique_copy(in, in, out, pred);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
bidirectional_iterator_archetype<T> bi;
|
||||
std::reverse(bi, bi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
bidirectional_iterator_archetype<Tin> bi;
|
||||
output_iterator_archetype<Tout> out;
|
||||
out = std::reverse_copy(bi, bi, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
forward_iterator_archetype<T> fi;
|
||||
// Issue, SGI STL is not have void return type, C++ standard does
|
||||
std::rotate(fi, fi, fi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
output_iterator_archetype<Tout> out;
|
||||
out = std::rotate_copy(fi, fi, fi, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
random_access_iterator_archetype<T> ri;
|
||||
std::random_shuffle(ri, ri);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
random_access_iterator_archetype<T> ri;
|
||||
unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
|
||||
std::random_shuffle(ri, ri, ran);
|
||||
}
|
||||
#if !defined(__KCC)
|
||||
{
|
||||
typedef assignable_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
random_access_iterator_archetype<Tout> ri_out;
|
||||
ri_out = std::random_sample(in, in, ri_out, ri_out);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
random_access_iterator_archetype<Tout> ri_out;
|
||||
unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
|
||||
ri_out = std::random_sample(in, in, ri_out, ri_out, ran);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
forward_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out;
|
||||
int n = 1;
|
||||
out = std::random_sample_n(in, in, out, n);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
forward_iterator_archetype<Tout> out;
|
||||
unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
|
||||
int n = 1;
|
||||
out = std::random_sample_n(in, in, out, n, ran);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
|
||||
bidirectional_iterator_archetype<FT> bi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
bi = std::partition(bi, bi, pred);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
fi = std::stable_partition(fi, fi, pred);
|
||||
}
|
||||
//===========================================================================
|
||||
// Sorting Algorithms
|
||||
|
||||
|
||||
Reference in New Issue
Block a user