source: svn/newcon3bcm2_21bu/toolchain/include/c++/3.4.2/bits/boost_concept_check.h

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 31.4 KB
Line 
1// Copyright (C) 2004 Free Software Foundation, Inc.
2//
3// This file is part of the GNU ISO C++ Library.  This library is free
4// software; you can redistribute it and/or modify it under the
5// terms of the GNU General Public License as published by the
6// Free Software Foundation; either version 2, or (at your option)
7// any later version.
8
9// This library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License along
15// with this library; see the file COPYING.  If not, write to the Free
16// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17// USA.
18
19// As a special exception, you may use this file as part of a free software
20// library without restriction.  Specifically, if other files instantiate
21// templates or use macros or inline functions from this file, or you compile
22// this file and link it with other files to produce an executable, this
23// file does not by itself cause the resulting executable to be covered by
24// the GNU General Public License.  This exception does not however
25// invalidate any other reasons why the executable file might be covered by
26// the GNU General Public License.
27
28// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
29// sell and distribute this software is granted provided this
30// copyright notice appears in all copies. This software is provided
31// "as is" without express or implied warranty, and with no claim as
32// to its suitability for any purpose.
33//
34
35// GCC Note:  based on version 1.12.0 of the Boost library.
36
37/** @file boost_concept_check.h
38 *  This is an internal header file, included by other library headers.
39 *  You should not attempt to use it directly.
40 */
41
42#ifndef _BOOST_CONCEPT_CHECK_H
43#define _BOOST_CONCEPT_CHECK_H 1
44
45#pragma GCC system_header
46
47#include <cstddef>                // for ptrdiff_t, used next
48#include <bits/stl_iterator_base_types.h>    // for traits and tags
49#include <utility>                           // for pair<>
50
51namespace __gnu_cxx
52{
53
54#define _IsUnused __attribute__ ((__unused__))
55
56// When the C-C code is in use, we would like this function to do as little
57// as possible at runtime, use as few resources as possible, and hopefully
58// be elided out of existence... hmmm.
59template <class _Concept>
60inline void __function_requires()
61{
62  void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
63}
64
65// No definition: if this is referenced, there's a problem with
66// the instantiating type not being one of the required integer types.
67// Unfortunately, this results in a link-time error, not a compile-time error.
68void __error_type_must_be_an_integer_type();
69void __error_type_must_be_an_unsigned_integer_type();
70void __error_type_must_be_a_signed_integer_type();
71
72// ??? Should the "concept_checking*" structs begin with more than _ ?
73#define _GLIBCXX_CLASS_REQUIRES(_type_var, _ns, _concept) \
74  typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
75  template <_func##_type_var##_concept _Tp1> \
76  struct _concept_checking##_type_var##_concept { }; \
77  typedef _concept_checking##_type_var##_concept< \
78    &_ns::_concept <_type_var>::__constraints> \
79    _concept_checking_typedef##_type_var##_concept
80
81#define _GLIBCXX_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
82  typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
83  template <_func##_type_var1##_type_var2##_concept _Tp1> \
84  struct _concept_checking##_type_var1##_type_var2##_concept { }; \
85  typedef _concept_checking##_type_var1##_type_var2##_concept< \
86    &_ns::_concept <_type_var1,_type_var2>::__constraints> \
87    _concept_checking_typedef##_type_var1##_type_var2##_concept
88
89#define _GLIBCXX_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
90  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
91  template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
92  struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
93  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
94    &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints>  \
95  _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
96
97#define _GLIBCXX_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
98  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
99  template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
100  struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
101  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
102  &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
103    _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
104
105
106template <class _Tp1, class _Tp2>
107struct _Aux_require_same { };
108
109template <class _Tp>
110struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
111
112  template <class _Tp1, class _Tp2>
113  struct _SameTypeConcept
114  {
115    void __constraints() {
116      typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
117    }
118  };
119
120  template <class _Tp>
121  struct _IntegerConcept {
122    void __constraints() {
123      __error_type_must_be_an_integer_type();
124    }
125  };
126  template <> struct _IntegerConcept<short> { void __constraints() {} };
127  template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
128  template <> struct _IntegerConcept<int> { void __constraints() {} };
129  template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
130  template <> struct _IntegerConcept<long> { void __constraints() {} };
131  template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
132  template <> struct _IntegerConcept<long long> { void __constraints() {} };
133  template <> struct _IntegerConcept<unsigned long long>
134                                                { void __constraints() {} };
135
136  template <class _Tp>
137  struct _SignedIntegerConcept {
138    void __constraints() {
139      __error_type_must_be_a_signed_integer_type();
140    }
141  };
142  template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
143  template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
144  template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
145  template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
146
147  template <class _Tp>
148  struct _UnsignedIntegerConcept {
149    void __constraints() {
150      __error_type_must_be_an_unsigned_integer_type();
151    }
152  };
153  template <> struct _UnsignedIntegerConcept<unsigned short>
154    { void __constraints() {} };
155  template <> struct _UnsignedIntegerConcept<unsigned int>
156    { void __constraints() {} };
157  template <> struct _UnsignedIntegerConcept<unsigned long>
158    { void __constraints() {} };
159  template <> struct _UnsignedIntegerConcept<unsigned long long>
160    { void __constraints() {} };
161
162  //===========================================================================
163  // Basic Concepts
164
165  template <class _Tp>
166  struct _DefaultConstructibleConcept
167  {
168    void __constraints() {
169      _Tp __a _IsUnused;                // require default constructor
170    }
171  };
172
173  template <class _Tp>
174  struct _AssignableConcept
175  {
176    void __constraints() {
177      __a = __a;                        // require assignment operator
178      __const_constraints(__a);
179    }
180    void __const_constraints(const _Tp& __b) {
181      __a = __b;                   // const required for argument to assignment
182    }
183    _Tp __a;
184    // possibly should be "Tp* a;" and then dereference "a" in constraint
185    // functions?  present way would require a default ctor, i think...
186  };
187
188  template <class _Tp>
189  struct _CopyConstructibleConcept
190  {
191    void __constraints() {
192      _Tp __a(__b);                     // require copy constructor
193      _Tp* __ptr _IsUnused = &__a;      // require address of operator
194      __const_constraints(__a);
195    }
196    void __const_constraints(const _Tp& __a) {
197      _Tp __c _IsUnused(__a);           // require const copy constructor
198      const _Tp* __ptr _IsUnused = &__a; // require const address of operator
199    }
200    _Tp __b;
201  };
202
203  // The SGI STL version of Assignable requires copy constructor and operator=
204  template <class _Tp>
205  struct _SGIAssignableConcept
206  {
207    void __constraints() {
208      _Tp __b _IsUnused(__a);
209      __a = __a;                        // require assignment operator
210      __const_constraints(__a);
211    }
212    void __const_constraints(const _Tp& __b) {
213      _Tp __c _IsUnused(__b);
214      __a = __b;              // const required for argument to assignment
215    }
216    _Tp __a;
217  };
218
219  template <class _From, class _To>
220  struct _ConvertibleConcept
221  {
222    void __constraints() {
223      _To __y _IsUnused = __x;
224    }
225    _From __x;
226  };
227
228  // The C++ standard requirements for many concepts talk about return
229  // types that must be "convertible to bool".  The problem with this
230  // requirement is that it leaves the door open for evil proxies that
231  // define things like operator|| with strange return types.  Two
232  // possible solutions are:
233  // 1) require the return type to be exactly bool
234  // 2) stay with convertible to bool, and also
235  //    specify stuff about all the logical operators.
236  // For now we just test for convertible to bool.
237  template <class _Tp>
238  void __aux_require_boolean_expr(const _Tp& __t) {
239    bool __x _IsUnused = __t;
240  }
241
242// FIXME
243  template <class _Tp>
244  struct _EqualityComparableConcept
245  {
246    void __constraints() {
247      __aux_require_boolean_expr(__a == __b);
248    }
249    _Tp __a, __b;
250  };
251
252  template <class _Tp>
253  struct _LessThanComparableConcept
254  {
255    void __constraints() {
256      __aux_require_boolean_expr(__a < __b);
257    }
258    _Tp __a, __b;
259  };
260
261  // This is equivalent to SGI STL's LessThanComparable.
262  template <class _Tp>
263  struct _ComparableConcept
264  {
265    void __constraints() {
266      __aux_require_boolean_expr(__a < __b);
267      __aux_require_boolean_expr(__a > __b);
268      __aux_require_boolean_expr(__a <= __b);
269      __aux_require_boolean_expr(__a >= __b);
270    }
271    _Tp __a, __b;
272  };
273
274#define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
275  template <class _First, class _Second> \
276  struct _NAME { \
277    void __constraints() { (void)__constraints_(); } \
278    bool __constraints_() {  \
279      return  __a _OP __b; \
280    } \
281    _First __a; \
282    _Second __b; \
283  }
284
285#define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
286  template <class _Ret, class _First, class _Second> \
287  struct _NAME { \
288    void __constraints() { (void)__constraints_(); } \
289    _Ret __constraints_() {  \
290      return __a _OP __b; \
291    } \
292    _First __a; \
293    _Second __b; \
294  }
295
296  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
297  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
298  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
299  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
300  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
301  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
302
303  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
304  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
305  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
306  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
307  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
308
309#undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
310#undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT
311
312  //===========================================================================
313  // Function Object Concepts
314
315  template <class _Func, class _Return>
316  struct _GeneratorConcept
317  {
318    void __constraints() {
319      const _Return& __r _IsUnused = __f();// require operator() member function
320    }
321    _Func __f;
322  };
323
324
325  template <class _Func>
326  struct _GeneratorConcept<_Func,void>
327  {
328    void __constraints() {
329      __f();                            // require operator() member function
330    }
331    _Func __f;
332  };
333
334  template <class _Func, class _Return, class _Arg>
335  struct _UnaryFunctionConcept
336  {
337    void __constraints() {
338      __r = __f(__arg);                  // require operator()
339    }
340    _Func __f;
341    _Arg __arg;
342    _Return __r;
343  };
344
345  template <class _Func, class _Arg>
346  struct _UnaryFunctionConcept<_Func, void, _Arg> {
347    void __constraints() {
348      __f(__arg);                       // require operator()
349    }
350    _Func __f;
351    _Arg __arg;
352  };
353
354  template <class _Func, class _Return, class _First, class _Second>
355  struct _BinaryFunctionConcept
356  {
357    void __constraints() {
358      __r = __f(__first, __second);     // require operator()
359    }
360    _Func __f;
361    _First __first;
362    _Second __second;
363    _Return __r;
364  };
365
366  template <class _Func, class _First, class _Second>
367  struct _BinaryFunctionConcept<_Func, void, _First, _Second>
368  {
369    void __constraints() {
370      __f(__first, __second);           // require operator()
371    }
372    _Func __f;
373    _First __first;
374    _Second __second;
375  };
376
377  template <class _Func, class _Arg>
378  struct _UnaryPredicateConcept
379  {
380    void __constraints() {
381      __aux_require_boolean_expr(__f(__arg)); // require op() returning bool
382    }
383    _Func __f;
384    _Arg __arg;
385  };
386
387  template <class _Func, class _First, class _Second>
388  struct _BinaryPredicateConcept
389  {
390    void __constraints() {
391      __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool
392    }
393    _Func __f;
394    _First __a;
395    _Second __b;
396  };
397
398  // use this when functor is used inside a container class like std::set
399  template <class _Func, class _First, class _Second>
400  struct _Const_BinaryPredicateConcept {
401    void __constraints() {
402      __const_constraints(__f);
403    }
404    void __const_constraints(const _Func& __fun) {
405      __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
406      // operator() must be a const member function
407      __aux_require_boolean_expr(__fun(__a, __b));
408    }
409    _Func __f;
410    _First __a;
411    _Second __b;
412  };
413
414  //===========================================================================
415  // Iterator Concepts
416
417  template <class _Tp>
418  struct _TrivialIteratorConcept
419  {
420    void __constraints() {
421//    __function_requires< _DefaultConstructibleConcept<_Tp> >();
422      __function_requires< _AssignableConcept<_Tp> >();
423      __function_requires< _EqualityComparableConcept<_Tp> >();
424//      typedef typename std::iterator_traits<_Tp>::value_type _V;
425      (void)*__i;                       // require dereference operator
426    }
427    _Tp __i;
428  };
429
430  template <class _Tp>
431  struct _Mutable_TrivialIteratorConcept
432  {
433    void __constraints() {
434      __function_requires< _TrivialIteratorConcept<_Tp> >();
435      *__i = *__j;                      // require dereference and assignment
436    }
437    _Tp __i, __j;
438  };
439
440  template <class _Tp>
441  struct _InputIteratorConcept
442  {
443    void __constraints() {
444      __function_requires< _TrivialIteratorConcept<_Tp> >();
445      // require iterator_traits typedef's
446      typedef typename std::iterator_traits<_Tp>::difference_type _Diff;
447//      __function_requires< _SignedIntegerConcept<_Diff> >();
448      typedef typename std::iterator_traits<_Tp>::reference _Ref;
449      typedef typename std::iterator_traits<_Tp>::pointer _Pt;
450      typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
451      __function_requires< _ConvertibleConcept<
452        typename std::iterator_traits<_Tp>::iterator_category,
453        std::input_iterator_tag> >();
454      ++__i;                            // require preincrement operator
455      __i++;                            // require postincrement operator
456    }
457    _Tp __i;
458  };
459
460  template <class _Tp, class _ValueT>
461  struct _OutputIteratorConcept
462  {
463    void __constraints() {
464      __function_requires< _AssignableConcept<_Tp> >();
465      ++__i;                            // require preincrement operator
466      __i++;                            // require postincrement operator
467      *__i++ = __t;                     // require postincrement and assignment
468    }
469    _Tp __i;
470    _ValueT __t;
471  };
472
473  template <class _Tp>
474  struct _ForwardIteratorConcept
475  {
476    void __constraints() {
477      __function_requires< _InputIteratorConcept<_Tp> >();
478      __function_requires< _DefaultConstructibleConcept<_Tp> >();
479      __function_requires< _ConvertibleConcept<
480        typename std::iterator_traits<_Tp>::iterator_category,
481        std::forward_iterator_tag> >();
482      typedef typename std::iterator_traits<_Tp>::reference _Ref;
483      _Ref __r _IsUnused = *__i;
484    }
485    _Tp __i;
486  };
487
488  template <class _Tp>
489  struct _Mutable_ForwardIteratorConcept
490  {
491    void __constraints() {
492      __function_requires< _ForwardIteratorConcept<_Tp> >();
493      *__i++ = *__i;                    // require postincrement and assignment
494    }
495    _Tp __i;
496  };
497
498  template <class _Tp>
499  struct _BidirectionalIteratorConcept
500  {
501    void __constraints() {
502      __function_requires< _ForwardIteratorConcept<_Tp> >();
503      __function_requires< _ConvertibleConcept<
504        typename std::iterator_traits<_Tp>::iterator_category,
505        std::bidirectional_iterator_tag> >();
506      --__i;                            // require predecrement operator
507      __i--;                            // require postdecrement operator
508    }
509    _Tp __i;
510  };
511
512  template <class _Tp>
513  struct _Mutable_BidirectionalIteratorConcept
514  {
515    void __constraints() {
516      __function_requires< _BidirectionalIteratorConcept<_Tp> >();
517      __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
518      *__i-- = *__i;                    // require postdecrement and assignment
519    }
520    _Tp __i;
521  };
522
523
524  template <class _Tp>
525  struct _RandomAccessIteratorConcept
526  {
527    void __constraints() {
528      __function_requires< _BidirectionalIteratorConcept<_Tp> >();
529      __function_requires< _ComparableConcept<_Tp> >();
530      __function_requires< _ConvertibleConcept<
531        typename std::iterator_traits<_Tp>::iterator_category,
532        std::random_access_iterator_tag> >();
533      // ??? We don't use _Ref, are we just checking for "referenceability"?
534      typedef typename std::iterator_traits<_Tp>::reference _Ref;
535
536      __i += __n;                       // require assignment addition operator
537      __i = __i + __n; __i = __n + __i; // require addition with difference type
538      __i -= __n;                       // require assignment subtraction op
539      __i = __i - __n;                  // require subtraction with
540                                        //            difference type
541      __n = __i - __j;                  // require difference operator
542      (void)__i[__n];                   // require element access operator
543    }
544    _Tp __a, __b;
545    _Tp __i, __j;
546    typename std::iterator_traits<_Tp>::difference_type __n;
547  };
548
549  template <class _Tp>
550  struct _Mutable_RandomAccessIteratorConcept
551  {
552    void __constraints() {
553      __function_requires< _RandomAccessIteratorConcept<_Tp> >();
554      __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
555      __i[__n] = *__i;                  // require element access and assignment
556    }
557    _Tp __i;
558    typename std::iterator_traits<_Tp>::difference_type __n;
559  };
560
561  //===========================================================================
562  // Container Concepts
563
564  template <class _Container>
565  struct _ContainerConcept
566  {
567    typedef typename _Container::value_type _Value_type;
568    typedef typename _Container::difference_type _Difference_type;
569    typedef typename _Container::size_type _Size_type;
570    typedef typename _Container::const_reference _Const_reference;
571    typedef typename _Container::const_pointer _Const_pointer;
572    typedef typename _Container::const_iterator _Const_iterator;
573
574    void __constraints() {
575      __function_requires< _InputIteratorConcept<_Const_iterator> >();
576      __function_requires< _AssignableConcept<_Container> >();
577      const _Container __c;
578      __i = __c.begin();
579      __i = __c.end();
580      __n = __c.size();
581      __n = __c.max_size();
582      __b = __c.empty();
583    }
584    bool __b;
585    _Const_iterator __i;
586    _Size_type __n;
587  };
588
589  template <class _Container>
590  struct _Mutable_ContainerConcept
591  {
592    typedef typename _Container::value_type _Value_type;
593    typedef typename _Container::reference _Reference;
594    typedef typename _Container::iterator _Iterator;
595    typedef typename _Container::pointer _Pointer;
596
597    void __constraints() {
598      __function_requires< _ContainerConcept<_Container> >();
599      __function_requires< _AssignableConcept<_Value_type> >();
600      __function_requires< _InputIteratorConcept<_Iterator> >();
601
602      __i = __c.begin();
603      __i = __c.end();
604      __c.swap(__c2);
605    }
606    _Iterator __i;
607    _Container __c, __c2;
608  };
609
610  template <class _ForwardContainer>
611  struct _ForwardContainerConcept
612  {
613    void __constraints() {
614      __function_requires< _ContainerConcept<_ForwardContainer> >();
615      typedef typename _ForwardContainer::const_iterator _Const_iterator;
616      __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
617    }
618  };
619
620  template <class _ForwardContainer>
621  struct _Mutable_ForwardContainerConcept
622  {
623    void __constraints() {
624      __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
625      __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
626      typedef typename _ForwardContainer::iterator _Iterator;
627      __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
628    }
629  };
630
631  template <class _ReversibleContainer>
632  struct _ReversibleContainerConcept
633  {
634    typedef typename _ReversibleContainer::const_iterator _Const_iterator;
635    typedef typename _ReversibleContainer::const_reverse_iterator
636      _Const_reverse_iterator;
637
638    void __constraints() {
639      __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
640      __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
641      __function_requires<
642        _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
643
644      const _ReversibleContainer __c;
645      _Const_reverse_iterator __i = __c.rbegin();
646      __i = __c.rend();
647    }
648  };
649
650  template <class _ReversibleContainer>
651  struct _Mutable_ReversibleContainerConcept
652  {
653    typedef typename _ReversibleContainer::iterator _Iterator;
654    typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
655
656    void __constraints() {
657      __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
658      __function_requires<
659        _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
660      __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
661      __function_requires<
662        _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
663
664      _Reverse_iterator __i = __c.rbegin();
665      __i = __c.rend();
666    }
667    _ReversibleContainer __c;
668  };
669
670  template <class _RandomAccessContainer>
671  struct _RandomAccessContainerConcept
672  {
673    typedef typename _RandomAccessContainer::size_type _Size_type;
674    typedef typename _RandomAccessContainer::const_reference _Const_reference;
675    typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
676    typedef typename _RandomAccessContainer::const_reverse_iterator
677      _Const_reverse_iterator;
678
679    void __constraints() {
680      __function_requires<
681        _ReversibleContainerConcept<_RandomAccessContainer> >();
682      __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
683      __function_requires<
684        _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
685
686      const _RandomAccessContainer __c;
687      _Const_reference __r _IsUnused = __c[__n];
688    }
689    _Size_type __n;
690  };
691
692  template <class _RandomAccessContainer>
693  struct _Mutable_RandomAccessContainerConcept
694  {
695    typedef typename _RandomAccessContainer::size_type _Size_type;
696    typedef typename _RandomAccessContainer::reference _Reference;
697    typedef typename _RandomAccessContainer::iterator _Iterator;
698    typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
699
700    void __constraints() {
701      __function_requires<
702        _RandomAccessContainerConcept<_RandomAccessContainer> >();
703      __function_requires<
704        _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
705      __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
706      __function_requires<
707        _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
708
709      _Reference __r _IsUnused = __c[__i];
710    }
711    _Size_type __i;
712    _RandomAccessContainer __c;
713  };
714
715  // A Sequence is inherently mutable
716  template <class _Sequence>
717  struct _SequenceConcept
718  {
719    typedef typename _Sequence::reference _Reference;
720    typedef typename _Sequence::const_reference _Const_reference;
721
722    void __constraints() {
723      // Matt Austern's book puts DefaultConstructible here, the C++
724      // standard places it in Container
725      //    function_requires< DefaultConstructible<Sequence> >();
726      __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
727      __function_requires< _DefaultConstructibleConcept<_Sequence> >();
728
729      _Sequence
730        __c _IsUnused(__n),
731        __c2 _IsUnused(__n, __t),
732        __c3 _IsUnused(__first, __last);
733
734      __c.insert(__p, __t);
735      __c.insert(__p, __n, __t);
736      __c.insert(__p, __first, __last);
737
738      __c.erase(__p);
739      __c.erase(__p, __q);
740
741      _Reference __r _IsUnused = __c.front();
742
743      __const_constraints(__c);
744    }
745    void __const_constraints(const _Sequence& __c) {
746      _Const_reference __r _IsUnused = __c.front();
747    }
748    typename _Sequence::value_type __t;
749    typename _Sequence::size_type __n;
750    typename _Sequence::value_type *__first, *__last;
751    typename _Sequence::iterator __p, __q;
752  };
753
754  template <class _FrontInsertionSequence>
755  struct _FrontInsertionSequenceConcept
756  {
757    void __constraints() {
758      __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
759
760      __c.push_front(__t);
761      __c.pop_front();
762    }
763    _FrontInsertionSequence __c;
764    typename _FrontInsertionSequence::value_type __t;
765  };
766
767  template <class _BackInsertionSequence>
768  struct _BackInsertionSequenceConcept
769  {
770    typedef typename _BackInsertionSequence::reference _Reference;
771    typedef typename _BackInsertionSequence::const_reference _Const_reference;
772
773    void __constraints() {
774      __function_requires< _SequenceConcept<_BackInsertionSequence> >();
775
776      __c.push_back(__t);
777      __c.pop_back();
778      _Reference __r _IsUnused = __c.back();
779    }
780    void __const_constraints(const _BackInsertionSequence& __c) {
781      _Const_reference __r _IsUnused = __c.back();
782    };
783    _BackInsertionSequence __c;
784    typename _BackInsertionSequence::value_type __t;
785  };
786
787  template <class _AssociativeContainer>
788  struct _AssociativeContainerConcept
789  {
790    void __constraints() {
791      __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
792      __function_requires<
793        _DefaultConstructibleConcept<_AssociativeContainer> >();
794
795      __i = __c.find(__k);
796      __r = __c.equal_range(__k);
797      __c.erase(__k);
798      __c.erase(__i);
799      __c.erase(__r.first, __r.second);
800      __const_constraints(__c);
801    }
802    void __const_constraints(const _AssociativeContainer& __c) {
803      __ci = __c.find(__k);
804      __n = __c.count(__k);
805      __cr = __c.equal_range(__k);
806    }
807    typedef typename _AssociativeContainer::iterator _Iterator;
808    typedef typename _AssociativeContainer::const_iterator _Const_iterator;
809
810    _AssociativeContainer __c;
811    _Iterator __i;
812    std::pair<_Iterator,_Iterator> __r;
813    _Const_iterator __ci;
814    std::pair<_Const_iterator,_Const_iterator> __cr;
815    typename _AssociativeContainer::key_type __k;
816    typename _AssociativeContainer::size_type __n;
817  };
818
819  template <class _UniqueAssociativeContainer>
820  struct _UniqueAssociativeContainerConcept
821  {
822    void __constraints() {
823      __function_requires<
824        _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
825
826      _UniqueAssociativeContainer __c(__first, __last);
827
828      __pos_flag = __c.insert(__t);
829      __c.insert(__first, __last);
830    }
831    std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
832    typename _UniqueAssociativeContainer::value_type __t;
833    typename _UniqueAssociativeContainer::value_type *__first, *__last;
834  };
835
836  template <class _MultipleAssociativeContainer>
837  struct _MultipleAssociativeContainerConcept
838  {
839    void __constraints() {
840      __function_requires<
841        _AssociativeContainerConcept<_MultipleAssociativeContainer> >();
842
843      _MultipleAssociativeContainer __c(__first, __last);
844
845      __pos = __c.insert(__t);
846      __c.insert(__first, __last);
847
848    }
849    typename _MultipleAssociativeContainer::iterator __pos;
850    typename _MultipleAssociativeContainer::value_type __t;
851    typename _MultipleAssociativeContainer::value_type *__first, *__last;
852  };
853
854  template <class _SimpleAssociativeContainer>
855  struct _SimpleAssociativeContainerConcept
856  {
857    void __constraints() {
858      __function_requires<
859        _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
860      typedef typename _SimpleAssociativeContainer::key_type _Key_type;
861      typedef typename _SimpleAssociativeContainer::value_type _Value_type;
862      typedef typename _Aux_require_same<_Key_type, _Value_type>::_Type
863        _Required;
864    }
865  };
866
867  template <class _SimpleAssociativeContainer>
868  struct _PairAssociativeContainerConcept
869  {
870    void __constraints() {
871      __function_requires<
872        _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
873      typedef typename _SimpleAssociativeContainer::key_type _Key_type;
874      typedef typename _SimpleAssociativeContainer::value_type _Value_type;
875      typedef typename _SimpleAssociativeContainer::mapped_type _Mapped_type;
876      typedef std::pair<const _Key_type, _Mapped_type> _Required_value_type;
877      typedef typename _Aux_require_same<_Value_type,
878        _Required_value_type>::_Type _Required;
879    }
880  };
881
882  template <class _SortedAssociativeContainer>
883  struct _SortedAssociativeContainerConcept
884  {
885    void __constraints() {
886      __function_requires<
887        _AssociativeContainerConcept<_SortedAssociativeContainer> >();
888      __function_requires<
889        _ReversibleContainerConcept<_SortedAssociativeContainer> >();
890
891      _SortedAssociativeContainer
892        __c _IsUnused(__kc),
893        __c2 _IsUnused(__first, __last),
894        __c3 _IsUnused(__first, __last, __kc);
895
896      __p = __c.upper_bound(__k);
897      __p = __c.lower_bound(__k);
898      __r = __c.equal_range(__k);
899
900      __c.insert(__p, __t);
901    }
902    void __const_constraints(const _SortedAssociativeContainer& __c) {
903      __kc = __c.key_comp();
904      __vc = __c.value_comp();
905
906      __cp = __c.upper_bound(__k);
907      __cp = __c.lower_bound(__k);
908      __cr = __c.equal_range(__k);
909    }
910    typename _SortedAssociativeContainer::key_compare __kc;
911    typename _SortedAssociativeContainer::value_compare __vc;
912    typename _SortedAssociativeContainer::value_type __t;
913    typename _SortedAssociativeContainer::key_type __k;
914    typedef typename _SortedAssociativeContainer::iterator _Iterator;
915    typedef typename _SortedAssociativeContainer::const_iterator
916      _Const_iterator;
917
918    _Iterator __p;
919    _Const_iterator __cp;
920    std::pair<_Iterator,_Iterator> __r;
921    std::pair<_Const_iterator,_Const_iterator> __cr;
922    typename _SortedAssociativeContainer::value_type *__first, *__last;
923  };
924
925  // HashedAssociativeContainer
926
927} // namespace __gnu_cxx
928
929#undef _IsUnused
930
931#endif // _GLIBCXX_BOOST_CONCEPT_CHECK
932
933
Note: See TracBrowser for help on using the repository browser.