OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [boost_concept_check.h] - Blame information for rev 35

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.