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

concept checking changes

Browse Source 
[SVN r8278]
This commit is contained in:
Jeremy Siek
2000-11-21 20:18:07 +00:00
parent 094da4b2f6
commit ddd16bb04c
2 changed files with 150 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
include/boost/pending/concept_archetypes.hpp
View File

@@ -291,7 +291,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
input_proxy<T> operator*() { return input_proxy<T>(); } input_proxy<T> operator*() const { return input_proxy<T>(); }
}; };
} // namespace boost } // namespace boost
@@ -327,7 +327,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
input_output_proxy<T> operator*() { return input_output_proxy<T>(); } input_output_proxy<T> operator*() const { return input_output_proxy<T>(); }
}; };
} // namespace boost } // namespace boost
@@ -358,7 +358,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
reference operator*() { return static_object<T>::get(); } reference operator*() const { return static_object<T>::get(); }
self& operator++() { return *this; } self& operator++() { return *this; }
self operator++(int) { return *this; } self operator++(int) { return *this; }
}; };
@@ -382,7 +382,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
reference operator*() { return output_proxy(); } reference operator*() const { return output_proxy(); }
self& operator++() { return *this; } self& operator++() { return *this; }
self operator++(int) { return *this; } self operator++(int) { return *this; }
}; };
@@ -402,7 +402,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
reference operator*() { return static_object<T>::get(); } reference operator*() const { return static_object<T>::get(); }
self& operator++() { return *this; } self& operator++() { return *this; }
self operator++(int) { return *this; } self operator++(int) { return *this; }
}; };
@@ -422,7 +422,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
reference operator*() { return static_object<T>::get(); } reference operator*() const { return static_object<T>::get(); }
self& operator++() { return *this; } self& operator++() { return *this; }
self operator++(int) { return *this; } self operator++(int) { return *this; }
self& operator--() { return *this; } self& operator--() { return *this; }
@@ -444,7 +444,7 @@ namespace boost {
self& operator=(const self&) { return *this; } self& operator=(const self&) { return *this; }
bool operator==(const self&) const { return true; } bool operator==(const self&) const { return true; }
bool operator!=(const self&) const { return true; } bool operator!=(const self&) const { return true; }
reference operator*() { return static_object<T>::get(); } reference operator*() const { return static_object<T>::get(); }
self& operator++() { return *this; } self& operator++() { return *this; }
self operator++(int) { return *this; } self operator++(int) { return *this; }
self& operator--() { return *this; } self& operator--() { return *this; }

285
include/boost/pending/concept_checks.hpp
View File

@@ -19,82 +19,47 @@
#define BOOST_FPTR #define BOOST_FPTR
#endif #endif
#define BOOST_FUNCTION_REQUIRES(type_var, concept) \ namespace boost {
do { \
void (concept<type_var>::*x)() = BOOST_FPTR concept<type_var>::constraints; \
x = x; } while (0)
#define BOOST_FUNCTION_REQUIRES2(type_var1, type_var2, concept) \ template <class T> void ignore_unused_variable_warning(const T&) { }
do { \
void (concept<type_var1, type_var2>::*x)() = \
BOOST_FPTR concept<type_var1, type_var2>::constraints; \
x = x; } while (0)
#define BOOST_FUNCTION_REQUIRES3(type_var1, type_var2, type_var3,concept) \ template <class Concept>
do { \ void function_requires()
void (concept <type_var1, type_var2, type_var3>::*x)() = \ {
BOOST_FPTR concept <type_var1, type_var2, type_var3>::constraints; \ #if !defined(NDEBUG)
x = x; } while (0) void (Concept::*x)() = BOOST_FPTR Concept::constraints;
ignore_unused_variable_warning(x);
#endif
}
#define BOOST_FUNCTION_REQUIRES4(type_var1, type_var2, type_var3,type_var4,concept) \ template <class Concept>
do { \ class class_requires
void (concept <type_var1,type_var2,type_var3,type_var4>::*x)() = \ {
BOOST_FPTR concept <type_var1, type_var2, type_var3, type_var4>::constraints;\ #if defined(NDEBUG)
x = x; } while (0) public:
typedef int check;
#else
#define BOOST_CLASS_REQUIRES(type_var, concept) \ typedef void (Concept::* function_pointer)();
typedef void (concept <type_var>::* __func##type_var##concept)(); \
template <__func##type_var##concept _Tp1> \
struct __dummy_struct_##type_var##concept { }; \
typedef __dummy_struct_##type_var##concept< \
BOOST_FPTR concept <type_var>::constraints> \
__dummy_typedef_##type_var##concept
#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \
typedef void (concept <type_var1,type_var2>::* __func##type_var1##type_var2##concept)(); \
template <__func##type_var1##type_var2##concept _Tp1> \
struct __dummy_struct_##type_var1##type_var2##concept { }; \
typedef __dummy_struct_##type_var1##type_var2##concept< \
BOOST_FPTR concept <type_var1,type_var2>::constraints> \
__dummy_typedef_##type_var1##type_var2##concept
#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \
typedef void (concept <type_var1,type_var2,type_var3>::* __func##type_var1##type_var2##type_var3##concept)(); \
template <__func##type_var1##type_var2##type_var3##concept _Tp1> \
struct __dummy_struct_##type_var1##type_var2##type_var3##concept { }; \
typedef __dummy_struct_##type_var1##type_var2##type_var3##concept< \
BOOST_FPTR concept <type_var1,type_var2,type_var3>::constraints> \
__dummy_typedef_##type_var1##type_var2##type_var3##concept
#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \
typedef void (concept <type_var1,type_var2,type_var3,type_var4>::* __func##type_var1##type_var2##type_var3##type_var4##concept)(); \
template <__func##type_var1##type_var2##type_var3##type_var4##concept _Tp1> \
struct __dummy_struct_##type_var1##type_var2##type_var3##type_var4##concept { }; \
typedef __dummy_struct_##type_var1##type_var2##type_var3##type_var4##concept< \
BOOST_FPTR concept <type_var1,type_var2,type_var3,type_var4>::constraints> \
__dummy_typedef_##type_var1##type_var2##type_var3##type_var4##concept
template <function_pointer Fptr>
struct dummy_struct { };
public:
typedef dummy_struct< BOOST_FPTR Concept::constraints > check;
#endif
};
#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T, class U> template <class T, class U>
struct require_same_type { }; struct require_same { };
template <class T> template <class T>
struct require_same_type<T,T> { typedef T type; }; struct require_same<T,T> { typedef T type; };
#else #else
// This version does not perform checking, but will not do any harm.
template <class T, class U> template <class T, class U>
struct require_same_type { typedef T type; }; struct require_same { typedef T type; };
#endif #endif
#define BOOST_FUNCTION_REQUIRES_SAME_TYPE(X,Y) \
typedef typename require_same_type<X,Y>::type X##_same_##Y
#define BOOST_CLASS_REQUIRES_SAME_TYPE(X,Y) \
typedef typename require_same_type<X,Y>::type X##_same_##Y
template <class T> void ignore_unused_variable_warning(const T&) { }
template <class T> template <class T>
struct IntegerConcept { struct IntegerConcept {
void constraints() { void constraints() {
@@ -128,6 +93,24 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
// etc. // etc.
#endif #endif
template <class T>
struct UnsignedIntegerConcept {
void constraints() {
#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
error__type_must_be_an_unsigned_integer_type();
#endif
}
};
#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <> struct UnsignedIntegerConcept<unsigned short>
{ void constraints() {} };
template <> struct UnsignedIntegerConcept<unsigned int>
{ void constraints() {} };
template <> struct UnsignedIntegerConcept<unsigned long>
{ void constraints() {} };
// etc.
#endif
//=========================================================================== //===========================================================================
// Basic Concepts // Basic Concepts
@@ -224,11 +207,10 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
require_boolean_expr(a == b); require_boolean_expr(a == b);
require_boolean_expr(a != b); require_boolean_expr(a != b);
} }
bool boolean;
TT a, b; TT a, b;
}; };
template <class XX, class YY> template <class AA, class BB>
struct EqualityComparable2Concept struct EqualityComparable2Concept
{ {
void constraints() { void constraints() {
@@ -237,41 +219,55 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
require_boolean_expr(a != b); require_boolean_expr(a != b);
require_boolean_expr(b != a); require_boolean_expr(b != a);
} }
XX a; AA a;
YY b; BB b;
}; };
// Use LessThanOpConcept (see below) instead of
// LessThanComparableConcept when you want to express comparison
// between two different types.
template <class TT> template <class TT>
struct LessThanComparableConcept struct LessThanComparableConcept
{ {
void constraints() { void constraints() {
require_boolean_expr(a < b); require_boolean_expr(a < b);
} }
bool boolean;
TT a, b; TT a, b;
}; };
template <class AA, class BB>
struct LessThanComparable2Concept
{
void constraints() {
function_requires< LessThanComparableConcept<AA> >();
function_requires< LessThanComparableConcept<BB> >();
require_boolean_expr(a < b);
require_boolean_expr(b < a);
}
AA a;
BB b;
};
// This is equivalent to SGI STL's LessThanComparable. // This is equivalent to SGI STL's LessThanComparable.
template <class TT> template <class TT>
struct ComparableConcept struct ComparableConcept
{ {
void constraints() { void constraints() {
function_requires< EqualityComparableConcept<TT> >();
require_boolean_expr(a < b); require_boolean_expr(a < b);
require_boolean_expr(a > b); require_boolean_expr(a > b);
require_boolean_expr(a <= b); require_boolean_expr(a <= b);
require_boolean_expr(a >= b); require_boolean_expr(a >= b);
} }
bool boolean;
TT a, b; TT a, b;
}; };
template <class XX, class YY> // This is a generalization of SGI STL's LessThanComparable
// concept to 2 types.
template <class AA, class BB>
struct Comparable2Concept struct Comparable2Concept
{ {
void constraints() { void constraints() {
function_requires< EqualityComparable2Concept<AA,BB> >();
function_requires< ComparableConcept<AA> >();
function_requires< ComparableConcept<BB> >();
require_boolean_expr(a < b); require_boolean_expr(a < b);
require_boolean_expr(b < a); require_boolean_expr(b < a);
require_boolean_expr(a > b); require_boolean_expr(a > b);
@@ -281,9 +277,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
require_boolean_expr(a >= b); require_boolean_expr(a >= b);
require_boolean_expr(b >= a); require_boolean_expr(b >= a);
} }
bool boolean; AA a;
XX a; BB b;
YY b;
}; };
//=========================================================================== //===========================================================================
@@ -293,9 +288,9 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct TrivialIteratorConcept struct TrivialIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, AssignableConcept); function_requires< AssignableConcept<TT> >();
BOOST_FUNCTION_REQUIRES(TT, DefaultConstructibleConcept); function_requires< DefaultConstructibleConcept<TT> >();
BOOST_FUNCTION_REQUIRES(TT, EqualityComparableConcept); function_requires< EqualityComparableConcept<TT> >();
#ifndef BOOST_NO_STD_ITERATOR_TRAITS #ifndef BOOST_NO_STD_ITERATOR_TRAITS
typedef typename std::iterator_traits<TT>::value_type V; typedef typename std::iterator_traits<TT>::value_type V;
#endif #endif
@@ -308,7 +303,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct Mutable_TrivialIteratorConcept struct Mutable_TrivialIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, TrivialIteratorConcept); function_requires< TrivialIteratorConcept<TT> >();
*i = *j; // require dereference and assignment *i = *j; // require dereference and assignment
} }
TT i, j; TT i, j;
@@ -318,16 +313,17 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct InputIteratorConcept struct InputIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, TrivialIteratorConcept); function_requires< TrivialIteratorConcept<TT> >();
// require iterator_traits typedef's // require iterator_traits typedef's
#ifndef BOOST_NO_STD_ITERATOR_TRAITS #ifndef BOOST_NO_STD_ITERATOR_TRAITS
typedef typename std::iterator_traits<TT>::difference_type D; typedef typename std::iterator_traits<TT>::difference_type D;
BOOST_FUNCTION_REQUIRES(D, SignedIntegerConcept); function_requires< SignedIntegerConcept<D> >();
typedef typename std::iterator_traits<TT>::reference R; typedef typename std::iterator_traits<TT>::reference R;
typedef typename std::iterator_traits<TT>::pointer P; typedef typename std::iterator_traits<TT>::pointer P;
typedef typename std::iterator_traits<TT>::iterator_category C; typedef typename std::iterator_traits<TT>::iterator_category C;
BOOST_FUNCTION_REQUIRES2(typename std::iterator_traits<TT>::iterator_category, function_requires< ConvertibleConcept<
std::input_iterator_tag, ConvertibleConcept); typename std::iterator_traits<TT>::iterator_category,
std::input_iterator_tag> >();
#endif #endif
++i; // require preincrement operator ++i; // require preincrement operator
i++; // require postincrement operator i++; // require postincrement operator
@@ -339,7 +335,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct OutputIteratorConcept struct OutputIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, AssignableConcept); function_requires< AssignableConcept<TT> >();
++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
@@ -352,10 +348,11 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct ForwardIteratorConcept struct ForwardIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, InputIteratorConcept); function_requires< InputIteratorConcept<TT> >();
#ifndef BOOST_NO_STD_ITERATOR_TRAITS #ifndef BOOST_NO_STD_ITERATOR_TRAITS
BOOST_FUNCTION_REQUIRES2(typename std::iterator_traits<TT>::iterator_category, function_requires< ConvertibleConcept<
std::forward_iterator_tag, ConvertibleConcept); typename std::iterator_traits<TT>::iterator_category,
std::forward_iterator_tag> >();
typedef typename std::iterator_traits<TT>::reference reference; typedef typename std::iterator_traits<TT>::reference reference;
reference r = *i; reference r = *i;
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
@@ -368,7 +365,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct Mutable_ForwardIteratorConcept struct Mutable_ForwardIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, ForwardIteratorConcept); function_requires< ForwardIteratorConcept<TT> >();
*i++ = *i; // require postincrement and assignment *i++ = *i; // require postincrement and assignment
} }
TT i; TT i;
@@ -378,10 +375,11 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct BidirectionalIteratorConcept struct BidirectionalIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, ForwardIteratorConcept); function_requires< ForwardIteratorConcept<TT> >();
#ifndef BOOST_NO_STD_ITERATOR_TRAITS #ifndef BOOST_NO_STD_ITERATOR_TRAITS
BOOST_FUNCTION_REQUIRES2(typename std::iterator_traits<TT>::iterator_category, function_requires< ConvertibleConcept<
std::bidirectional_iterator_tag, ConvertibleConcept); typename std::iterator_traits<TT>::iterator_category,
std::bidirectional_iterator_tag> >();
#endif #endif
--i; // require predecrement operator --i; // require predecrement operator
i--; // require postdecrement operator i--; // require postdecrement operator
@@ -393,8 +391,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct Mutable_BidirectionalIteratorConcept struct Mutable_BidirectionalIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, BidirectionalIteratorConcept); function_requires< BidirectionalIteratorConcept<TT> >();
BOOST_FUNCTION_REQUIRES(TT, Mutable_ForwardIteratorConcept); function_requires< Mutable_ForwardIteratorConcept<TT> >();
*i-- = *i; // require postdecrement and assignment *i-- = *i; // require postdecrement and assignment
} }
TT i; TT i;
@@ -405,11 +403,12 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct RandomAccessIteratorConcept struct RandomAccessIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, BidirectionalIteratorConcept); function_requires< BidirectionalIteratorConcept<TT> >();
BOOST_FUNCTION_REQUIRES(TT, ComparableConcept); function_requires< ComparableConcept<TT> >();
#ifndef BOOST_NO_STD_ITERATOR_TRAITS #ifndef BOOST_NO_STD_ITERATOR_TRAITS
BOOST_FUNCTION_REQUIRES2(typename std::iterator_traits<TT>::iterator_category, function_requires< ConvertibleConcept<
std::random_access_iterator_tag, ConvertibleConcept); typename std::iterator_traits<TT>::iterator_category,
std::random_access_iterator_tag> >();
typedef typename std::iterator_traits<TT>::reference R; typedef typename std::iterator_traits<TT>::reference R;
#endif #endif
@@ -433,8 +432,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct Mutable_RandomAccessIteratorConcept struct Mutable_RandomAccessIteratorConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(TT, RandomAccessIteratorConcept); function_requires< RandomAccessIteratorConcept<TT> >();
BOOST_FUNCTION_REQUIRES(TT, Mutable_BidirectionalIteratorConcept); function_requires< Mutable_BidirectionalIteratorConcept<TT> >();
i[n] = *i; // require element access and assignment i[n] = *i; // require element access and assignment
} }
TT i; TT i;
@@ -544,7 +543,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
const_constraints(f); const_constraints(f);
} }
void const_constraints(const Func& fun) { void const_constraints(const Func& fun) {
BOOST_FUNCTION_REQUIRES3(Func, First, Second, BinaryPredicateConcept); function_requires<BinaryPredicateConcept<Func, First, Second> >();
// 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));
} }
@@ -602,8 +601,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
typedef typename Container::const_iterator const_iterator; typedef typename Container::const_iterator const_iterator;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(const_iterator, InputIteratorConcept); function_requires< InputIteratorConcept<const_iterator> >();
BOOST_FUNCTION_REQUIRES(Container, AssignableConcept); function_requires< AssignableConcept<Container> >();
const Container c; const Container c;
i = c.begin(); i = c.begin();
i = c.end(); i = c.end();
@@ -625,9 +624,9 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
typedef typename Container::pointer pointer; typedef typename Container::pointer pointer;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(Container, ContainerConcept); function_requires< ContainerConcept<Container> >();
BOOST_FUNCTION_REQUIRES(value_type, AssignableConcept); function_requires< AssignableConcept<value_type> >();
BOOST_FUNCTION_REQUIRES(iterator, InputIteratorConcept); function_requires< InputIteratorConcept<iterator> >();
i = c.begin(); i = c.begin();
i = c.end(); i = c.end();
@@ -641,9 +640,9 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct ForwardContainerConcept struct ForwardContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(ForwardContainer, ContainerConcept); function_requires< ContainerConcept<ForwardContainer> >();
typedef typename ForwardContainer::const_iterator const_iterator; typedef typename ForwardContainer::const_iterator const_iterator;
BOOST_FUNCTION_REQUIRES(const_iterator, ForwardIteratorConcept); function_requires< ForwardIteratorConcept<const_iterator> >();
} }
}; };
@@ -651,10 +650,10 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct Mutable_ForwardContainerConcept struct Mutable_ForwardContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(ForwardContainer, ForwardContainerConcept); function_requires< ForwardContainerConcept<ForwardContainer> >();
BOOST_FUNCTION_REQUIRES(ForwardContainer, Mutable_ContainerConcept); function_requires< Mutable_ContainerConcept<ForwardContainer> >();
typedef typename ForwardContainer::iterator iterator; typedef typename ForwardContainer::iterator iterator;
BOOST_FUNCTION_REQUIRES(iterator, Mutable_ForwardIteratorConcept); function_requires< Mutable_ForwardIteratorConcept<iterator> >();
} }
}; };
@@ -666,9 +665,9 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
const_reverse_iterator; const_reverse_iterator;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(ReversibleContainer, ForwardContainerConcept); function_requires< ForwardContainerConcept<ReversibleContainer> >();
BOOST_FUNCTION_REQUIRES(const_iterator, BidirectionalIteratorConcept); function_requires< BidirectionalIteratorConcept<const_iterator> >();
BOOST_FUNCTION_REQUIRES(const_reverse_iterator, BidirectionalIteratorConcept); function_requires< BidirectionalIteratorConcept<const_reverse_iterator> >();
const ReversibleContainer c; const ReversibleContainer c;
const_reverse_iterator i = c.rbegin(); const_reverse_iterator i = c.rbegin();
@@ -683,10 +682,10 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
typedef typename ReversibleContainer::reverse_iterator reverse_iterator; typedef typename ReversibleContainer::reverse_iterator reverse_iterator;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(ReversibleContainer, ReversibleContainerConcept); function_requires< ReversibleContainerConcept<ReversibleContainer> >();
BOOST_FUNCTION_REQUIRES(ReversibleContainer, Mutable_ForwardContainerConcept); function_requires< Mutable_ForwardContainerConcept<ReversibleContainer> >();
BOOST_FUNCTION_REQUIRES(iterator, Mutable_BidirectionalIteratorConcept); function_requires< Mutable_BidirectionalIteratorConcept<iterator> >();
BOOST_FUNCTION_REQUIRES(reverse_iterator, Mutable_BidirectionalIteratorConcept); function_requires< Mutable_BidirectionalIteratorConcept<reverse_iterator> >();
reverse_iterator i = c.rbegin(); reverse_iterator i = c.rbegin();
i = c.rend(); i = c.rend();
@@ -704,9 +703,9 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
const_reverse_iterator; const_reverse_iterator;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(RandomAccessContainer, ReversibleContainerConcept); function_requires< ReversibleContainerConcept<RandomAccessContainer> >();
BOOST_FUNCTION_REQUIRES(const_iterator, RandomAccessIteratorConcept); function_requires< RandomAccessIteratorConcept<const_iterator> >();
BOOST_FUNCTION_REQUIRES(const_reverse_iterator, RandomAccessIteratorConcept); function_requires< RandomAccessIteratorConcept<const_reverse_iterator> >();
const RandomAccessContainer c; const RandomAccessContainer c;
const_reference r = c[n]; const_reference r = c[n];
@@ -724,10 +723,10 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
typedef typename RandomAccessContainer::reverse_iterator reverse_iterator; typedef typename RandomAccessContainer::reverse_iterator reverse_iterator;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(RandomAccessContainer, RandomAccessContainerConcept); function_requires< RandomAccessContainerConcept<RandomAccessContainer> >();
BOOST_FUNCTION_REQUIRES(RandomAccessContainer, Mutable_ReversibleContainerConcept); function_requires< Mutable_ReversibleContainerConcept<RandomAccessContainer> >();
BOOST_FUNCTION_REQUIRES(iterator, Mutable_RandomAccessIteratorConcept); function_requires< Mutable_RandomAccessIteratorConcept<iterator> >();
BOOST_FUNCTION_REQUIRES(reverse_iterator, Mutable_RandomAccessIteratorConcept); function_requires< Mutable_RandomAccessIteratorConcept<reverse_iterator> >();
reference r = c[i]; reference r = c[i];
ignore_unused_variable_warning(r); ignore_unused_variable_warning(r);
@@ -740,16 +739,16 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
template <class Sequence> template <class Sequence>
struct SequenceConcept struct SequenceConcept
{ {
// Matt Austern's book puts DefaultConstructible here, the C++
// standard places it in Container
// BOOST_CLASS_REQUIRES(Sequence, DefaultConstructible);
typedef typename Sequence::reference reference; typedef typename Sequence::reference reference;
typedef typename Sequence::const_reference const_reference; typedef typename Sequence::const_reference const_reference;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(Sequence, Mutable_ForwardContainerConcept); // Matt Austern's book puts DefaultConstructible here, the C++
BOOST_FUNCTION_REQUIRES(Sequence, DefaultConstructibleConcept); // standard places it in Container
// function_requires< DefaultConstructible<Sequence> >();
function_requires< Mutable_ForwardContainerConcept<Sequence> >();
function_requires< DefaultConstructibleConcept<Sequence> >();
Sequence Sequence
c(n), c(n),
@@ -785,7 +784,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct FrontInsertionSequenceConcept struct FrontInsertionSequenceConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(FrontInsertionSequence, SequenceConcept); function_requires< SequenceConcept<FrontInsertionSequence> >();
c.push_front(t); c.push_front(t);
c.pop_front(); c.pop_front();
@@ -801,7 +800,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
typedef typename BackInsertionSequence::const_reference const_reference; typedef typename BackInsertionSequence::const_reference const_reference;
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(BackInsertionSequence, SequenceConcept); function_requires< SequenceConcept<BackInsertionSequence> >();
c.push_back(t); c.push_back(t);
c.pop_back(); c.pop_back();
@@ -820,8 +819,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct AssociativeContainerConcept struct AssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(AssociativeContainer, ForwardContainerConcept); function_requires< ForwardContainerConcept<AssociativeContainer> >();
BOOST_FUNCTION_REQUIRES(AssociativeContainer, DefaultConstructibleConcept); function_requires< DefaultConstructibleConcept<AssociativeContainer> >();
i = c.find(k); i = c.find(k);
r = c.equal_range(k); r = c.equal_range(k);
@@ -851,7 +850,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct UniqueAssociativeContainerConcept struct UniqueAssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(UniqueAssociativeContainer, AssociativeContainerConcept); function_requires< AssociativeContainerConcept<UniqueAssociativeContainer> >();
UniqueAssociativeContainer c(first, last); UniqueAssociativeContainer c(first, last);
@@ -869,7 +868,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct MultipleAssociativeContainerConcept struct MultipleAssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(MultipleAssociativeContainer, AssociativeContainerConcept); function_requires< AssociativeContainerConcept<MultipleAssociativeContainer> >();
MultipleAssociativeContainer c(first, last); MultipleAssociativeContainer c(first, last);
@@ -888,10 +887,10 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct SimpleAssociativeContainerConcept struct SimpleAssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(SimpleAssociativeContainer, AssociativeContainerConcept); function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
typedef typename SimpleAssociativeContainer::key_type key_type; typedef typename SimpleAssociativeContainer::key_type key_type;
typedef typename SimpleAssociativeContainer::value_type value_type; typedef typename SimpleAssociativeContainer::value_type value_type;
BOOST_FUNCTION_REQUIRES_SAME_TYPE(key_type, value_type); typedef typename require_same<key_type, value_type>::type req;
} }
}; };
@@ -899,12 +898,12 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct PairAssociativeContainerConcept struct PairAssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(SimpleAssociativeContainer, AssociativeContainerConcept); function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
typedef typename SimpleAssociativeContainer::key_type key_type; typedef typename SimpleAssociativeContainer::key_type key_type;
typedef typename SimpleAssociativeContainer::value_type value_type; typedef typename SimpleAssociativeContainer::value_type value_type;
typedef typename SimpleAssociativeContainer::mapped_type mapped_type; typedef typename SimpleAssociativeContainer::mapped_type mapped_type;
typedef std::pair<const key_type, mapped_type> required_value_type; typedef std::pair<const key_type, mapped_type> required_value_type;
BOOST_FUNCTION_REQUIRES_SAME_TYPE(value_type, required_value_type); typedef typename require_same<value_type, required_value_type>::type req;
} }
}; };
@@ -912,8 +911,8 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
struct SortedAssociativeContainerConcept struct SortedAssociativeContainerConcept
{ {
void constraints() { void constraints() {
BOOST_FUNCTION_REQUIRES(SortedAssociativeContainer, AssociativeContainerConcept); function_requires< AssociativeContainerConcept<SortedAssociativeContainer> >();
BOOST_FUNCTION_REQUIRES(SortedAssociativeContainer, ReversibleContainerConcept); function_requires< ReversibleContainerConcept<SortedAssociativeContainer> >();
SortedAssociativeContainer SortedAssociativeContainer
c(kc), c(kc),
@@ -953,5 +952,7 @@ template <class T> void ignore_unused_variable_warning(const T&) { }
// HashedAssociativeContainer // HashedAssociativeContainer
} // namespace boost
#endif // BOOST_CONCEPT_CHECKS_HPP #endif // BOOST_CONCEPT_CHECKS_HPP