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

Merging fixes to release; fixes #2294 fixes #4918 fixes #3645 refs #2823 refs #1427 refs #2893

Browse Source 
[SVN r67792]
This commit is contained in:
Marshall Clow
2011-01-08 18:38:08 +00:00
parent 807fcd7b97
commit 7dec68923d
1 changed files with 102 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
include/boost/concept_check.hpp
View File

@@ -38,14 +38,14 @@ namespace boost
// //
// Backward compatibility // Backward compatibility
// //
template <class Model> template <class Model>
inline void function_requires(Model* = 0) inline void function_requires(Model* = 0)
{ {
BOOST_CONCEPT_ASSERT((Model)); BOOST_CONCEPT_ASSERT((Model));
} }
template <class T> inline void ignore_unused_variable_warning(T const&) {} template <class T> inline void ignore_unused_variable_warning(T const&) {}
# define BOOST_CLASS_REQUIRE(type_var, ns, concept) \ # define BOOST_CLASS_REQUIRE(type_var, ns, concept) \
BOOST_CONCEPT_ASSERT((ns::concept<type_var>)) BOOST_CONCEPT_ASSERT((ns::concept<type_var>))
@@ -58,20 +58,21 @@ namespace boost
# define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \ # define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>)) BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))
// //
// Begin concept definitions // Begin concept definitions
// //
BOOST_concept(Integer, (T)) BOOST_concept(Integer, (T))
{ {
BOOST_CONCEPT_USAGE(Integer) BOOST_CONCEPT_USAGE(Integer)
{ {
x.error_type_must_be_an_integer_type(); x.error_type_must_be_an_integer_type();
} }
private: private:
T x; T x;
}; };
template <> struct Integer<char> {};
template <> struct Integer<signed char> {}; template <> struct Integer<signed char> {};
template <> struct Integer<unsigned char> {}; template <> struct Integer<unsigned char> {};
template <> struct Integer<short> {}; template <> struct Integer<short> {};
@@ -89,7 +90,7 @@ namespace boost
# endif # endif
BOOST_concept(SignedInteger,(T)) { BOOST_concept(SignedInteger,(T)) {
BOOST_CONCEPT_USAGE(SignedInteger) { BOOST_CONCEPT_USAGE(SignedInteger) {
x.error_type_must_be_a_signed_integer_type(); x.error_type_must_be_a_signed_integer_type();
} }
private: private:
@@ -103,16 +104,16 @@ namespace boost
template <> struct SignedInteger< ::boost::long_long_type> {}; template <> struct SignedInteger< ::boost::long_long_type> {};
# elif defined(BOOST_HAS_MS_INT64) # elif defined(BOOST_HAS_MS_INT64)
template <> struct SignedInteger<__int64> {}; template <> struct SignedInteger<__int64> {};
# endif # endif
BOOST_concept(UnsignedInteger,(T)) { BOOST_concept(UnsignedInteger,(T)) {
BOOST_CONCEPT_USAGE(UnsignedInteger) { BOOST_CONCEPT_USAGE(UnsignedInteger) {
x.error_type_must_be_an_unsigned_integer_type(); x.error_type_must_be_an_unsigned_integer_type();
} }
private: private:
T x; T x;
}; };
template <> struct UnsignedInteger<unsigned char> {}; template <> struct UnsignedInteger<unsigned char> {};
template <> struct UnsignedInteger<unsigned short> {}; template <> struct UnsignedInteger<unsigned short> {};
template <> struct UnsignedInteger<unsigned int> {}; template <> struct UnsignedInteger<unsigned int> {};
@@ -138,23 +139,24 @@ namespace boost
{ {
BOOST_CONCEPT_USAGE(Assignable) { BOOST_CONCEPT_USAGE(Assignable) {
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = a; // require assignment operator a = b; // require assignment operator
#endif #endif
const_constraints(a); const_constraints(b);
} }
private: private:
void const_constraints(const TT& b) { void const_constraints(const TT& x) {
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = b; // const required for argument to assignment a = x; // const required for argument to assignment
#else #else
ignore_unused_variable_warning(b); ignore_unused_variable_warning(x);
#endif #endif
} }
private: private:
TT a; TT a;
TT b;
}; };
BOOST_concept(CopyConstructible,(TT)) BOOST_concept(CopyConstructible,(TT))
{ {
BOOST_CONCEPT_USAGE(CopyConstructible) { BOOST_CONCEPT_USAGE(CopyConstructible) {
@@ -182,22 +184,23 @@ namespace boost
BOOST_concept(SGIAssignable,(TT)) BOOST_concept(SGIAssignable,(TT))
{ {
BOOST_CONCEPT_USAGE(SGIAssignable) { BOOST_CONCEPT_USAGE(SGIAssignable) {
TT b(a); TT c(a);
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = a; // require assignment operator a = b; // require assignment operator
#endif #endif
const_constraints(a); const_constraints(b);
ignore_unused_variable_warning(b); ignore_unused_variable_warning(c);
} }
private: private:
void const_constraints(const TT& b) { void const_constraints(const TT& x) {
TT c(b); TT c(x);
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = b; // const required for argument to assignment a = x; // const required for argument to assignment
#endif #endif
ignore_unused_variable_warning(c); ignore_unused_variable_warning(c);
} }
TT a; TT a;
TT b;
}; };
#if (defined _MSC_VER) #if (defined _MSC_VER)
# pragma warning( pop ) # pragma warning( pop )
@@ -299,7 +302,7 @@ namespace boost
BOOST_concept(Generator,(Func)(Return)) BOOST_concept(Generator,(Func)(Return))
{ {
BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); } BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
private: private:
void test(boost::mpl::false_) void test(boost::mpl::false_)
{ {
@@ -312,22 +315,22 @@ namespace boost
{ {
f(); f();
} }
Func f; Func f;
}; };
BOOST_concept(UnaryFunction,(Func)(Return)(Arg)) BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
{ {
BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); } BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
private: private:
void test(boost::mpl::false_) void test(boost::mpl::false_)
{ {
f(arg); // "priming the pump" this way keeps msvc6 happy (ICE) f(arg); // "priming the pump" this way keeps msvc6 happy (ICE)
Return r = f(arg); Return r = f(arg);
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
} }
void test(boost::mpl::true_) void test(boost::mpl::true_)
{ {
f(arg); f(arg);
@@ -356,12 +359,21 @@ namespace boost
Return r = f(first, second); // require operator() Return r = f(first, second); // require operator()
(void)r; (void)r;
} }
void test(boost::mpl::true_) void test(boost::mpl::true_)
{ {
f(first,second); f(first,second);
} }
#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
&& BOOST_WORKAROUND(__GNUC__, > 3)))
// Declare a dummy constructor to make gcc happy.
// It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
// (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg"
// in class without a constructor [-Wuninitialized])
BinaryFunction();
#endif
Func f; Func f;
First first; First first;
Second second; Second second;
@@ -373,6 +385,15 @@ namespace boost
require_boolean_expr(f(arg)); // require operator() returning bool require_boolean_expr(f(arg)); // require operator() returning bool
} }
private: private:
#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
&& BOOST_WORKAROUND(__GNUC__, > 3)))
// Declare a dummy constructor to make gcc happy.
// It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
// (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg"
// in class without a constructor [-Wuninitialized])
UnaryPredicate();
#endif
Func f; Func f;
Arg arg; Arg arg;
}; };
@@ -383,6 +404,14 @@ namespace boost
require_boolean_expr(f(a, b)); // require operator() returning bool require_boolean_expr(f(a, b)); // require operator() returning bool
} }
private: private:
#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
&& BOOST_WORKAROUND(__GNUC__, > 3)))
// Declare a dummy constructor to make gcc happy.
// It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
// (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg"
// in class without a constructor [-Wuninitialized])
BinaryPredicate();
#endif
Func f; Func f;
First a; First a;
Second b; Second b;
@@ -392,7 +421,7 @@ namespace boost
BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second)) BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
: BinaryPredicate<Func, First, Second> : BinaryPredicate<Func, First, Second>
{ {
BOOST_CONCEPT_USAGE(Const_BinaryPredicate) { BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
const_constraints(f); const_constraints(f);
} }
private: private:
@@ -400,6 +429,15 @@ namespace boost
// operator() must be a const member function // operator() must be a const member function
require_boolean_expr(fun(a, b)); require_boolean_expr(fun(a, b));
} }
#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
&& BOOST_WORKAROUND(__GNUC__, > 3)))
// Declare a dummy constructor to make gcc happy.
// It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
// (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg"
// in class without a constructor [-Wuninitialized])
Const_BinaryPredicate();
#endif
Func f; Func f;
First a; First a;
Second b; Second b;
@@ -409,7 +447,7 @@ namespace boost
: Generator<Func, typename Func::result_type> : Generator<Func, typename Func::result_type>
{ {
typedef typename Func::result_type result_type; typedef typename Func::result_type result_type;
BOOST_CONCEPT_USAGE(AdaptableGenerator) BOOST_CONCEPT_USAGE(AdaptableGenerator)
{ {
BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>)); BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -440,7 +478,7 @@ namespace boost
typedef typename Func::first_argument_type first_argument_type; typedef typename Func::first_argument_type first_argument_type;
typedef typename Func::second_argument_type second_argument_type; typedef typename Func::second_argument_type second_argument_type;
typedef typename Func::result_type result_type; typedef typename Func::result_type result_type;
~AdaptableBinaryFunction() ~AdaptableBinaryFunction()
{ {
BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>)); BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -478,7 +516,7 @@ namespace boost
{ {
BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>)); BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>)); BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
TT j(i); TT j(i);
(void)*i; // require dereference operator (void)*i; // require dereference operator
++j; // require preincrement operator ++j; // require preincrement operator
@@ -492,7 +530,7 @@ namespace boost
: Assignable<TT> : Assignable<TT>
{ {
BOOST_CONCEPT_USAGE(OutputIterator) { BOOST_CONCEPT_USAGE(OutputIterator) {
++i; // require preincrement operator ++i; // require preincrement operator
i++; // require postincrement operator i++; // require postincrement operator
*i++ = t; // require postincrement and assignment *i++ = t; // require postincrement and assignment
@@ -511,11 +549,11 @@ namespace boost
BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
, std::forward_iterator_tag , std::forward_iterator_tag
>)); >));
typename InputIterator<TT>::reference r = *i; typename InputIterator<TT>::reference r = *i;
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
} }
private: private:
TT i; TT i;
}; };
@@ -577,7 +615,7 @@ namespace boost
n = i - j; // require difference operator n = i - j; // require difference operator
(void)i[n]; // require element access operator (void)i[n]; // require element access operator
} }
private: private:
TT a, b; TT a, b;
TT i, j; TT i, j;
@@ -615,7 +653,7 @@ namespace boost
BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>)); BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
const_constraints(c); const_constraints(c);
} }
private: private:
void const_constraints(const C& cc) { void const_constraints(const C& cc) {
i = cc.begin(); i = cc.begin();
@@ -636,19 +674,19 @@ namespace boost
typedef typename C::reference reference; typedef typename C::reference reference;
typedef typename C::iterator iterator; typedef typename C::iterator iterator;
typedef typename C::pointer pointer; typedef typename C::pointer pointer;
BOOST_CONCEPT_USAGE(Mutable_Container) BOOST_CONCEPT_USAGE(Mutable_Container)
{ {
BOOST_CONCEPT_ASSERT(( BOOST_CONCEPT_ASSERT((
Assignable<typename Mutable_Container::value_type>)); Assignable<typename Mutable_Container::value_type>));
BOOST_CONCEPT_ASSERT((InputIterator<iterator>)); BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
i = c.begin(); i = c.begin();
i = c.end(); i = c.end();
c.swap(c2); c.swap(c2);
} }
private: private:
iterator i; iterator i;
C c, c2; C c, c2;
@@ -664,7 +702,7 @@ namespace boost
typename ForwardContainer::const_iterator typename ForwardContainer::const_iterator
>)); >));
} }
}; };
BOOST_concept(Mutable_ForwardContainer,(C)) BOOST_concept(Mutable_ForwardContainer,(C))
: ForwardContainer<C> : ForwardContainer<C>
@@ -677,7 +715,7 @@ namespace boost
typename Mutable_ForwardContainer::iterator typename Mutable_ForwardContainer::iterator
>)); >));
} }
}; };
BOOST_concept(ReversibleContainer,(C)) BOOST_concept(ReversibleContainer,(C))
: ForwardContainer<C> : ForwardContainer<C>
@@ -691,9 +729,9 @@ namespace boost
BOOST_CONCEPT_ASSERT(( BOOST_CONCEPT_ASSERT((
BidirectionalIterator< BidirectionalIterator<
typename ReversibleContainer::const_iterator>)); typename ReversibleContainer::const_iterator>));
BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>)); BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
const_constraints(c); const_constraints(c);
} }
private: private:
@@ -710,17 +748,17 @@ namespace boost
, ReversibleContainer<C> , ReversibleContainer<C>
{ {
typedef typename C::reverse_iterator reverse_iterator; typedef typename C::reverse_iterator reverse_iterator;
BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer) BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
{ {
typedef typename Mutable_ForwardContainer<C>::iterator iterator; typedef typename Mutable_ForwardContainer<C>::iterator iterator;
BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>)); BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>)); BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>));
reverse_iterator i = c.rbegin(); reverse_iterator i = c.rbegin();
i = c.rend(); i = c.rend();
} }
private: private:
C c; C c;
}; };
@@ -736,7 +774,7 @@ namespace boost
RandomAccessIterator< RandomAccessIterator<
typename RandomAccessContainer::const_iterator typename RandomAccessContainer::const_iterator
>)); >));
const_constraints(c); const_constraints(c);
} }
private: private:
@@ -745,7 +783,7 @@ namespace boost
const_reference r = cc[n]; const_reference r = cc[n];
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
} }
C c; C c;
size_type n; size_type n;
}; };
@@ -761,11 +799,11 @@ namespace boost
{ {
BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>)); BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>)); BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
typename self::reference r = c[i]; typename self::reference r = c[i];
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
} }
private: private:
typename Mutable_ReversibleContainer<C>::size_type i; typename Mutable_ReversibleContainer<C>::size_type i;
C c; C c;
@@ -781,7 +819,7 @@ namespace boost
{ {
BOOST_CONCEPT_USAGE(Sequence) BOOST_CONCEPT_USAGE(Sequence)
{ {
S S
c(n), c(n),
c2(n, t), c2(n, t),
c3(first, last); c3(first, last);
@@ -806,7 +844,7 @@ namespace boost
typename Sequence::const_reference r = c.front(); typename Sequence::const_reference r = c.front();
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
} }
typename S::value_type t; typename S::value_type t;
typename S::size_type n; typename S::size_type n;
typename S::value_type* first, *last; typename S::value_type* first, *last;
@@ -865,11 +903,11 @@ namespace boost
c.erase(r.first, r.second); c.erase(r.first, r.second);
const_constraints(c); const_constraints(c);
BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>)); BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
typedef typename AssociativeContainer::value_type value_type_; typedef typename AssociativeContainer::value_type value_type_;
BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>)); BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
} }
// Redundant with the base concept, but it helps below. // Redundant with the base concept, but it helps below.
typedef typename C::const_iterator const_iterator; typedef typename C::const_iterator const_iterator;
private: private:
@@ -895,7 +933,7 @@ namespace boost
BOOST_CONCEPT_USAGE(UniqueAssociativeContainer) BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
{ {
C c(first, last); C c(first, last);
pos_flag = c.insert(t); pos_flag = c.insert(t);
c.insert(first, last); c.insert(first, last);
@@ -913,7 +951,7 @@ namespace boost
BOOST_CONCEPT_USAGE(MultipleAssociativeContainer) BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
{ {
C c(first, last); C c(first, last);
pos = c.insert(t); pos = c.insert(t);
c.insert(first, last); c.insert(first, last);
@@ -956,7 +994,7 @@ namespace boost
{ {
BOOST_CONCEPT_USAGE(SortedAssociativeContainer) BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
{ {
C C
c(kc), c(kc),
c2(first, last), c2(first, last),
c3(first, last, kc); c3(first, last, kc);
@@ -964,15 +1002,15 @@ namespace boost
p = c.upper_bound(k); p = c.upper_bound(k);
p = c.lower_bound(k); p = c.lower_bound(k);
r = c.equal_range(k); r = c.equal_range(k);
c.insert(p, t); c.insert(p, t);
ignore_unused_variable_warning(c); ignore_unused_variable_warning(c);
ignore_unused_variable_warning(c2); ignore_unused_variable_warning(c2);
ignore_unused_variable_warning(c3); ignore_unused_variable_warning(c3);
const_constraints(c); const_constraints(c);
} }
void const_constraints(const C& c) void const_constraints(const C& c)
{ {
kc = c.key_comp(); kc = c.key_comp();
@@ -982,7 +1020,7 @@ namespace boost
cp = c.lower_bound(k); cp = c.lower_bound(k);
cr = c.equal_range(k); cr = c.equal_range(k);
} }
private: private:
typename C::key_compare kc; typename C::key_compare kc;
typename C::value_compare vc; typename C::value_compare vc;