1 | // |
---|
2 | // (C) Copyright Jeremy Siek 2000. |
---|
3 | // Distributed under the Boost Software License, Version 1.0. (See |
---|
4 | // accompanying file LICENSE_1_0.txt or copy at |
---|
5 | // http://www.boost.org/LICENSE_1_0.txt) |
---|
6 | // |
---|
7 | // Revision History: |
---|
8 | // 05 May 2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek) |
---|
9 | // 02 April 2001: Removed limits header altogether. (Jeremy Siek) |
---|
10 | // 01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock) |
---|
11 | // |
---|
12 | |
---|
13 | // See http://www.boost.org/libs/concept_check for documentation. |
---|
14 | |
---|
15 | #ifndef BOOST_CONCEPT_CHECKS_HPP |
---|
16 | #define BOOST_CONCEPT_CHECKS_HPP |
---|
17 | |
---|
18 | #include <boost/config.hpp> |
---|
19 | #include <boost/iterator.hpp> |
---|
20 | #include <boost/type_traits/conversion_traits.hpp> |
---|
21 | #include <utility> |
---|
22 | #include <boost/type_traits/conversion_traits.hpp> |
---|
23 | #include <boost/static_assert.hpp> |
---|
24 | #include <boost/mpl/identity.hpp> |
---|
25 | |
---|
26 | |
---|
27 | #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__BORLANDC__) |
---|
28 | #define BOOST_FPTR |
---|
29 | #else |
---|
30 | #define BOOST_FPTR & |
---|
31 | #endif |
---|
32 | |
---|
33 | namespace boost { |
---|
34 | |
---|
35 | /* |
---|
36 | "inline" is used for ignore_unused_variable_warning() |
---|
37 | and function_requires() to make sure there is no |
---|
38 | overhead with g++. |
---|
39 | */ |
---|
40 | |
---|
41 | template <class T> inline void ignore_unused_variable_warning(const T&) { } |
---|
42 | |
---|
43 | // the unused, defaulted parameter is a workaround for MSVC and Compaq C++ |
---|
44 | template <class Concept> |
---|
45 | inline void function_requires(mpl::identity<Concept>* = 0) |
---|
46 | { |
---|
47 | #if !defined(NDEBUG) |
---|
48 | void (Concept::*x)() = BOOST_FPTR Concept::constraints; |
---|
49 | ignore_unused_variable_warning(x); |
---|
50 | #endif |
---|
51 | } |
---|
52 | |
---|
53 | #define BOOST_CLASS_REQUIRE(type_var, ns, concept) \ |
---|
54 | typedef void (ns::concept <type_var>::* func##type_var##concept)(); \ |
---|
55 | template <func##type_var##concept Tp1_> \ |
---|
56 | struct concept_checking_##type_var##concept { }; \ |
---|
57 | typedef concept_checking_##type_var##concept< \ |
---|
58 | BOOST_FPTR ns::concept<type_var>::constraints> \ |
---|
59 | concept_checking_typedef_##type_var##concept |
---|
60 | |
---|
61 | #define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept) \ |
---|
62 | typedef void (ns::concept <type_var1,type_var2>::* \ |
---|
63 | func##type_var1##type_var2##concept)(); \ |
---|
64 | template <func##type_var1##type_var2##concept Tp1_> \ |
---|
65 | struct concept_checking_##type_var1##type_var2##concept { }; \ |
---|
66 | typedef concept_checking_##type_var1##type_var2##concept< \ |
---|
67 | BOOST_FPTR ns::concept<type_var1,type_var2>::constraints> \ |
---|
68 | concept_checking_typedef_##type_var1##type_var2##concept |
---|
69 | |
---|
70 | #define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept) \ |
---|
71 | typedef void (ns::concept <tv1,tv2,tv3>::* \ |
---|
72 | func##tv1##tv2##tv3##concept)(); \ |
---|
73 | template <func##tv1##tv2##tv3##concept Tp1_> \ |
---|
74 | struct concept_checking_##tv1##tv2##tv3##concept { }; \ |
---|
75 | typedef concept_checking_##tv1##tv2##tv3##concept< \ |
---|
76 | BOOST_FPTR ns::concept<tv1,tv2,tv3>::constraints> \ |
---|
77 | concept_checking_typedef_##tv1##tv2##tv3##concept |
---|
78 | |
---|
79 | #define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \ |
---|
80 | typedef void (ns::concept <tv1,tv2,tv3,tv4>::* \ |
---|
81 | func##tv1##tv2##tv3##tv4##concept)(); \ |
---|
82 | template <func##tv1##tv2##tv3##tv4##concept Tp1_> \ |
---|
83 | struct concept_checking_##tv1##tv2##tv3##tv4##concept { }; \ |
---|
84 | typedef concept_checking_##tv1##tv2##tv3##tv4##concept< \ |
---|
85 | BOOST_FPTR ns::concept<tv1,tv2,tv3,tv4>::constraints> \ |
---|
86 | concept_checking_typedef_##tv1##tv2##tv3##tv4##concept |
---|
87 | |
---|
88 | // NOTE: The BOOST_CLASS_REQUIRES (with an 'S' at the end) is deprecated. |
---|
89 | |
---|
90 | // The BOOST_CLASS_REQUIRES macros use function pointers as |
---|
91 | // template parameters, which VC++ does not support. |
---|
92 | |
---|
93 | #if defined(BOOST_NO_FUNCTION_PTR_TEMPLATE_PARAMETERS) |
---|
94 | |
---|
95 | #define BOOST_CLASS_REQUIRES(type_var, concept) |
---|
96 | #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) |
---|
97 | #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) |
---|
98 | #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) |
---|
99 | |
---|
100 | #else |
---|
101 | |
---|
102 | #define BOOST_CLASS_REQUIRES(type_var, concept) \ |
---|
103 | typedef void (concept <type_var>::* func##type_var##concept)(); \ |
---|
104 | template <func##type_var##concept Tp1_> \ |
---|
105 | struct concept_checking_##type_var##concept { }; \ |
---|
106 | typedef concept_checking_##type_var##concept< \ |
---|
107 | BOOST_FPTR concept <type_var>::constraints> \ |
---|
108 | concept_checking_typedef_##type_var##concept |
---|
109 | |
---|
110 | #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \ |
---|
111 | typedef void (concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \ |
---|
112 | template <func##type_var1##type_var2##concept Tp1_> \ |
---|
113 | struct concept_checking_##type_var1##type_var2##concept { }; \ |
---|
114 | typedef concept_checking_##type_var1##type_var2##concept< \ |
---|
115 | BOOST_FPTR concept <type_var1,type_var2>::constraints> \ |
---|
116 | concept_checking_typedef_##type_var1##type_var2##concept |
---|
117 | |
---|
118 | #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \ |
---|
119 | typedef void (concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \ |
---|
120 | template <func##type_var1##type_var2##type_var3##concept Tp1_> \ |
---|
121 | struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \ |
---|
122 | typedef concept_checking_##type_var1##type_var2##type_var3##concept< \ |
---|
123 | BOOST_FPTR concept <type_var1,type_var2,type_var3>::constraints> \ |
---|
124 | concept_checking_typedef_##type_var1##type_var2##type_var3##concept |
---|
125 | |
---|
126 | #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \ |
---|
127 | typedef void (concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \ |
---|
128 | template <func##type_var1##type_var2##type_var3##type_var4##concept Tp1_> \ |
---|
129 | struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \ |
---|
130 | typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \ |
---|
131 | BOOST_FPTR concept <type_var1,type_var2,type_var3,type_var4>::constraints> \ |
---|
132 | concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept |
---|
133 | |
---|
134 | |
---|
135 | #endif |
---|
136 | |
---|
137 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
138 | template <class T, class U> |
---|
139 | struct require_same { }; |
---|
140 | |
---|
141 | template <class T> |
---|
142 | struct require_same<T,T> { typedef T type; }; |
---|
143 | #else |
---|
144 | // This version does not perform checking, but will not do any harm. |
---|
145 | template <class T, class U> |
---|
146 | struct require_same { typedef T type; }; |
---|
147 | #endif |
---|
148 | |
---|
149 | template <class T> |
---|
150 | struct IntegerConcept { |
---|
151 | void constraints() { |
---|
152 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
153 | x.error_type_must_be_an_integer_type(); |
---|
154 | #endif |
---|
155 | } |
---|
156 | T x; |
---|
157 | }; |
---|
158 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
159 | template <> struct IntegerConcept<short> { void constraints() {} }; |
---|
160 | template <> struct IntegerConcept<unsigned short> { void constraints() {} }; |
---|
161 | template <> struct IntegerConcept<int> { void constraints() {} }; |
---|
162 | template <> struct IntegerConcept<unsigned int> { void constraints() {} }; |
---|
163 | template <> struct IntegerConcept<long> { void constraints() {} }; |
---|
164 | template <> struct IntegerConcept<unsigned long> { void constraints() {} }; |
---|
165 | // etc. |
---|
166 | #endif |
---|
167 | |
---|
168 | template <class T> |
---|
169 | struct SignedIntegerConcept { |
---|
170 | void constraints() { |
---|
171 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
172 | x.error_type_must_be_a_signed_integer_type(); |
---|
173 | #endif |
---|
174 | } |
---|
175 | T x; |
---|
176 | }; |
---|
177 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
178 | template <> struct SignedIntegerConcept<short> { void constraints() {} }; |
---|
179 | template <> struct SignedIntegerConcept<int> { void constraints() {} }; |
---|
180 | template <> struct SignedIntegerConcept<long> { void constraints() {} }; |
---|
181 | # if defined(BOOST_HAS_LONG_LONG) |
---|
182 | template <> struct SignedIntegerConcept< ::boost::long_long_type> { void constraints() {} }; |
---|
183 | # endif |
---|
184 | // etc. |
---|
185 | #endif |
---|
186 | |
---|
187 | template <class T> |
---|
188 | struct UnsignedIntegerConcept { |
---|
189 | void constraints() { |
---|
190 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
191 | x.error_type_must_be_an_unsigned_integer_type(); |
---|
192 | #endif |
---|
193 | } |
---|
194 | T x; |
---|
195 | }; |
---|
196 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
197 | template <> struct UnsignedIntegerConcept<unsigned short> |
---|
198 | { void constraints() {} }; |
---|
199 | template <> struct UnsignedIntegerConcept<unsigned int> |
---|
200 | { void constraints() {} }; |
---|
201 | template <> struct UnsignedIntegerConcept<unsigned long> |
---|
202 | { void constraints() {} }; |
---|
203 | // etc. |
---|
204 | #endif |
---|
205 | |
---|
206 | //=========================================================================== |
---|
207 | // Basic Concepts |
---|
208 | |
---|
209 | template <class TT> |
---|
210 | struct DefaultConstructibleConcept |
---|
211 | { |
---|
212 | void constraints() { |
---|
213 | TT a; // require default constructor |
---|
214 | ignore_unused_variable_warning(a); |
---|
215 | } |
---|
216 | }; |
---|
217 | |
---|
218 | template <class TT> |
---|
219 | struct AssignableConcept |
---|
220 | { |
---|
221 | void constraints() { |
---|
222 | #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL |
---|
223 | a = a; // require assignment operator |
---|
224 | #endif |
---|
225 | const_constraints(a); |
---|
226 | } |
---|
227 | void const_constraints(const TT& b) { |
---|
228 | #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL |
---|
229 | a = b; // const required for argument to assignment |
---|
230 | #endif |
---|
231 | } |
---|
232 | TT a; |
---|
233 | }; |
---|
234 | |
---|
235 | template <class TT> |
---|
236 | struct CopyConstructibleConcept |
---|
237 | { |
---|
238 | void constraints() { |
---|
239 | TT a(b); // require copy constructor |
---|
240 | TT* ptr = &a; // require address of operator |
---|
241 | const_constraints(a); |
---|
242 | ignore_unused_variable_warning(ptr); |
---|
243 | } |
---|
244 | void const_constraints(const TT& a) { |
---|
245 | TT c(a); // require const copy constructor |
---|
246 | const TT* ptr = &a; // require const address of operator |
---|
247 | ignore_unused_variable_warning(c); |
---|
248 | ignore_unused_variable_warning(ptr); |
---|
249 | } |
---|
250 | TT b; |
---|
251 | }; |
---|
252 | |
---|
253 | // The SGI STL version of Assignable requires copy constructor and operator= |
---|
254 | template <class TT> |
---|
255 | struct SGIAssignableConcept |
---|
256 | { |
---|
257 | void constraints() { |
---|
258 | TT b(a); |
---|
259 | #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL |
---|
260 | a = a; // require assignment operator |
---|
261 | #endif |
---|
262 | const_constraints(a); |
---|
263 | ignore_unused_variable_warning(b); |
---|
264 | } |
---|
265 | void const_constraints(const TT& b) { |
---|
266 | TT c(b); |
---|
267 | #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL |
---|
268 | a = b; // const required for argument to assignment |
---|
269 | #endif |
---|
270 | ignore_unused_variable_warning(c); |
---|
271 | } |
---|
272 | TT a; |
---|
273 | }; |
---|
274 | |
---|
275 | template <class X, class Y> |
---|
276 | struct ConvertibleConcept |
---|
277 | { |
---|
278 | void constraints() { |
---|
279 | Y y = x; |
---|
280 | ignore_unused_variable_warning(y); |
---|
281 | } |
---|
282 | X x; |
---|
283 | }; |
---|
284 | |
---|
285 | // The C++ standard requirements for many concepts talk about return |
---|
286 | // types that must be "convertible to bool". The problem with this |
---|
287 | // requirement is that it leaves the door open for evil proxies that |
---|
288 | // define things like operator|| with strange return types. Two |
---|
289 | // possible solutions are: |
---|
290 | // 1) require the return type to be exactly bool |
---|
291 | // 2) stay with convertible to bool, and also |
---|
292 | // specify stuff about all the logical operators. |
---|
293 | // For now we just test for convertible to bool. |
---|
294 | template <class TT> |
---|
295 | void require_boolean_expr(const TT& t) { |
---|
296 | bool x = t; |
---|
297 | ignore_unused_variable_warning(x); |
---|
298 | } |
---|
299 | |
---|
300 | template <class TT> |
---|
301 | struct EqualityComparableConcept |
---|
302 | { |
---|
303 | void constraints() { |
---|
304 | require_boolean_expr(a == b); |
---|
305 | require_boolean_expr(a != b); |
---|
306 | } |
---|
307 | TT a, b; |
---|
308 | }; |
---|
309 | |
---|
310 | template <class TT> |
---|
311 | struct LessThanComparableConcept |
---|
312 | { |
---|
313 | void constraints() { |
---|
314 | require_boolean_expr(a < b); |
---|
315 | } |
---|
316 | TT a, b; |
---|
317 | }; |
---|
318 | |
---|
319 | // This is equivalent to SGI STL's LessThanComparable. |
---|
320 | template <class TT> |
---|
321 | struct ComparableConcept |
---|
322 | { |
---|
323 | void constraints() { |
---|
324 | require_boolean_expr(a < b); |
---|
325 | require_boolean_expr(a > b); |
---|
326 | require_boolean_expr(a <= b); |
---|
327 | require_boolean_expr(a >= b); |
---|
328 | } |
---|
329 | TT a, b; |
---|
330 | }; |
---|
331 | |
---|
332 | #define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \ |
---|
333 | template <class First, class Second> \ |
---|
334 | struct NAME { \ |
---|
335 | void constraints() { (void)constraints_(); } \ |
---|
336 | bool constraints_() { \ |
---|
337 | return a OP b; \ |
---|
338 | } \ |
---|
339 | First a; \ |
---|
340 | Second b; \ |
---|
341 | } |
---|
342 | |
---|
343 | #define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \ |
---|
344 | template <class Ret, class First, class Second> \ |
---|
345 | struct NAME { \ |
---|
346 | void constraints() { (void)constraints_(); } \ |
---|
347 | Ret constraints_() { \ |
---|
348 | return a OP b; \ |
---|
349 | } \ |
---|
350 | First a; \ |
---|
351 | Second b; \ |
---|
352 | } |
---|
353 | |
---|
354 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept); |
---|
355 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOpConcept); |
---|
356 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOpConcept); |
---|
357 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOpConcept); |
---|
358 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOpConcept); |
---|
359 | BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOpConcept); |
---|
360 | |
---|
361 | BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOpConcept); |
---|
362 | BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOpConcept); |
---|
363 | BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOpConcept); |
---|
364 | BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept); |
---|
365 | BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept); |
---|
366 | |
---|
367 | //=========================================================================== |
---|
368 | // Function Object Concepts |
---|
369 | |
---|
370 | template <class Func, class Return> |
---|
371 | struct GeneratorConcept |
---|
372 | { |
---|
373 | void constraints() { |
---|
374 | const Return& r = f(); // require operator() member function |
---|
375 | ignore_unused_variable_warning(r); |
---|
376 | } |
---|
377 | Func f; |
---|
378 | }; |
---|
379 | |
---|
380 | |
---|
381 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
382 | template <class Func> |
---|
383 | struct GeneratorConcept<Func,void> |
---|
384 | { |
---|
385 | void constraints() { |
---|
386 | f(); // require operator() member function |
---|
387 | } |
---|
388 | Func f; |
---|
389 | }; |
---|
390 | #endif |
---|
391 | |
---|
392 | template <class Func, class Return, class Arg> |
---|
393 | struct UnaryFunctionConcept |
---|
394 | { |
---|
395 | // required in case any of our template args are const-qualified: |
---|
396 | UnaryFunctionConcept(); |
---|
397 | |
---|
398 | void constraints() { |
---|
399 | r = f(arg); // require operator() |
---|
400 | } |
---|
401 | Func f; |
---|
402 | Arg arg; |
---|
403 | Return r; |
---|
404 | }; |
---|
405 | |
---|
406 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
407 | template <class Func, class Arg> |
---|
408 | struct UnaryFunctionConcept<Func, void, Arg> { |
---|
409 | void constraints() { |
---|
410 | f(arg); // require operator() |
---|
411 | } |
---|
412 | Func f; |
---|
413 | Arg arg; |
---|
414 | }; |
---|
415 | #endif |
---|
416 | |
---|
417 | template <class Func, class Return, class First, class Second> |
---|
418 | struct BinaryFunctionConcept |
---|
419 | { |
---|
420 | void constraints() { |
---|
421 | r = f(first, second); // require operator() |
---|
422 | } |
---|
423 | Func f; |
---|
424 | First first; |
---|
425 | Second second; |
---|
426 | Return r; |
---|
427 | }; |
---|
428 | |
---|
429 | #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION |
---|
430 | template <class Func, class First, class Second> |
---|
431 | struct BinaryFunctionConcept<Func, void, First, Second> |
---|
432 | { |
---|
433 | void constraints() { |
---|
434 | f(first, second); // require operator() |
---|
435 | } |
---|
436 | Func f; |
---|
437 | First first; |
---|
438 | Second second; |
---|
439 | }; |
---|
440 | #endif |
---|
441 | |
---|
442 | template <class Func, class Arg> |
---|
443 | struct UnaryPredicateConcept |
---|
444 | { |
---|
445 | void constraints() { |
---|
446 | require_boolean_expr(f(arg)); // require operator() returning bool |
---|
447 | } |
---|
448 | Func f; |
---|
449 | Arg arg; |
---|
450 | }; |
---|
451 | |
---|
452 | template <class Func, class First, class Second> |
---|
453 | struct BinaryPredicateConcept |
---|
454 | { |
---|
455 | void constraints() { |
---|
456 | require_boolean_expr(f(a, b)); // require operator() returning bool |
---|
457 | } |
---|
458 | Func f; |
---|
459 | First a; |
---|
460 | Second b; |
---|
461 | }; |
---|
462 | |
---|
463 | // use this when functor is used inside a container class like std::set |
---|
464 | template <class Func, class First, class Second> |
---|
465 | struct Const_BinaryPredicateConcept { |
---|
466 | void constraints() { |
---|
467 | const_constraints(f); |
---|
468 | } |
---|
469 | void const_constraints(const Func& fun) { |
---|
470 | function_requires<BinaryPredicateConcept<Func, First, Second> >(); |
---|
471 | // operator() must be a const member function |
---|
472 | require_boolean_expr(fun(a, b)); |
---|
473 | } |
---|
474 | Func f; |
---|
475 | First a; |
---|
476 | Second b; |
---|
477 | }; |
---|
478 | |
---|
479 | template <class Func, class Return> |
---|
480 | struct AdaptableGeneratorConcept |
---|
481 | { |
---|
482 | void constraints() { |
---|
483 | typedef typename Func::result_type result_type; |
---|
484 | BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value)); |
---|
485 | function_requires< GeneratorConcept<Func, result_type> >(); |
---|
486 | } |
---|
487 | }; |
---|
488 | |
---|
489 | template <class Func, class Return, class Arg> |
---|
490 | struct AdaptableUnaryFunctionConcept |
---|
491 | { |
---|
492 | void constraints() { |
---|
493 | typedef typename Func::argument_type argument_type; |
---|
494 | typedef typename Func::result_type result_type; |
---|
495 | BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value)); |
---|
496 | BOOST_STATIC_ASSERT((is_convertible<Arg, argument_type>::value)); |
---|
497 | function_requires< UnaryFunctionConcept<Func, result_type, argument_type> >(); |
---|
498 | } |
---|
499 | }; |
---|
500 | |
---|
501 | template <class Func, class Return, class First, class Second> |
---|
502 | struct AdaptableBinaryFunctionConcept |
---|
503 | { |
---|
504 | void constraints() { |
---|
505 | typedef typename Func::first_argument_type first_argument_type; |
---|
506 | typedef typename Func::second_argument_type second_argument_type; |
---|
507 | typedef typename Func::result_type result_type; |
---|
508 | BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value)); |
---|
509 | BOOST_STATIC_ASSERT((is_convertible<First, first_argument_type>::value)); |
---|
510 | BOOST_STATIC_ASSERT((is_convertible<Second, second_argument_type>::value)); |
---|
511 | function_requires< BinaryFunctionConcept<Func, result_type, |
---|
512 | first_argument_type, second_argument_type> >(); |
---|
513 | } |
---|
514 | }; |
---|
515 | |
---|
516 | template <class Func, class Arg> |
---|
517 | struct AdaptablePredicateConcept |
---|
518 | { |
---|
519 | void constraints() { |
---|
520 | function_requires< UnaryPredicateConcept<Func, Arg> >(); |
---|
521 | function_requires< AdaptableUnaryFunctionConcept<Func, bool, Arg> >(); |
---|
522 | } |
---|
523 | }; |
---|
524 | |
---|
525 | template <class Func, class First, class Second> |
---|
526 | struct AdaptableBinaryPredicateConcept |
---|
527 | { |
---|
528 | void constraints() { |
---|
529 | function_requires< BinaryPredicateConcept<Func, First, Second> >(); |
---|
530 | function_requires< AdaptableBinaryFunctionConcept<Func, bool, First, Second> >(); |
---|
531 | } |
---|
532 | }; |
---|
533 | |
---|
534 | //=========================================================================== |
---|
535 | // Iterator Concepts |
---|
536 | |
---|
537 | template <class TT> |
---|
538 | struct InputIteratorConcept |
---|
539 | { |
---|
540 | void constraints() { |
---|
541 | function_requires< AssignableConcept<TT> >(); |
---|
542 | function_requires< EqualityComparableConcept<TT> >(); |
---|
543 | TT j(i); |
---|
544 | (void)*i; // require dereference operator |
---|
545 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
546 | // require iterator_traits typedef's |
---|
547 | typedef typename std::iterator_traits<TT>::difference_type D; |
---|
548 | // Hmm, the following is a bit fragile |
---|
549 | //function_requires< SignedIntegerConcept<D> >(); |
---|
550 | typedef typename std::iterator_traits<TT>::reference R; |
---|
551 | typedef typename std::iterator_traits<TT>::pointer P; |
---|
552 | typedef typename std::iterator_traits<TT>::iterator_category C; |
---|
553 | function_requires< ConvertibleConcept<C, std::input_iterator_tag> >(); |
---|
554 | #endif |
---|
555 | ++j; // require preincrement operator |
---|
556 | i++; // require postincrement operator |
---|
557 | } |
---|
558 | TT i; |
---|
559 | }; |
---|
560 | |
---|
561 | template <class TT, class ValueT> |
---|
562 | struct OutputIteratorConcept |
---|
563 | { |
---|
564 | void constraints() { |
---|
565 | function_requires< AssignableConcept<TT> >(); |
---|
566 | ++i; // require preincrement operator |
---|
567 | i++; // require postincrement operator |
---|
568 | *i++ = t; // require postincrement and assignment |
---|
569 | } |
---|
570 | TT i, j; |
---|
571 | ValueT t; |
---|
572 | }; |
---|
573 | |
---|
574 | template <class TT> |
---|
575 | struct ForwardIteratorConcept |
---|
576 | { |
---|
577 | void constraints() { |
---|
578 | function_requires< InputIteratorConcept<TT> >(); |
---|
579 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
580 | typedef typename std::iterator_traits<TT>::iterator_category C; |
---|
581 | function_requires< ConvertibleConcept<C, std::forward_iterator_tag> >(); |
---|
582 | typedef typename std::iterator_traits<TT>::reference reference; |
---|
583 | reference r = *i; |
---|
584 | ignore_unused_variable_warning(r); |
---|
585 | #endif |
---|
586 | } |
---|
587 | TT i; |
---|
588 | }; |
---|
589 | |
---|
590 | template <class TT> |
---|
591 | struct Mutable_ForwardIteratorConcept |
---|
592 | { |
---|
593 | void constraints() { |
---|
594 | function_requires< ForwardIteratorConcept<TT> >(); |
---|
595 | *i++ = *i; // require postincrement and assignment |
---|
596 | } |
---|
597 | TT i; |
---|
598 | }; |
---|
599 | |
---|
600 | template <class TT> |
---|
601 | struct BidirectionalIteratorConcept |
---|
602 | { |
---|
603 | void constraints() { |
---|
604 | function_requires< ForwardIteratorConcept<TT> >(); |
---|
605 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
606 | typedef typename std::iterator_traits<TT>::iterator_category C; |
---|
607 | function_requires< ConvertibleConcept<C, |
---|
608 | std::bidirectional_iterator_tag> >(); |
---|
609 | #endif |
---|
610 | --i; // require predecrement operator |
---|
611 | i--; // require postdecrement operator |
---|
612 | } |
---|
613 | TT i; |
---|
614 | }; |
---|
615 | |
---|
616 | template <class TT> |
---|
617 | struct Mutable_BidirectionalIteratorConcept |
---|
618 | { |
---|
619 | void constraints() { |
---|
620 | function_requires< BidirectionalIteratorConcept<TT> >(); |
---|
621 | function_requires< Mutable_ForwardIteratorConcept<TT> >(); |
---|
622 | *i-- = *i; // require postdecrement and assignment |
---|
623 | } |
---|
624 | TT i; |
---|
625 | }; |
---|
626 | |
---|
627 | |
---|
628 | template <class TT> |
---|
629 | struct RandomAccessIteratorConcept |
---|
630 | { |
---|
631 | void constraints() { |
---|
632 | function_requires< BidirectionalIteratorConcept<TT> >(); |
---|
633 | function_requires< ComparableConcept<TT> >(); |
---|
634 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
635 | typedef typename std::iterator_traits<TT>::iterator_category C; |
---|
636 | function_requires< ConvertibleConcept< C, |
---|
637 | std::random_access_iterator_tag> >(); |
---|
638 | typedef typename std::iterator_traits<TT>::reference R; |
---|
639 | #endif |
---|
640 | |
---|
641 | i += n; // require assignment addition operator |
---|
642 | i = i + n; i = n + i; // require addition with difference type |
---|
643 | i -= n; // require assignment subtraction operator |
---|
644 | i = i - n; // require subtraction with difference type |
---|
645 | n = i - j; // require difference operator |
---|
646 | (void)i[n]; // require element access operator |
---|
647 | } |
---|
648 | TT a, b; |
---|
649 | TT i, j; |
---|
650 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
651 | typename std::iterator_traits<TT>::difference_type n; |
---|
652 | #else |
---|
653 | std::ptrdiff_t n; |
---|
654 | #endif |
---|
655 | }; |
---|
656 | |
---|
657 | template <class TT> |
---|
658 | struct Mutable_RandomAccessIteratorConcept |
---|
659 | { |
---|
660 | void constraints() { |
---|
661 | function_requires< RandomAccessIteratorConcept<TT> >(); |
---|
662 | function_requires< Mutable_BidirectionalIteratorConcept<TT> >(); |
---|
663 | i[n] = *i; // require element access and assignment |
---|
664 | } |
---|
665 | TT i; |
---|
666 | #ifndef BOOST_NO_STD_ITERATOR_TRAITS |
---|
667 | typename std::iterator_traits<TT>::difference_type n; |
---|
668 | #else |
---|
669 | std::ptrdiff_t n; |
---|
670 | #endif |
---|
671 | }; |
---|
672 | |
---|
673 | //=========================================================================== |
---|
674 | // Container Concepts |
---|
675 | |
---|
676 | template <class Container> |
---|
677 | struct ContainerConcept |
---|
678 | { |
---|
679 | typedef typename Container::value_type value_type; |
---|
680 | typedef typename Container::difference_type difference_type; |
---|
681 | typedef typename Container::size_type size_type; |
---|
682 | typedef typename Container::const_reference const_reference; |
---|
683 | typedef typename Container::const_pointer const_pointer; |
---|
684 | typedef typename Container::const_iterator const_iterator; |
---|
685 | |
---|
686 | void constraints() { |
---|
687 | function_requires< InputIteratorConcept<const_iterator> >(); |
---|
688 | function_requires< AssignableConcept<Container> >(); |
---|
689 | const_constraints(c); |
---|
690 | } |
---|
691 | void const_constraints(const Container& cc) { |
---|
692 | i = cc.begin(); |
---|
693 | i = cc.end(); |
---|
694 | n = cc.size(); |
---|
695 | n = cc.max_size(); |
---|
696 | b = cc.empty(); |
---|
697 | } |
---|
698 | Container c; |
---|
699 | bool b; |
---|
700 | const_iterator i; |
---|
701 | size_type n; |
---|
702 | }; |
---|
703 | |
---|
704 | template <class Container> |
---|
705 | struct Mutable_ContainerConcept |
---|
706 | { |
---|
707 | typedef typename Container::value_type value_type; |
---|
708 | typedef typename Container::reference reference; |
---|
709 | typedef typename Container::iterator iterator; |
---|
710 | typedef typename Container::pointer pointer; |
---|
711 | |
---|
712 | void constraints() { |
---|
713 | function_requires< ContainerConcept<Container> >(); |
---|
714 | function_requires< AssignableConcept<value_type> >(); |
---|
715 | function_requires< InputIteratorConcept<iterator> >(); |
---|
716 | |
---|
717 | i = c.begin(); |
---|
718 | i = c.end(); |
---|
719 | c.swap(c2); |
---|
720 | } |
---|
721 | iterator i; |
---|
722 | Container c, c2; |
---|
723 | }; |
---|
724 | |
---|
725 | template <class ForwardContainer> |
---|
726 | struct ForwardContainerConcept |
---|
727 | { |
---|
728 | void constraints() { |
---|
729 | function_requires< ContainerConcept<ForwardContainer> >(); |
---|
730 | typedef typename ForwardContainer::const_iterator const_iterator; |
---|
731 | function_requires< ForwardIteratorConcept<const_iterator> >(); |
---|
732 | } |
---|
733 | }; |
---|
734 | |
---|
735 | template <class ForwardContainer> |
---|
736 | struct Mutable_ForwardContainerConcept |
---|
737 | { |
---|
738 | void constraints() { |
---|
739 | function_requires< ForwardContainerConcept<ForwardContainer> >(); |
---|
740 | function_requires< Mutable_ContainerConcept<ForwardContainer> >(); |
---|
741 | typedef typename ForwardContainer::iterator iterator; |
---|
742 | function_requires< Mutable_ForwardIteratorConcept<iterator> >(); |
---|
743 | } |
---|
744 | }; |
---|
745 | |
---|
746 | template <class ReversibleContainer> |
---|
747 | struct ReversibleContainerConcept |
---|
748 | { |
---|
749 | typedef typename ReversibleContainer::const_iterator const_iterator; |
---|
750 | typedef typename ReversibleContainer::const_reverse_iterator |
---|
751 | const_reverse_iterator; |
---|
752 | |
---|
753 | void constraints() { |
---|
754 | function_requires< ForwardContainerConcept<ReversibleContainer> >(); |
---|
755 | function_requires< BidirectionalIteratorConcept<const_iterator> >(); |
---|
756 | function_requires< |
---|
757 | BidirectionalIteratorConcept<const_reverse_iterator> >(); |
---|
758 | const_constraints(c); |
---|
759 | } |
---|
760 | void const_constraints(const ReversibleContainer& cc) { |
---|
761 | const_reverse_iterator i = cc.rbegin(); |
---|
762 | i = cc.rend(); |
---|
763 | } |
---|
764 | ReversibleContainer c; |
---|
765 | }; |
---|
766 | |
---|
767 | template <class ReversibleContainer> |
---|
768 | struct Mutable_ReversibleContainerConcept |
---|
769 | { |
---|
770 | typedef typename ReversibleContainer::iterator iterator; |
---|
771 | typedef typename ReversibleContainer::reverse_iterator reverse_iterator; |
---|
772 | |
---|
773 | void constraints() { |
---|
774 | function_requires< ReversibleContainerConcept<ReversibleContainer> >(); |
---|
775 | function_requires< |
---|
776 | Mutable_ForwardContainerConcept<ReversibleContainer> >(); |
---|
777 | function_requires< Mutable_BidirectionalIteratorConcept<iterator> >(); |
---|
778 | function_requires< |
---|
779 | Mutable_BidirectionalIteratorConcept<reverse_iterator> >(); |
---|
780 | |
---|
781 | reverse_iterator i = c.rbegin(); |
---|
782 | i = c.rend(); |
---|
783 | } |
---|
784 | ReversibleContainer c; |
---|
785 | }; |
---|
786 | |
---|
787 | template <class RandomAccessContainer> |
---|
788 | struct RandomAccessContainerConcept |
---|
789 | { |
---|
790 | typedef typename RandomAccessContainer::size_type size_type; |
---|
791 | typedef typename RandomAccessContainer::const_reference const_reference; |
---|
792 | typedef typename RandomAccessContainer::const_iterator const_iterator; |
---|
793 | typedef typename RandomAccessContainer::const_reverse_iterator |
---|
794 | const_reverse_iterator; |
---|
795 | |
---|
796 | void constraints() { |
---|
797 | function_requires< ReversibleContainerConcept<RandomAccessContainer> >(); |
---|
798 | function_requires< RandomAccessIteratorConcept<const_iterator> >(); |
---|
799 | function_requires< |
---|
800 | RandomAccessIteratorConcept<const_reverse_iterator> >(); |
---|
801 | |
---|
802 | const_constraints(c); |
---|
803 | } |
---|
804 | void const_constraints(const RandomAccessContainer& cc) { |
---|
805 | const_reference r = cc[n]; |
---|
806 | ignore_unused_variable_warning(r); |
---|
807 | } |
---|
808 | RandomAccessContainer c; |
---|
809 | size_type n; |
---|
810 | }; |
---|
811 | |
---|
812 | template <class RandomAccessContainer> |
---|
813 | struct Mutable_RandomAccessContainerConcept |
---|
814 | { |
---|
815 | typedef typename RandomAccessContainer::size_type size_type; |
---|
816 | typedef typename RandomAccessContainer::reference reference; |
---|
817 | typedef typename RandomAccessContainer::iterator iterator; |
---|
818 | typedef typename RandomAccessContainer::reverse_iterator reverse_iterator; |
---|
819 | |
---|
820 | void constraints() { |
---|
821 | function_requires< |
---|
822 | RandomAccessContainerConcept<RandomAccessContainer> >(); |
---|
823 | function_requires< |
---|
824 | Mutable_ReversibleContainerConcept<RandomAccessContainer> >(); |
---|
825 | function_requires< Mutable_RandomAccessIteratorConcept<iterator> >(); |
---|
826 | function_requires< |
---|
827 | Mutable_RandomAccessIteratorConcept<reverse_iterator> >(); |
---|
828 | |
---|
829 | reference r = c[i]; |
---|
830 | ignore_unused_variable_warning(r); |
---|
831 | } |
---|
832 | size_type i; |
---|
833 | RandomAccessContainer c; |
---|
834 | }; |
---|
835 | |
---|
836 | // A Sequence is inherently mutable |
---|
837 | template <class Sequence> |
---|
838 | struct SequenceConcept |
---|
839 | { |
---|
840 | |
---|
841 | typedef typename Sequence::reference reference; |
---|
842 | typedef typename Sequence::const_reference const_reference; |
---|
843 | |
---|
844 | void constraints() { |
---|
845 | // Matt Austern's book puts DefaultConstructible here, the C++ |
---|
846 | // standard places it in Container |
---|
847 | // function_requires< DefaultConstructible<Sequence> >(); |
---|
848 | function_requires< Mutable_ForwardContainerConcept<Sequence> >(); |
---|
849 | function_requires< DefaultConstructibleConcept<Sequence> >(); |
---|
850 | |
---|
851 | Sequence |
---|
852 | c(n), |
---|
853 | c2(n, t), |
---|
854 | c3(first, last); |
---|
855 | |
---|
856 | c.insert(p, t); |
---|
857 | c.insert(p, n, t); |
---|
858 | c.insert(p, first, last); |
---|
859 | |
---|
860 | c.erase(p); |
---|
861 | c.erase(p, q); |
---|
862 | |
---|
863 | reference r = c.front(); |
---|
864 | |
---|
865 | ignore_unused_variable_warning(c); |
---|
866 | ignore_unused_variable_warning(c2); |
---|
867 | ignore_unused_variable_warning(c3); |
---|
868 | ignore_unused_variable_warning(r); |
---|
869 | const_constraints(c); |
---|
870 | } |
---|
871 | void const_constraints(const Sequence& c) { |
---|
872 | const_reference r = c.front(); |
---|
873 | ignore_unused_variable_warning(r); |
---|
874 | } |
---|
875 | typename Sequence::value_type t; |
---|
876 | typename Sequence::size_type n; |
---|
877 | typename Sequence::value_type* first, *last; |
---|
878 | typename Sequence::iterator p, q; |
---|
879 | }; |
---|
880 | |
---|
881 | template <class FrontInsertionSequence> |
---|
882 | struct FrontInsertionSequenceConcept |
---|
883 | { |
---|
884 | void constraints() { |
---|
885 | function_requires< SequenceConcept<FrontInsertionSequence> >(); |
---|
886 | |
---|
887 | c.push_front(t); |
---|
888 | c.pop_front(); |
---|
889 | } |
---|
890 | FrontInsertionSequence c; |
---|
891 | typename FrontInsertionSequence::value_type t; |
---|
892 | }; |
---|
893 | |
---|
894 | template <class BackInsertionSequence> |
---|
895 | struct BackInsertionSequenceConcept |
---|
896 | { |
---|
897 | typedef typename BackInsertionSequence::reference reference; |
---|
898 | typedef typename BackInsertionSequence::const_reference const_reference; |
---|
899 | |
---|
900 | void constraints() { |
---|
901 | function_requires< SequenceConcept<BackInsertionSequence> >(); |
---|
902 | |
---|
903 | c.push_back(t); |
---|
904 | c.pop_back(); |
---|
905 | reference r = c.back(); |
---|
906 | ignore_unused_variable_warning(r); |
---|
907 | } |
---|
908 | void const_constraints(const BackInsertionSequence& cc) { |
---|
909 | const_reference r = cc.back(); |
---|
910 | ignore_unused_variable_warning(r); |
---|
911 | }; |
---|
912 | BackInsertionSequence c; |
---|
913 | typename BackInsertionSequence::value_type t; |
---|
914 | }; |
---|
915 | |
---|
916 | template <class AssociativeContainer> |
---|
917 | struct AssociativeContainerConcept |
---|
918 | { |
---|
919 | void constraints() { |
---|
920 | function_requires< ForwardContainerConcept<AssociativeContainer> >(); |
---|
921 | function_requires< DefaultConstructibleConcept<AssociativeContainer> >(); |
---|
922 | |
---|
923 | i = c.find(k); |
---|
924 | r = c.equal_range(k); |
---|
925 | c.erase(k); |
---|
926 | c.erase(i); |
---|
927 | c.erase(r.first, r.second); |
---|
928 | const_constraints(c); |
---|
929 | } |
---|
930 | void const_constraints(const AssociativeContainer& cc) { |
---|
931 | ci = cc.find(k); |
---|
932 | n = cc.count(k); |
---|
933 | cr = cc.equal_range(k); |
---|
934 | } |
---|
935 | typedef typename AssociativeContainer::iterator iterator; |
---|
936 | typedef typename AssociativeContainer::const_iterator const_iterator; |
---|
937 | |
---|
938 | AssociativeContainer c; |
---|
939 | iterator i; |
---|
940 | std::pair<iterator,iterator> r; |
---|
941 | const_iterator ci; |
---|
942 | std::pair<const_iterator,const_iterator> cr; |
---|
943 | typename AssociativeContainer::key_type k; |
---|
944 | typename AssociativeContainer::size_type n; |
---|
945 | }; |
---|
946 | |
---|
947 | template <class UniqueAssociativeContainer> |
---|
948 | struct UniqueAssociativeContainerConcept |
---|
949 | { |
---|
950 | void constraints() { |
---|
951 | function_requires< AssociativeContainerConcept<UniqueAssociativeContainer> >(); |
---|
952 | |
---|
953 | UniqueAssociativeContainer c(first, last); |
---|
954 | |
---|
955 | pos_flag = c.insert(t); |
---|
956 | c.insert(first, last); |
---|
957 | |
---|
958 | ignore_unused_variable_warning(c); |
---|
959 | } |
---|
960 | std::pair<typename UniqueAssociativeContainer::iterator, bool> pos_flag; |
---|
961 | typename UniqueAssociativeContainer::value_type t; |
---|
962 | typename UniqueAssociativeContainer::value_type* first, *last; |
---|
963 | }; |
---|
964 | |
---|
965 | template <class MultipleAssociativeContainer> |
---|
966 | struct MultipleAssociativeContainerConcept |
---|
967 | { |
---|
968 | void constraints() { |
---|
969 | function_requires< AssociativeContainerConcept<MultipleAssociativeContainer> >(); |
---|
970 | |
---|
971 | MultipleAssociativeContainer c(first, last); |
---|
972 | |
---|
973 | pos = c.insert(t); |
---|
974 | c.insert(first, last); |
---|
975 | |
---|
976 | ignore_unused_variable_warning(c); |
---|
977 | ignore_unused_variable_warning(pos); |
---|
978 | } |
---|
979 | typename MultipleAssociativeContainer::iterator pos; |
---|
980 | typename MultipleAssociativeContainer::value_type t; |
---|
981 | typename MultipleAssociativeContainer::value_type* first, *last; |
---|
982 | }; |
---|
983 | |
---|
984 | template <class SimpleAssociativeContainer> |
---|
985 | struct SimpleAssociativeContainerConcept |
---|
986 | { |
---|
987 | void constraints() { |
---|
988 | function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >(); |
---|
989 | typedef typename SimpleAssociativeContainer::key_type key_type; |
---|
990 | typedef typename SimpleAssociativeContainer::value_type value_type; |
---|
991 | typedef typename require_same<key_type, value_type>::type req; |
---|
992 | } |
---|
993 | }; |
---|
994 | |
---|
995 | template <class SimpleAssociativeContainer> |
---|
996 | struct PairAssociativeContainerConcept |
---|
997 | { |
---|
998 | void constraints() { |
---|
999 | function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >(); |
---|
1000 | typedef typename SimpleAssociativeContainer::key_type key_type; |
---|
1001 | typedef typename SimpleAssociativeContainer::value_type value_type; |
---|
1002 | typedef typename SimpleAssociativeContainer::mapped_type mapped_type; |
---|
1003 | typedef std::pair<const key_type, mapped_type> required_value_type; |
---|
1004 | typedef typename require_same<value_type, required_value_type>::type req; |
---|
1005 | } |
---|
1006 | }; |
---|
1007 | |
---|
1008 | template <class SortedAssociativeContainer> |
---|
1009 | struct SortedAssociativeContainerConcept |
---|
1010 | { |
---|
1011 | void constraints() { |
---|
1012 | function_requires< AssociativeContainerConcept<SortedAssociativeContainer> >(); |
---|
1013 | function_requires< ReversibleContainerConcept<SortedAssociativeContainer> >(); |
---|
1014 | |
---|
1015 | SortedAssociativeContainer |
---|
1016 | c(kc), |
---|
1017 | c2(first, last), |
---|
1018 | c3(first, last, kc); |
---|
1019 | |
---|
1020 | p = c.upper_bound(k); |
---|
1021 | p = c.lower_bound(k); |
---|
1022 | r = c.equal_range(k); |
---|
1023 | |
---|
1024 | c.insert(p, t); |
---|
1025 | |
---|
1026 | ignore_unused_variable_warning(c); |
---|
1027 | ignore_unused_variable_warning(c2); |
---|
1028 | ignore_unused_variable_warning(c3); |
---|
1029 | } |
---|
1030 | void const_constraints(const SortedAssociativeContainer& c) { |
---|
1031 | kc = c.key_comp(); |
---|
1032 | vc = c.value_comp(); |
---|
1033 | |
---|
1034 | cp = c.upper_bound(k); |
---|
1035 | cp = c.lower_bound(k); |
---|
1036 | cr = c.equal_range(k); |
---|
1037 | } |
---|
1038 | typename SortedAssociativeContainer::key_compare kc; |
---|
1039 | typename SortedAssociativeContainer::value_compare vc; |
---|
1040 | typename SortedAssociativeContainer::value_type t; |
---|
1041 | typename SortedAssociativeContainer::key_type k; |
---|
1042 | typedef typename SortedAssociativeContainer::iterator iterator; |
---|
1043 | typedef typename SortedAssociativeContainer::const_iterator const_iterator; |
---|
1044 | iterator p; |
---|
1045 | const_iterator cp; |
---|
1046 | std::pair<iterator,iterator> r; |
---|
1047 | std::pair<const_iterator,const_iterator> cr; |
---|
1048 | typename SortedAssociativeContainer::value_type* first, *last; |
---|
1049 | }; |
---|
1050 | |
---|
1051 | // HashedAssociativeContainer |
---|
1052 | |
---|
1053 | } // namespace boost |
---|
1054 | |
---|
1055 | #endif // BOOST_CONCEPT_CHECKS_HPP |
---|
1056 | |
---|