feedc0de/boost_concept_check
1
0
Fork 0
forked from boostorg/concept_check
Code Pull Requests Activity

updating with respect to change in input_iterator_archetype

Browse Source 
[SVN r22183]
This commit is contained in:
Jeremy Siek
2004-02-06 05:47:22 +00:00
parent 6547eb9803
commit cc25398b06
1 changed files with 72 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
stl_concept_covering.cpp
View File

@@ -93,22 +93,19 @@ namespace boost { // so Koenig lookup will find
// for std::partial_sum and adj_diff // for std::partial_sum and adj_diff
namespace part_sum namespace part_sum
{ {
typedef boost::null_archetype<> Tout; class T {
typedef boost::sgi_assignable_archetype<
boost::convertible_to_archetype<Tout> > Ret;
class Tin {
public: public:
Tin(const Ret&) { } typedef boost::sgi_assignable_archetype<> Ret;
Tin(boost::detail::dummy_constructor x) { } T(const Ret&) { }
operator const Tout&() const { return boost::static_object<Tout>::get(); } T(boost::detail::dummy_constructor x) { }
private: private:
Tin() { } T() { }
}; };
Ret operator+(const Tin&, const Tin&) { T::Ret operator+(const T&, const T&) {
return Ret(dummy_cons); return T::Ret(dummy_cons);
} }
Ret operator-(const Tin&, const Tin&) { T::Ret operator-(const T&, const T&) {
return Ret(dummy_cons); return T::Ret(dummy_cons);
} }
} }
@@ -130,6 +127,7 @@ namespace power_stuff {
struct tag1 { }; struct tag1 { };
struct tag2 { }; struct tag2 { };
int int
main() main()
{ {
@@ -138,12 +136,12 @@ main()
//=========================================================================== //===========================================================================
// Non-mutating Algorithms // Non-mutating Algorithms
{ {
input_iterator_archetype< input_iterator_archetype< null_archetype<> > in;
convertible_to_archetype< null_archetype<> > > in;
unary_function_archetype< null_archetype<> , null_archetype<> > unary_function_archetype< null_archetype<> , null_archetype<> >
f(dummy_cons); f(dummy_cons);
std::for_each(in, in, f); std::for_each(in, in, f);
} }
// gcc bug
{ {
typedef equality_comparable2_first_archetype<> Left; typedef equality_comparable2_first_archetype<> Left;
input_iterator_archetype< Left > in; input_iterator_archetype< Left > in;
@@ -151,9 +149,9 @@ main()
in = std::find(in, in, value); in = std::find(in, in, value);
} }
{ {
input_iterator_archetype< typedef null_archetype<> T;
convertible_to_archetype< null_archetype<> > > in; input_iterator_archetype<T> in;
unary_predicate_archetype< null_archetype<> > pred(dummy_cons); unary_predicate_archetype<T> pred(dummy_cons);
in = std::find_if(in, in, pred); in = std::find_if(in, in, pred);
} }
{ {
@@ -167,6 +165,7 @@ main()
pred(dummy_cons); pred(dummy_cons);
fo = std::adjacent_find(fo, fo, pred); fo = std::adjacent_find(fo, fo, pred);
} }
// gcc bug
{ {
typedef equal_op_first_archetype<> Left; typedef equal_op_first_archetype<> Left;
input_iterator_archetype<Left> in; input_iterator_archetype<Left> in;
@@ -185,14 +184,14 @@ main()
ignore_unused_variable_warning(n); ignore_unused_variable_warning(n);
} }
{ {
typedef input_iterator_archetype< typedef input_iterator_archetype< null_archetype<> > InIter;
convertible_to_archetype<null_archetype<> > > InIter;
InIter in; InIter in;
unary_predicate_archetype<null_archetype<> > pred(dummy_cons); unary_predicate_archetype<null_archetype<> > pred(dummy_cons);
std::iterator_traits<InIter>::difference_type std::iterator_traits<InIter>::difference_type
n = std::count_if(in, in, pred); n = std::count_if(in, in, pred);
ignore_unused_variable_warning(n); ignore_unused_variable_warning(n);
} }
// gcc bug
{ {
typedef equal_op_first_archetype<> Left; typedef equal_op_first_archetype<> Left;
typedef input_iterator_archetype<Left> InIter1; typedef input_iterator_archetype<Left> InIter1;
@@ -204,14 +203,14 @@ main()
ignore_unused_variable_warning(p); ignore_unused_variable_warning(p);
} }
{ {
typedef input_iterator_archetype< typedef input_iterator_archetype<null_archetype<> > InIter;
convertible_to_archetype<null_archetype<> > > InIter;
InIter in1, in2; InIter in1, in2;
binary_predicate_archetype<null_archetype<> , null_archetype<> > binary_predicate_archetype<null_archetype<> , null_archetype<> >
pred(dummy_cons); pred(dummy_cons);
std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred); std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred);
ignore_unused_variable_warning(p); ignore_unused_variable_warning(p);
} }
// gcc bug
{ {
typedef equality_comparable2_first_archetype<> Left; typedef equality_comparable2_first_archetype<> Left;
input_iterator_archetype<Left> in1; input_iterator_archetype<Left> in1;
@@ -221,7 +220,7 @@ main()
ignore_unused_variable_warning(b); ignore_unused_variable_warning(b);
} }
{ {
input_iterator_archetype< convertible_to_archetype<null_archetype<> > > input_iterator_archetype< null_archetype<> >
in1, in2; in1, in2;
binary_predicate_archetype<null_archetype<> , null_archetype<> > binary_predicate_archetype<null_archetype<> , null_archetype<> >
pred(dummy_cons); pred(dummy_cons);
@@ -286,10 +285,9 @@ main()
// Mutating Algorithms // Mutating Algorithms
{ {
typedef null_archetype<> OutT; typedef null_archetype<> T;
typedef convertible_to_archetype<OutT> InT; input_iterator_archetype<T> in;
input_iterator_archetype<InT> in; output_iterator_archetype<T> out(dummy_cons);
output_iterator_archetype<OutT> out(dummy_cons);
out = std::copy(in, in, out); out = std::copy(in, in, out);
} }
{ {
@@ -316,8 +314,8 @@ main()
fi2 = std::swap_ranges(fi1, fi1, fi2); fi2 = std::swap_ranges(fi1, fi1, fi2);
} }
{ {
typedef convertible_to_archetype<null_archetype<> > Tin; typedef null_archetype<int> Tin;
typedef null_archetype<> Tout; typedef null_archetype<char> Tout;
input_iterator_archetype<Tin> in; input_iterator_archetype<Tin> in;
output_iterator_archetype<Tout> out(dummy_cons); output_iterator_archetype<Tout> out(dummy_cons);
unary_function_archetype<null_archetype<> , unary_function_archetype<null_archetype<> ,
@@ -325,13 +323,13 @@ main()
out = std::transform(in, in, out, op); out = std::transform(in, in, out, op);
} }
{ {
typedef convertible_to_archetype<null_archetype<int> > Tin1; typedef null_archetype<int> Tin1;
typedef convertible_to_archetype<null_archetype<char> > Tin2; typedef null_archetype<char> Tin2;
typedef null_archetype<> Tout; typedef null_archetype<double> Tout;
input_iterator_archetype<Tin1> in1; input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2; input_iterator_archetype<Tin2> in2;
output_iterator_archetype<Tout> out(dummy_cons); output_iterator_archetype<Tout> out(dummy_cons);
binary_function_archetype<null_archetype<int>, null_archetype<char>, binary_function_archetype<Tin1, Tin2,
convertible_to_archetype<Tout> > op(dummy_cons); convertible_to_archetype<Tout> > op(dummy_cons);
out = std::transform(in1, in1, in2, out, op); out = std::transform(in1, in1, in2, out, op);
} }
@@ -352,8 +350,8 @@ main()
convertible_to_archetype<FT> value(dummy_cons); convertible_to_archetype<FT> value(dummy_cons);
std::replace_if(fi, fi, pred, value); std::replace_if(fi, fi, pred, value);
} }
// gcc bug
{ {
#if 0
// Issue, the use of ?: inside replace_copy() complicates things // Issue, the use of ?: inside replace_copy() complicates things
typedef equal_op_first_archetype<> Tin; typedef equal_op_first_archetype<> Tin;
typedef null_archetype<> Tout; typedef null_archetype<> Tout;
@@ -362,33 +360,15 @@ main()
output_iterator_archetype<Tout> out(dummy_cons); output_iterator_archetype<Tout> out(dummy_cons);
T value(dummy_cons); T value(dummy_cons);
out = std::replace_copy(in, in, out, value, value); 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(dummy_cons);
T value(dummy_cons);
out = std::replace_copy(in, in, out, value, value);
#endif
} }
{ {
// The issue of ?: also affects this function // The issue of ?: also affects this function
typedef null_archetype<int> PredArg; typedef null_archetype<> Tout;
typedef null_archetype<char> Tout; typedef assignable_archetype< convertible_to_archetype<Tout> > Tin;
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; input_iterator_archetype<Tin> in;
output_iterator_archetype<Tout> out(dummy_cons); output_iterator_archetype<Tout> out(dummy_cons);
unary_predicate_archetype<PredArg> pred(dummy_cons); unary_predicate_archetype<Tin> pred(dummy_cons);
T value(dummy_cons); Tin value(dummy_cons);
out = std::replace_copy_if(in, in, out, pred, value); out = std::replace_copy_if(in, in, out, pred, value);
} }
{ {
@@ -435,6 +415,7 @@ main()
unary_predicate_archetype<PredArg> pred(dummy_cons); unary_predicate_archetype<PredArg> pred(dummy_cons);
fi = std::remove_if(fi, fi, pred); fi = std::remove_if(fi, fi, pred);
} }
// gcc bug
{ {
typedef null_archetype<> Tout; typedef null_archetype<> Tout;
typedef equality_comparable2_first_archetype< typedef equality_comparable2_first_archetype<
@@ -446,13 +427,10 @@ main()
out = std::remove_copy(in, in, out, value); out = std::remove_copy(in, in, out, value);
} }
{ {
typedef null_archetype<int> Tout; typedef null_archetype<> T;
typedef null_archetype<char> PredArg; input_iterator_archetype<T> in;
typedef convertible_to_archetype<PredArg, output_iterator_archetype<T> out(dummy_cons);
convertible_to_archetype<Tout> > Tin; unary_predicate_archetype<T> pred(dummy_cons);
input_iterator_archetype<Tin> in;
output_iterator_archetype<Tout> out(dummy_cons);
unary_predicate_archetype<PredArg> pred(dummy_cons);
out = std::remove_copy_if(in, in, out, pred); out = std::remove_copy_if(in, in, out, pred);
} }
{ {
@@ -470,6 +448,7 @@ main()
binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons); binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
fi = std::unique(fi, fi, pred); fi = std::unique(fi, fi, pred);
} }
// gcc bug
{ {
typedef equality_comparable_archetype< sgi_assignable_archetype<> > T; typedef equality_comparable_archetype< sgi_assignable_archetype<> > T;
input_iterator_archetype<T> in; input_iterator_archetype<T> in;
@@ -477,16 +456,10 @@ main()
out = std::unique_copy(in, in, out); out = std::unique_copy(in, in, out);
} }
{ {
typedef null_archetype<int> Arg1; typedef sgi_assignable_archetype<> T;
typedef null_archetype<char> Arg2; input_iterator_archetype<T> in;
typedef null_archetype<short> Tout; output_iterator_archetype<T> out(dummy_cons);
typedef sgi_assignable_archetype< binary_predicate_archetype<T, T> pred(dummy_cons);
convertible_to_archetype<Tout,
convertible_to_archetype<Arg1,
convertible_to_archetype<Arg2> > > > Tin;
input_iterator_archetype<Tin> in;
output_iterator_archetype<Tout> out(dummy_cons);
binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
out = std::unique_copy(in, in, out, pred); out = std::unique_copy(in, in, out, pred);
} }
{ {
@@ -585,6 +558,7 @@ main()
binary_predicate_archetype<Arg, Arg> comp(dummy_cons); binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
std::partial_sort(ri, ri, ri, comp); std::partial_sort(ri, ri, ri, comp);
} }
// gcc bug
{ {
// This could be formulated so that the two iterators are not // This could be formulated so that the two iterators are not
// required to have the same value type, but it is messy. // required to have the same value type, but it is messy.
@@ -595,12 +569,10 @@ main()
ri_out = std::partial_sort_copy(in, in , ri_out, ri_out); ri_out = std::partial_sort_copy(in, in , ri_out, ri_out);
} }
{ {
typedef null_archetype<> Arg; typedef sgi_assignable_archetype<> T;
typedef sgi_assignable_archetype<
convertible_to_archetype<Arg> > T;
input_iterator_archetype<T> in; input_iterator_archetype<T> in;
mutable_random_access_iterator_archetype<T> ri_out; mutable_random_access_iterator_archetype<T> ri_out;
binary_predicate_archetype<Arg, Arg> comp(dummy_cons); binary_predicate_archetype<T, T> comp(dummy_cons);
ri_out = std::partial_sort_copy(in, in , ri_out, ri_out, comp); ri_out = std::partial_sort_copy(in, in , ri_out, ri_out, comp);
} }
{ {
@@ -737,6 +709,7 @@ main()
less_than_op_first_archetype< less_than_op_first_archetype<
convertible_to_archetype<Tout>, optag2> ,optag1> Tin2; convertible_to_archetype<Tout>, optag2> ,optag1> Tin2;
#endif #endif
// gcc bug
input_iterator_archetype<Tin1> in1; input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2; input_iterator_archetype<Tin2> in2;
output_iterator_archetype<Tout> out(dummy_cons); output_iterator_archetype<Tout> out(dummy_cons);
@@ -747,21 +720,12 @@ main()
out = std::set_symmetric_difference(in1, in1, in2, in2, out); out = std::set_symmetric_difference(in1, in1, in2, in2, out);
} }
{ {
typedef null_archetype<int> Arg1; typedef null_archetype<> T;
typedef null_archetype<char> Arg2; input_iterator_archetype<T> in1;
typedef null_archetype<short> Tout; input_iterator_archetype<T,2> in2;
#if defined(__GNUC__) || defined(__KCC) typedef convertible_from_archetype<T> Tout;
typedef convertible_to_archetype<Tout, output_iterator_archetype<T> out(dummy_cons);
convertible_to_archetype<Arg1, binary_predicate_archetype<T, T> comp(dummy_cons);
convertible_to_archetype<Arg2> > > Tin1;
typedef convertible_to_archetype<Tout,
convertible_to_archetype<Arg2,
convertible_to_archetype<Arg1> > > Tin2;
#endif
input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2;
output_iterator_archetype<Tout> out(dummy_cons);
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
out = std::merge(in1, in1, in2, in2, out, comp); out = std::merge(in1, in1, in2, in2, out, comp);
out = std::set_union(in1, in1, in2, in2, out, comp); out = std::set_union(in1, in1, in2, in2, out, comp);
out = std::set_intersection(in1, in1, in2, in2, out, comp); out = std::set_intersection(in1, in1, in2, in2, out, comp);
@@ -782,13 +746,12 @@ main()
binary_predicate_archetype<Arg, Arg> comp(dummy_cons); binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
std::inplace_merge(bi, bi, bi, comp); std::inplace_merge(bi, bi, bi, comp);
} }
// gcc bug
{ {
#if defined(__GNUC__) || defined(__KCC)
typedef less_than_op_first_archetype< typedef less_than_op_first_archetype<
less_than_op_second_archetype<null_archetype<>, optag1>, optag2> Tin1; less_than_op_second_archetype<null_archetype<>, optag1>, optag2> Tin1;
typedef less_than_op_second_archetype< typedef less_than_op_second_archetype<
less_than_op_first_archetype<null_archetype<>, optag1>, optag2> Tin2; less_than_op_first_archetype<null_archetype<>, optag1>, optag2> Tin2;
#endif
input_iterator_archetype<Tin1> in1; input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2; input_iterator_archetype<Tin2> in2;
bool b = std::includes(in1, in1, in2, in2); bool b = std::includes(in1, in1, in2, in2);
@@ -796,17 +759,10 @@ main()
ignore_unused_variable_warning(b); ignore_unused_variable_warning(b);
} }
{ {
typedef null_archetype<int> Arg1; typedef null_archetype<int> Tin;
typedef null_archetype<char> Arg2; input_iterator_archetype<Tin> in1;
#if defined(__GNUC__) || defined(__KCC) input_iterator_archetype<Tin,1> in2;
typedef convertible_to_archetype<Arg1, binary_predicate_archetype<Tin, Tin> comp(dummy_cons);
convertible_to_archetype<Arg2> > Tin1;
typedef convertible_to_archetype<Arg2,
convertible_to_archetype<Arg1> > Tin2;
#endif
input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2;
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
bool b = std::includes(in1, in1, in2, in2, comp); bool b = std::includes(in1, in1, in2, in2, comp);
b = std::lexicographical_compare(in1, in1, in2, in2, comp); b = std::lexicographical_compare(in1, in1, in2, in2, comp);
ignore_unused_variable_warning(b); ignore_unused_variable_warning(b);
@@ -897,8 +853,7 @@ main()
typedef sgi_assignable_archetype< typedef sgi_assignable_archetype<
convertible_to_archetype<Arg1> > T; convertible_to_archetype<Arg1> > T;
typedef convertible_to_archetype<T> Ret; typedef convertible_to_archetype<T> Ret;
typedef convertible_to_archetype<Arg2> Tin; input_iterator_archetype<Arg2> in;
input_iterator_archetype<Tin> in;
T init(dummy_cons); T init(dummy_cons);
binary_function_archetype<Arg1, Arg2, Ret> op(dummy_cons); binary_function_archetype<Arg1, Arg2, Ret> op(dummy_cons);
init = std::accumulate(in, in, init, op); init = std::accumulate(in, in, init, op);
@@ -918,38 +873,30 @@ main()
convertible_to_archetype<AddArg1> > T; convertible_to_archetype<AddArg1> > T;
typedef convertible_to_archetype<AddArg2> RetMult; typedef convertible_to_archetype<AddArg2> RetMult;
typedef convertible_to_archetype<T> RetAdd; typedef convertible_to_archetype<T> RetAdd;
typedef convertible_to_archetype<MultArg1> Tin1; input_iterator_archetype<MultArg1> in1;
typedef convertible_to_archetype<MultArg2> Tin2; input_iterator_archetype<MultArg2> in2;
input_iterator_archetype<Tin1> in1;
input_iterator_archetype<Tin2> in2;
T init(dummy_cons); T init(dummy_cons);
binary_function_archetype<MultArg1, MultArg2, RetMult> mult_op(dummy_cons); binary_function_archetype<MultArg1, MultArg2, RetMult> mult_op(dummy_cons);
binary_function_archetype<AddArg1, AddArg2, RetAdd> add_op(dummy_cons); binary_function_archetype<AddArg1, AddArg2, RetAdd> add_op(dummy_cons);
init = std::inner_product(in1, in1, in2, init, add_op, mult_op); init = std::inner_product(in1, in1, in2, init, add_op, mult_op);
} }
{ {
input_iterator_archetype<part_sum::Tin> in; input_iterator_archetype<part_sum::T> in;
output_iterator_archetype<part_sum::Tout> out(dummy_cons); output_iterator_archetype<part_sum::T> out(dummy_cons);
out = std::partial_sum(in, in, out); out = std::partial_sum(in, in, out);
} }
{ {
typedef null_archetype<int> Arg; typedef sgi_assignable_archetype<> T;
typedef null_archetype<char> Tout; input_iterator_archetype<T> in;
typedef sgi_assignable_archetype< output_iterator_archetype<T> out(dummy_cons);
convertible_to_archetype<Arg, binary_function_archetype<T, T, T> add_op(dummy_cons);
convertible_to_archetype<Tout> > > Tin;
typedef convertible_to_archetype<Tout,
convertible_to_archetype<Tin> > Ret;
input_iterator_archetype<Tin> in;
output_iterator_archetype<Tout> out(dummy_cons);
binary_function_archetype<Arg, Arg, Ret> add_op(dummy_cons);
out = std::partial_sum(in, in, out, add_op); out = std::partial_sum(in, in, out, add_op);
binary_function_archetype<Arg, Arg, Ret> subtract_op(dummy_cons); binary_function_archetype<T, T, T> subtract_op(dummy_cons);
out = std::adjacent_difference(in, in, out, subtract_op); out = std::adjacent_difference(in, in, out, subtract_op);
} }
{ {
input_iterator_archetype<part_sum::Tin> in; input_iterator_archetype<part_sum::T> in;
output_iterator_archetype<part_sum::Tout> out(dummy_cons); output_iterator_archetype<part_sum::T> out(dummy_cons);
out = std::adjacent_difference(in, in, out); out = std::adjacent_difference(in, in, out);
} }
return 0; return 0;