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

Updated Concept Check library documentation.

Browse Source 
Changed BOOST_CONCEPT_WHERE to BOOST_CONCEPT_REQUIRES to be more
consistent with the current C++0x proposal, which now uses a
"requires" keyword in lieu of "where."

Factored GCC workarounds into the BOOST_CONCEPT_USAGE macro.


[SVN r40769]
This commit is contained in:
Dave Abrahams committed 2007-11-05 03:54:19 +00:00
1 parent 6ed3c013bb
commit 7dd50ca8f2
12 files changed
+1293 -1336
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

include/boost/concept/usage.hpp
+14 -3
View File
@@ -21,9 +21,20 @@ struct usage_requirements
~usage_requirements() { ((Model*)0)->~Model(); }
};
# define BOOST_CONCEPT_USAGE(model) \
BOOST_CONCEPT_ASSERT((boost::concept::usage_requirements<model>)); \
~model()
# if BOOST_WORKAROUND(__GNUC__, <= 3)
# define BOOST_CONCEPT_USAGE(model) \
model(); /* at least 2.96 and 3.4.3 both need this :( */ \
BOOST_CONCEPT_ASSERT((boost::concept::usage_requirements<model>)); \
~model()
# else
# define BOOST_CONCEPT_USAGE(model) \
BOOST_CONCEPT_ASSERT((boost::concept::usage_requirements<model>)); \
~model()
# endif
# endif
include/boost/concept/where.hpp
+30 -19
View File
@@ -1,8 +1,8 @@
// Copyright David Abrahams 2006. Distributed under the Boost
// Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONCEPT_WHERE_DWA2006430_HPP
# define BOOST_CONCEPT_WHERE_DWA2006430_HPP
#ifndef BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
# define BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
# include <boost/parameter/aux_/parenthesized_type.hpp>
# include <boost/concept/assert.hpp>
@@ -12,7 +12,7 @@ namespace boost {
// Template for use in handwritten assertions
template <class Model, class More>
struct where_ : More
struct requires_ : More
{
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
typedef typename More::type type;
@@ -23,41 +23,52 @@ struct where_ : More
// Template for use by macros, where models must be wrapped in parens.
// This isn't in namespace detail to keep extra cruft out of resulting
// error messages.
template <class ModelFn, class More>
struct _where_ : More
template <class ModelFn>
struct _requires_
{
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
typedef typename More::type type;
# endif
enum { value = 0 };
BOOST_CONCEPT_ASSERT_FN(ModelFn);
};
#define BOOST_CONCEPT_WHERE_OPEN(r,data,t) ::boost::_where_<void(*)t,
#define BOOST_CONCEPT_WHERE_CLOSE(r,data,t) >
template <int check, class Result>
struct Requires_ : ::boost::parameter::aux::unaryfunptr_arg_type<Result>
{
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
typedef typename ::boost::parameter::aux::unaryfunptr_arg_type<Result>::type type;
# endif
};
#define BOOST_CONCEPT_REQUIRES_(r,data,t) + (::boost::_requires_<void(*)t>::value)
#if defined(NDEBUG) || BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# define BOOST_CONCEPT_WHERE(models, result) \
# define BOOST_CONCEPT_REQUIRES(models, result) \
typename ::boost::parameter::aux::unaryfunptr_arg_type<void(*)result>::type
#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// Same thing as below without the initial typename
# define BOOST_CONCEPT_WHERE(models, result) \
BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_WHERE_OPEN, ~, models) \
# define BOOST_CONCEPT_REQUIRES(models, result) \
::boost::Requires_< \
(0 BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_REQUIRES_, ~, models)), \
::boost::parameter::aux::unaryfunptr_arg_type<void(*)result> \
BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_WHERE_CLOSE, ~, models)::type
>::type
#else
// This just ICEs on MSVC6 :(
# define BOOST_CONCEPT_WHERE(models, result) \
typename BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_WHERE_OPEN, ~, models) \
::boost::parameter::aux::unaryfunptr_arg_type<void(*)result> \
BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_WHERE_CLOSE, ~, models)::type
# define BOOST_CONCEPT_REQUIRES(models, result) \
typename ::boost::Requires_< \
(0 BOOST_PP_SEQ_FOR_EACH(BOOST_CONCEPT_REQUIRES_, ~, models)), \
void(*)result \
>::type
#endif
// C++0x proposed syntax changed. This supports an older usage
#define BOOST_CONCEPT_WHERE(models,result) BOOST_CONCEPT_REQUIRES(models,result)
} // namespace boost::concept_check
#endif // BOOST_CONCEPT_WHERE_DWA2006430_HPP
#endif // BOOST_CONCEPT_REQUIRES_DWA2006430_HPP
include/boost/concept_check.hpp
+27 -196
View File
@@ -62,9 +62,6 @@ namespace boost
//
BOOST_concept(Integer, (T))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Integer(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Integer)
{
x.error_type_must_be_an_integer_type();
@@ -90,9 +87,6 @@ namespace boost
# endif
BOOST_concept(SignedInteger,(T)) {
#if BOOST_WORKAROUND(__GNUC__, <= 3)
SignedInteger(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(SignedInteger) {
x.error_type_must_be_a_signed_integer_type();
}
@@ -110,9 +104,6 @@ namespace boost
# endif
BOOST_concept(UnsignedInteger,(T)) {
#if BOOST_WORKAROUND(__GNUC__, <= 3)
UnsignedInteger(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(UnsignedInteger) {
x.error_type_must_be_an_unsigned_integer_type();
}
@@ -135,9 +126,6 @@ namespace boost
BOOST_concept(DefaultConstructible,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
DefaultConstructible(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(DefaultConstructible) {
TT a; // require default constructor
ignore_unused_variable_warning(a);
@@ -146,13 +134,9 @@ namespace boost
BOOST_concept(Assignable,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Assignable(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Assignable) {
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
a = a; // require assignment operator
a = a; // require assignment operator
#endif
const_constraints(a);
}
@@ -166,12 +150,9 @@ namespace boost
TT a;
};
BOOST_concept(CopyConstructible,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
CopyConstructible(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(CopyConstructible) {
TT a(b); // require copy constructor
TT* ptr = &a; // require address of operator
@@ -191,10 +172,6 @@ namespace boost
// The SGI STL version of Assignable requires copy constructor and operator=
BOOST_concept(SGIAssignable,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
SGIAssignable(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(SGIAssignable) {
TT b(a);
#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
@@ -216,9 +193,6 @@ namespace boost
BOOST_concept(Convertible,(X)(Y))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Convertible(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Convertible) {
Y y = x;
ignore_unused_variable_warning(y);
@@ -244,9 +218,6 @@ namespace boost
BOOST_concept(EqualityComparable,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
EqualityComparable(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(EqualityComparable) {
require_boolean_expr(a == b);
require_boolean_expr(a != b);
@@ -257,9 +228,6 @@ namespace boost
BOOST_concept(LessThanComparable,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
LessThanComparable(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(LessThanComparable) {
require_boolean_expr(a < b);
}
@@ -270,9 +238,6 @@ namespace boost
// This is equivalent to SGI STL's LessThanComparable.
BOOST_concept(Comparable,(TT))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Comparable(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Comparable) {
require_boolean_expr(a < b);
require_boolean_expr(a > b);
@@ -283,18 +248,6 @@ namespace boost
TT a, b;
};
#if BOOST_WORKAROUND(__GNUC__, <= 3)
#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
BOOST_concept(NAME, (First)(Second)) \
{ \
NAME(); \
BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \
private: \
bool constraints_() { return a OP b; } \
First a; \
Second b; \
}
#else
#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
BOOST_concept(NAME, (First)(Second)) \
{ \
@@ -304,20 +257,7 @@ namespace boost
First a; \
Second b; \
}
#endif
#if BOOST_WORKAROUND(__GNUC__, <= 3)
#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \
BOOST_concept(NAME, (Ret)(First)(Second)) \
{ \
NAME(); \
BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \
private: \
Ret constraints_() { return a OP b; } \
First a; \
Second b; \
}
#else
#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \
BOOST_concept(NAME, (Ret)(First)(Second)) \
{ \
@@ -327,7 +267,6 @@ namespace boost
First a; \
Second b; \
}
#endif
BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);
BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);
@@ -347,9 +286,6 @@ namespace boost
BOOST_concept(Generator,(Func)(Return))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Generator(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
private:
@@ -370,9 +306,6 @@ namespace boost
BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
UnaryFunction(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
private:
@@ -394,9 +327,6 @@ namespace boost
BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
BinaryFunction(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }
private:
void test(boost::mpl::false_)
@@ -418,9 +348,6 @@ namespace boost
BOOST_concept(UnaryPredicate,(Func)(Arg))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
UnaryPredicate(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(UnaryPredicate) {
require_boolean_expr(f(arg)); // require operator() returning bool
}
@@ -431,9 +358,6 @@ namespace boost
BOOST_concept(BinaryPredicate,(Func)(First)(Second))
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
BinaryPredicate(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(BinaryPredicate) {
require_boolean_expr(f(a, b)); // require operator() returning bool
}
@@ -447,9 +371,6 @@ namespace boost
BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
: BinaryPredicate<Func, First, Second>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Const_BinaryPredicate(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
const_constraints(f);
}
@@ -468,9 +389,6 @@ namespace boost
{
typedef typename Func::result_type result_type;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AdaptableGenerator(); // at least 2.96 and 3.4.3 both need this :(
#endif
BOOST_CONCEPT_USAGE(AdaptableGenerator)
{
BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -483,9 +401,6 @@ namespace boost
typedef typename Func::argument_type argument_type;
typedef typename Func::result_type result_type;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AdaptableUnaryFunction(); // at least 2.96 and 3.4.3 both need this :(
#endif
~AdaptableUnaryFunction()
{
BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -505,9 +420,6 @@ namespace boost
typedef typename Func::second_argument_type second_argument_type;
typedef typename Func::result_type result_type;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AdaptableBinaryFunction(); // at least 2.96 and 3.4.3 both need this :(
#endif
~AdaptableBinaryFunction()
{
BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -520,18 +432,12 @@ namespace boost
: UnaryPredicate<Func, Arg>
, AdaptableUnaryFunction<Func, bool, Arg>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AdaptablePredicate(); // at least 2.96 and 3.4.3 both need this :(
#endif
};
BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))
: BinaryPredicate<Func, First, Second>
, AdaptableBinaryFunction<Func, bool, First, Second>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AdaptableBinaryPredicate(); // at least 2.96 and 3.4.3 both need this :(
#endif
};
//===========================================================================
@@ -547,10 +453,7 @@ namespace boost
typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
InputIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~InputIterator()
BOOST_CONCEPT_USAGE(InputIterator)
{
BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
@@ -567,10 +470,7 @@ namespace boost
BOOST_concept(OutputIterator,(TT)(ValueT))
: Assignable<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
OutputIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~OutputIterator() {
BOOST_CONCEPT_USAGE(OutputIterator) {
++i; // require preincrement operator
i++; // require postincrement operator
@@ -584,10 +484,7 @@ namespace boost
BOOST_concept(ForwardIterator,(TT))
: InputIterator<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
ForwardIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~ForwardIterator()
BOOST_CONCEPT_USAGE(ForwardIterator)
{
BOOST_CONCEPT_ASSERT((Convertible<
BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
@@ -605,10 +502,7 @@ namespace boost
BOOST_concept(Mutable_ForwardIterator,(TT))
: ForwardIterator<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_ForwardIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_ForwardIterator() {
BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
*i++ = *i; // require postincrement and assignment
}
private:
@@ -618,10 +512,7 @@ namespace boost
BOOST_concept(BidirectionalIterator,(TT))
: ForwardIterator<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
BidirectionalIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~BidirectionalIterator()
BOOST_CONCEPT_USAGE(BidirectionalIterator)
{
BOOST_CONCEPT_ASSERT((Convertible<
BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
@@ -639,10 +530,7 @@ namespace boost
: BidirectionalIterator<TT>
, Mutable_ForwardIterator<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_BidirectionalIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_BidirectionalIterator()
BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
{
*i-- = *i; // require postdecrement and assignment
}
@@ -654,10 +542,7 @@ namespace boost
: BidirectionalIterator<TT>
, Comparable<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
RandomAccessIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~RandomAccessIterator()
BOOST_CONCEPT_USAGE(RandomAccessIterator)
{
BOOST_CONCEPT_ASSERT((Convertible<
BOOST_DEDUCED_TYPENAME BidirectionalIterator<TT>::iterator_category
@@ -682,10 +567,7 @@ namespace boost
: RandomAccessIterator<TT>
, Mutable_BidirectionalIterator<TT>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_RandomAccessIterator(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_RandomAccessIterator()
BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator)
{
i[n] = *i; // require element access and assignment
}
@@ -707,10 +589,7 @@ namespace boost
typedef typename C::const_pointer const_pointer;
typedef typename C::const_iterator const_iterator;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Container(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Container()
BOOST_CONCEPT_USAGE(Container)
{
BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
const_constraints(c);
@@ -737,10 +616,7 @@ namespace boost
typedef typename C::iterator iterator;
typedef typename C::pointer pointer;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_Container(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_Container()
BOOST_CONCEPT_USAGE(Mutable_Container)
{
BOOST_CONCEPT_ASSERT((
Assignable<typename Mutable_Container::value_type>));
@@ -760,10 +636,7 @@ namespace boost
BOOST_concept(ForwardContainer,(C))
: Container<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
ForwardContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~ForwardContainer()
BOOST_CONCEPT_USAGE(ForwardContainer)
{
BOOST_CONCEPT_ASSERT((
ForwardIterator<
@@ -776,10 +649,7 @@ namespace boost
: ForwardContainer<C>
, Mutable_Container<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_ForwardContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_ForwardContainer()
BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
{
BOOST_CONCEPT_ASSERT((
Mutable_ForwardIterator<
@@ -795,10 +665,7 @@ namespace boost
C::const_reverse_iterator
const_reverse_iterator;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
ReversibleContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~ReversibleContainer()
BOOST_CONCEPT_USAGE(ReversibleContainer)
{
BOOST_CONCEPT_ASSERT((
BidirectionalIterator<
@@ -823,10 +690,7 @@ namespace boost
{
typedef typename C::reverse_iterator reverse_iterator;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_ReversibleContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_ReversibleContainer()
BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
{
typedef typename Mutable_ForwardContainer<C>::iterator iterator;
BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
@@ -845,10 +709,7 @@ namespace boost
typedef typename C::size_type size_type;
typedef typename C::const_reference const_reference;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
RandomAccessContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~RandomAccessContainer()
BOOST_CONCEPT_USAGE(RandomAccessContainer)
{
BOOST_CONCEPT_ASSERT((
RandomAccessIterator<
@@ -875,10 +736,7 @@ namespace boost
private:
typedef Mutable_RandomAccessContainer self;
public:
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Mutable_RandomAccessContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Mutable_RandomAccessContainer()
BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
{
BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
@@ -900,10 +758,7 @@ namespace boost
// ... so why aren't we following the standard? --DWA
, DefaultConstructible<S>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
Sequence(); // at least 2.96 and 3.4.3 both need this :(
#endif
~Sequence()
BOOST_CONCEPT_USAGE(Sequence)
{
S
c(n),
@@ -940,10 +795,7 @@ namespace boost
BOOST_concept(FrontInsertionSequence,(S))
: Sequence<S>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
FrontInsertionSequence(); // at least 2.96 and 3.4.3 both need this :(
#endif
~FrontInsertionSequence()
BOOST_CONCEPT_USAGE(FrontInsertionSequence)
{
c.push_front(t);
c.pop_front();
@@ -956,10 +808,7 @@ namespace boost
BOOST_concept(BackInsertionSequence,(S))
: Sequence<S>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
BackInsertionSequence(); // at least 2.96 and 3.4.3 both need this :(
#endif
~BackInsertionSequence()
BOOST_CONCEPT_USAGE(BackInsertionSequence)
{
c.push_back(t);
c.pop_back();
@@ -986,10 +835,7 @@ namespace boost
typedef typename C::value_compare value_compare;
typedef typename C::iterator iterator;
#if BOOST_WORKAROUND(__GNUC__, <= 3)
AssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~AssociativeContainer()
BOOST_CONCEPT_USAGE(AssociativeContainer)
{
i = c.find(k);
r = c.equal_range(k);
@@ -1025,10 +871,7 @@ namespace boost
BOOST_concept(UniqueAssociativeContainer,(C))
: AssociativeContainer<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
UniqueAssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~UniqueAssociativeContainer()
BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
{
C c(first, last);
@@ -1046,10 +889,7 @@ namespace boost
BOOST_concept(MultipleAssociativeContainer,(C))
: AssociativeContainer<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
MultipleAssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~MultipleAssociativeContainer()
BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
{
C c(first, last);
@@ -1068,10 +908,7 @@ namespace boost
BOOST_concept(SimpleAssociativeContainer,(C))
: AssociativeContainer<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
SimpleAssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~SimpleAssociativeContainer()
BOOST_CONCEPT_USAGE(SimpleAssociativeContainer)
{
typedef typename C::key_type key_type;
typedef typename C::value_type value_type;
@@ -1082,10 +919,7 @@ namespace boost
BOOST_concept(PairAssociativeContainer,(C))
: AssociativeContainer<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
PairAssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~PairAssociativeContainer()
BOOST_CONCEPT_USAGE(PairAssociativeContainer)
{
typedef typename C::key_type key_type;
typedef typename C::value_type value_type;
@@ -1099,10 +933,7 @@ namespace boost
: AssociativeContainer<C>
, ReversibleContainer<C>
{
#if BOOST_WORKAROUND(__GNUC__, <= 3)
SortedAssociativeContainer(); // at least 2.96 and 3.4.3 both need this :(
#endif
~SortedAssociativeContainer()
BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
{
C
c(kc),