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/] [chrono] - 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) 2008-2012 Free Software Foundation, Inc.
4
//
5
// This file is part of the GNU ISO C++ Library.  This library is free
6
// software; you can redistribute it and/or modify it under the
7
// terms of the GNU General Public License as published by the
8
// Free Software Foundation; either version 3, or (at your option)
9
// any later version.
10
 
11
// This library is distributed in the hope that it will be useful,
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
// GNU General Public License for more details.
15
 
16
// Under Section 7 of GPL version 3, you are granted additional
17
// permissions described in the GCC Runtime Library Exception, version
18
// 3.1, as published by the Free Software Foundation.
19
 
20
// You should have received a copy of the GNU General Public License and
21
// a copy of the GCC Runtime Library Exception along with this program;
22
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
// .
24
 
25
/** @file include/chrono
26
 *  This is a Standard C++ Library header.
27
 */
28
 
29
#ifndef _GLIBCXX_CHRONO
30
#define _GLIBCXX_CHRONO 1
31
 
32
#pragma GCC system_header
33
 
34
#if __cplusplus < 201103L
35
# include 
36
#else
37
 
38
#include 
39
#include 
40
#include 
41
#include 
42
 
43
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
44
 
45
namespace std _GLIBCXX_VISIBILITY(default)
46
{
47
  /**
48
   * @defgroup chrono Time
49
   * @ingroup utilities
50
   *
51
   * Classes and functions for time.
52
   * @{
53
   */
54
 
55
  /** @namespace std::chrono
56
   *  @brief ISO C++ 2011 entities sub-namespace for time and date.
57
   */
58
  namespace chrono
59
  {
60
  _GLIBCXX_BEGIN_NAMESPACE_VERSION
61
 
62
    template>
63
      struct duration;
64
 
65
    template
66
      struct time_point;
67
 
68
  _GLIBCXX_END_NAMESPACE_VERSION
69
  }
70
 
71
_GLIBCXX_BEGIN_NAMESPACE_VERSION
72
 
73
  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
74
 
75
  template
76
    struct __duration_common_type_wrapper
77
    {
78
    private:
79
      typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
80
      typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
81
      typedef typename _CT::type __cr;
82
      typedef ratio<__gcd_num::value,
83
        (_Period1::den / __gcd_den::value) * _Period2::den> __r;
84
    public:
85
      typedef __success_type> type;
86
    };
87
 
88
  template
89
    struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
90
    { typedef __failure_type type; };
91
 
92
  template
93
    struct common_type,
94
             chrono::duration<_Rep2, _Period2>>
95
    : public __duration_common_type_wrapper
96
             common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
97
    { };
98
 
99
  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
100
 
101
  template
102
    struct __timepoint_common_type_wrapper
103
    {
104
      typedef __success_type>
105
        type;
106
    };
107
 
108
  template
109
    struct __timepoint_common_type_wrapper<__failure_type, _Clock>
110
    { typedef __failure_type type; };
111
 
112
  template
113
    struct common_type,
114
             chrono::time_point<_Clock, _Duration2>>
115
    : public __timepoint_common_type_wrapper
116
             common_type<_Duration1, _Duration2>>::type, _Clock>::type
117
    { };
118
 
119
_GLIBCXX_END_NAMESPACE_VERSION
120
 
121
  namespace chrono
122
  {
123
  _GLIBCXX_BEGIN_NAMESPACE_VERSION
124
 
125
    // Primary template for duration_cast impl.
126
    template
127
             bool _NumIsOne = false, bool _DenIsOne = false>
128
      struct __duration_cast_impl
129
      {
130
        template
131
          static constexpr _ToDur
132
          __cast(const duration<_Rep, _Period>& __d)
133
          {
134
            typedef typename _ToDur::rep                        __to_rep;
135
            return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
136
              * static_cast<_CR>(_CF::num)
137
              / static_cast<_CR>(_CF::den)));
138
          }
139
      };
140
 
141
    template
142
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
143
      {
144
        template
145
          static constexpr _ToDur
146
          __cast(const duration<_Rep, _Period>& __d)
147
          {
148
            typedef typename _ToDur::rep                        __to_rep;
149
            return _ToDur(static_cast<__to_rep>(__d.count()));
150
          }
151
      };
152
 
153
    template
154
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
155
      {
156
        template
157
          static constexpr _ToDur
158
          __cast(const duration<_Rep, _Period>& __d)
159
          {
160
            typedef typename _ToDur::rep                        __to_rep;
161
            return _ToDur(static_cast<__to_rep>(
162
              static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
163
          }
164
      };
165
 
166
    template
167
      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
168
      {
169
        template
170
          static constexpr _ToDur
171
          __cast(const duration<_Rep, _Period>& __d)
172
          {
173
            typedef typename _ToDur::rep                        __to_rep;
174
            return _ToDur(static_cast<__to_rep>(
175
              static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
176
          }
177
      };
178
 
179
    template
180
      struct __is_duration
181
      : std::false_type
182
      { };
183
 
184
    template
185
      struct __is_duration>
186
      : std::true_type
187
      { };
188
 
189
    /// duration_cast
190
    template
191
      constexpr typename enable_if<__is_duration<_ToDur>::value,
192
                                   _ToDur>::type
193
      duration_cast(const duration<_Rep, _Period>& __d)
194
      {
195
        typedef typename _ToDur::period                         __to_period;
196
        typedef typename _ToDur::rep                            __to_rep;
197
        typedef ratio_divide<_Period, __to_period>            __cf;
198
        typedef typename common_type<__to_rep, _Rep, intmax_t>::type
199
                                                                __cr;
200
        typedef  __duration_cast_impl<_ToDur, __cf, __cr,
201
                                      __cf::num == 1, __cf::den == 1> __dc;
202
        return __dc::__cast(__d);
203
      }
204
 
205
    /// treat_as_floating_point
206
    template
207
      struct treat_as_floating_point
208
      : is_floating_point<_Rep>
209
      { };
210
 
211
    /// duration_values
212
    template
213
      struct duration_values
214
      {
215
        static constexpr _Rep
216
        zero()
217
        { return _Rep(0); }
218
 
219
        static constexpr _Rep
220
        max()
221
        { return numeric_limits<_Rep>::max(); }
222
 
223
        static constexpr _Rep
224
        min()
225
        { return numeric_limits<_Rep>::lowest(); }
226
      };
227
 
228
    template
229
      struct __is_ratio
230
      : std::false_type
231
      { };
232
 
233
    template
234
      struct __is_ratio>
235
      : std::true_type
236
      { };
237
 
238
    /// duration
239
    template
240
      struct duration
241
      {
242
        typedef _Rep                                            rep;
243
        typedef _Period                                         period;
244
 
245
        static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
246
        static_assert(__is_ratio<_Period>::value,
247
                      "period must be a specialization of ratio");
248
        static_assert(_Period::num > 0, "period must be positive");
249
 
250
        // 20.11.5.1 construction / copy / destroy
251
        constexpr duration() = default;
252
 
253
        // NB: Make constexpr implicit. This cannot be explicitly
254
        // constexpr, as any UDT that is not a literal type with a
255
        // constexpr copy constructor will be ill-formed.
256
        duration(const duration&) = default;
257
 
258
        template
259
               enable_if::value
260
                         && (treat_as_floating_point::value
261
                             || !treat_as_floating_point<_Rep2>::value)>::type>
262
          constexpr explicit duration(const _Rep2& __rep)
263
          : __r(static_cast(__rep)) { }
264
 
265
        template
266
               enable_if::value
267
                         || (ratio_divide<_Period2, period>::den == 1
268
                             && !treat_as_floating_point<_Rep2>::value)>::type>
269
          constexpr duration(const duration<_Rep2, _Period2>& __d)
270
          : __r(duration_cast(__d).count()) { }
271
 
272
        ~duration() = default;
273
        duration& operator=(const duration&) = default;
274
 
275
        // 20.11.5.2 observer
276
        constexpr rep
277
        count() const
278
        { return __r; }
279
 
280
        // 20.11.5.3 arithmetic
281
        constexpr duration
282
        operator+() const
283
        { return *this; }
284
 
285
        constexpr duration
286
        operator-() const
287
        { return duration(-__r); }
288
 
289
        duration&
290
        operator++()
291
        {
292
          ++__r;
293
          return *this;
294
        }
295
 
296
        duration
297
        operator++(int)
298
        { return duration(__r++); }
299
 
300
        duration&
301
        operator--()
302
        {
303
          --__r;
304
          return *this;
305
        }
306
 
307
        duration
308
        operator--(int)
309
        { return duration(__r--); }
310
 
311
        duration&
312
        operator+=(const duration& __d)
313
        {
314
          __r += __d.count();
315
          return *this;
316
        }
317
 
318
        duration&
319
        operator-=(const duration& __d)
320
        {
321
          __r -= __d.count();
322
          return *this;
323
        }
324
 
325
        duration&
326
        operator*=(const rep& __rhs)
327
        {
328
          __r *= __rhs;
329
          return *this;
330
        }
331
 
332
        duration&
333
        operator/=(const rep& __rhs)
334
        {
335
          __r /= __rhs;
336
          return *this;
337
        }
338
 
339
        // DR 934.
340
        template
341
          typename enable_if::value,
342
                             duration&>::type
343
          operator%=(const rep& __rhs)
344
          {
345
            __r %= __rhs;
346
            return *this;
347
          }
348
 
349
        template
350
          typename enable_if::value,
351
                             duration&>::type
352
          operator%=(const duration& __d)
353
          {
354
            __r %= __d.count();
355
            return *this;
356
          }
357
 
358
        // 20.11.5.4 special values
359
        static constexpr duration
360
        zero()
361
        { return duration(duration_values::zero()); }
362
 
363
        static constexpr duration
364
        min()
365
        { return duration(duration_values::min()); }
366
 
367
        static constexpr duration
368
        max()
369
        { return duration(duration_values::max()); }
370
 
371
      private:
372
        rep __r;
373
      };
374
 
375
    template
376
             typename _Rep2, typename _Period2>
377
      constexpr typename common_type,
378
                                     duration<_Rep2, _Period2>>::type
379
      operator+(const duration<_Rep1, _Period1>& __lhs,
380
                const duration<_Rep2, _Period2>& __rhs)
381
      {
382
        typedef duration<_Rep1, _Period1>                        __dur1;
383
        typedef duration<_Rep2, _Period2>                        __dur2;
384
        typedef typename common_type<__dur1,__dur2>::type      __cd;
385
        return __cd(__cd(__lhs).count() + __cd(__rhs).count());
386
      }
387
 
388
    template
389
             typename _Rep2, typename _Period2>
390
      constexpr typename common_type,
391
                                     duration<_Rep2, _Period2>>::type
392
      operator-(const duration<_Rep1, _Period1>& __lhs,
393
                const duration<_Rep2, _Period2>& __rhs)
394
      {
395
        typedef duration<_Rep1, _Period1>                        __dur1;
396
        typedef duration<_Rep2, _Period2>                        __dur2;
397
        typedef typename common_type<__dur1,__dur2>::type      __cd;
398
        return __cd(__cd(__lhs).count() - __cd(__rhs).count());
399
      }
400
 
401
    template
402
             is_convertible<_Rep2,
403
                            typename common_type<_Rep1, _Rep2>::type>::value>
404
      struct __common_rep_type { };
405
 
406
    template
407
      struct __common_rep_type<_Rep1, _Rep2, true>
408
      { typedef typename common_type<_Rep1, _Rep2>::type type; };
409
 
410
    template
411
      constexpr
412
      duration::type, _Period>
413
      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
414
      {
415
        typedef duration::type, _Period>
416
          __cd;
417
        return __cd(__cd(__d).count() * __s);
418
      }
419
 
420
    template
421
      constexpr
422
      duration::type, _Period>
423
      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
424
      { return __d * __s; }
425
 
426
    template
427
      constexpr duration
428
        enable_if::value, _Rep2>::type>::type, _Period>
429
      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
430
      {
431
        typedef duration::type, _Period>
432
          __cd;
433
        return __cd(__cd(__d).count() / __s);
434
      }
435
 
436
    template
437
             typename _Rep2, typename _Period2>
438
      constexpr typename common_type<_Rep1, _Rep2>::type
439
      operator/(const duration<_Rep1, _Period1>& __lhs,
440
                const duration<_Rep2, _Period2>& __rhs)
441
      {
442
        typedef duration<_Rep1, _Period1>                        __dur1;
443
        typedef duration<_Rep2, _Period2>                        __dur2;
444
        typedef typename common_type<__dur1,__dur2>::type      __cd;
445
        return __cd(__lhs).count() / __cd(__rhs).count();
446
      }
447
 
448
    // DR 934.
449
    template
450
      constexpr duration
451
        enable_if::value, _Rep2>::type>::type, _Period>
452
      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
453
      {
454
        typedef duration::type, _Period>
455
          __cd;
456
        return __cd(__cd(__d).count() % __s);
457
      }
458
 
459
    template
460
             typename _Rep2, typename _Period2>
461
      constexpr typename common_type,
462
                                     duration<_Rep2, _Period2>>::type
463
      operator%(const duration<_Rep1, _Period1>& __lhs,
464
                const duration<_Rep2, _Period2>& __rhs)
465
      {
466
        typedef duration<_Rep1, _Period1>                        __dur1;
467
        typedef duration<_Rep2, _Period2>                        __dur2;
468
        typedef typename common_type<__dur1,__dur2>::type      __cd;
469
        return __cd(__cd(__lhs).count() % __cd(__rhs).count());
470
      }
471
 
472
    // comparisons
473
    template
474
             typename _Rep2, typename _Period2>
475
      constexpr bool
476
      operator==(const duration<_Rep1, _Period1>& __lhs,
477
                 const duration<_Rep2, _Period2>& __rhs)
478
      {
479
        typedef duration<_Rep1, _Period1>                        __dur1;
480
        typedef duration<_Rep2, _Period2>                        __dur2;
481
        typedef typename common_type<__dur1,__dur2>::type      __ct;
482
        return __ct(__lhs).count() == __ct(__rhs).count();
483
      }
484
 
485
    template
486
             typename _Rep2, typename _Period2>
487
      constexpr bool
488
      operator<(const duration<_Rep1, _Period1>& __lhs,
489
                const duration<_Rep2, _Period2>& __rhs)
490
      {
491
        typedef duration<_Rep1, _Period1>                        __dur1;
492
        typedef duration<_Rep2, _Period2>                        __dur2;
493
        typedef typename common_type<__dur1,__dur2>::type      __ct;
494
        return __ct(__lhs).count() < __ct(__rhs).count();
495
      }
496
 
497
    template
498
             typename _Rep2, typename _Period2>
499
      constexpr bool
500
      operator!=(const duration<_Rep1, _Period1>& __lhs,
501
                 const duration<_Rep2, _Period2>& __rhs)
502
      { return !(__lhs == __rhs); }
503
 
504
    template
505
             typename _Rep2, typename _Period2>
506
      constexpr bool
507
      operator<=(const duration<_Rep1, _Period1>& __lhs,
508
                 const duration<_Rep2, _Period2>& __rhs)
509
      { return !(__rhs < __lhs); }
510
 
511
    template
512
             typename _Rep2, typename _Period2>
513
      constexpr bool
514
      operator>(const duration<_Rep1, _Period1>& __lhs,
515
                const duration<_Rep2, _Period2>& __rhs)
516
      { return __rhs < __lhs; }
517
 
518
    template
519
             typename _Rep2, typename _Period2>
520
      constexpr bool
521
      operator>=(const duration<_Rep1, _Period1>& __lhs,
522
                 const duration<_Rep2, _Period2>& __rhs)
523
      { return !(__lhs < __rhs); }
524
 
525
    /// nanoseconds
526
    typedef duration    nanoseconds;
527
 
528
    /// microseconds
529
    typedef duration    microseconds;
530
 
531
    /// milliseconds
532
    typedef duration    milliseconds;
533
 
534
    /// seconds
535
    typedef duration            seconds;
536
 
537
    /// minutes
538
    typedef duration>   minutes;
539
 
540
    /// hours
541
    typedef duration>   hours;
542
 
543
    /// time_point
544
    template
545
      struct time_point
546
      {
547
        typedef _Clock                                          clock;
548
        typedef _Dur                                            duration;
549
        typedef typename duration::rep                          rep;
550
        typedef typename duration::period                       period;
551
 
552
        constexpr time_point() : __d(duration::zero())
553
        { }
554
 
555
        constexpr explicit time_point(const duration& __dur)
556
        : __d(__dur)
557
        { }
558
 
559
        // conversions
560
        template
561
          constexpr time_point(const time_point& __t)
562
          : __d(__t.time_since_epoch())
563
          { }
564
 
565
        // observer
566
        constexpr duration
567
        time_since_epoch() const
568
        { return __d; }
569
 
570
        // arithmetic
571
        time_point&
572
        operator+=(const duration& __dur)
573
        {
574
          __d += __dur;
575
          return *this;
576
        }
577
 
578
        time_point&
579
        operator-=(const duration& __dur)
580
        {
581
          __d -= __dur;
582
          return *this;
583
        }
584
 
585
        // special values
586
        static constexpr time_point
587
        min()
588
        { return time_point(duration::min()); }
589
 
590
        static constexpr time_point
591
        max()
592
        { return time_point(duration::max()); }
593
 
594
      private:
595
        duration __d;
596
      };
597
 
598
    /// time_point_cast
599
    template
600
      constexpr typename enable_if<__is_duration<_ToDur>::value,
601
                                   time_point<_Clock, _ToDur>>::type
602
      time_point_cast(const time_point<_Clock, _Dur>& __t)
603
      {
604
        typedef time_point<_Clock, _ToDur>                      __time_point;
605
        return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
606
      }
607
 
608
    template
609
             typename _Rep2, typename _Period2>
610
      constexpr time_point<_Clock,
611
        typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
612
      operator+(const time_point<_Clock, _Dur1>& __lhs,
613
                const duration<_Rep2, _Period2>& __rhs)
614
      {
615
        typedef duration<_Rep2, _Period2>                        __dur2;
616
        typedef typename common_type<_Dur1,__dur2>::type      __ct;
617
        typedef time_point<_Clock, __ct>                      __time_point;
618
        return __time_point(__lhs.time_since_epoch() + __rhs);
619
      }
620
 
621
    template
622
             typename _Clock, typename _Dur2>
623
      constexpr time_point<_Clock,
624
        typename common_type, _Dur2>::type>
625
      operator+(const duration<_Rep1, _Period1>& __lhs,
626
                const time_point<_Clock, _Dur2>& __rhs)
627
      {
628
        typedef duration<_Rep1, _Period1>                        __dur1;
629
        typedef typename common_type<__dur1,_Dur2>::type      __ct;
630
        typedef time_point<_Clock, __ct>                      __time_point;
631
        return __time_point(__rhs.time_since_epoch() + __lhs);
632
      }
633
 
634
    template
635
             typename _Rep2, typename _Period2>
636
      constexpr time_point<_Clock,
637
        typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
638
      operator-(const time_point<_Clock, _Dur1>& __lhs,
639
                const duration<_Rep2, _Period2>& __rhs)
640
      {
641
        typedef duration<_Rep2, _Period2>                        __dur2;
642
        typedef typename common_type<_Dur1,__dur2>::type      __ct;
643
        typedef time_point<_Clock, __ct>                      __time_point;
644
        return __time_point(__lhs.time_since_epoch() -__rhs);
645
      }
646
 
647
    template
648
      constexpr typename common_type<_Dur1, _Dur2>::type
649
      operator-(const time_point<_Clock, _Dur1>& __lhs,
650
                const time_point<_Clock, _Dur2>& __rhs)
651
      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
652
 
653
    template
654
      constexpr bool
655
      operator==(const time_point<_Clock, _Dur1>& __lhs,
656
                 const time_point<_Clock, _Dur2>& __rhs)
657
      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
658
 
659
    template
660
      constexpr bool
661
      operator!=(const time_point<_Clock, _Dur1>& __lhs,
662
                 const time_point<_Clock, _Dur2>& __rhs)
663
      { return !(__lhs == __rhs); }
664
 
665
    template
666
      constexpr bool
667
      operator<(const time_point<_Clock, _Dur1>& __lhs,
668
                const time_point<_Clock, _Dur2>& __rhs)
669
      { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
670
 
671
    template
672
      constexpr bool
673
      operator<=(const time_point<_Clock, _Dur1>& __lhs,
674
                 const time_point<_Clock, _Dur2>& __rhs)
675
      { return !(__rhs < __lhs); }
676
 
677
    template
678
      constexpr bool
679
      operator>(const time_point<_Clock, _Dur1>& __lhs,
680
                const time_point<_Clock, _Dur2>& __rhs)
681
      { return __rhs < __lhs; }
682
 
683
    template
684
      constexpr bool
685
      operator>=(const time_point<_Clock, _Dur1>& __lhs,
686
                 const time_point<_Clock, _Dur2>& __rhs)
687
      { return !(__lhs < __rhs); }
688
 
689
    /// system_clock
690
    struct system_clock
691
    {
692
#ifdef _GLIBCXX_USE_CLOCK_REALTIME
693
      typedef chrono::nanoseconds                               duration;
694
#elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
695
      typedef chrono::microseconds                              duration;
696
#else
697
      typedef chrono::seconds                                   duration;
698
#endif
699
 
700
      typedef duration::rep                                     rep;
701
      typedef duration::period                                  period;
702
      typedef chrono::time_point        time_point;
703
 
704
      static_assert(system_clock::duration::min()
705
                    < system_clock::duration::zero(),
706
                    "a clock's minimum duration cannot be less than its epoch");
707
 
708
      static constexpr bool is_steady = false;
709
 
710
      static time_point
711
      now() noexcept;
712
 
713
      // Map to C API
714
      static std::time_t
715
      to_time_t(const time_point& __t) noexcept
716
      {
717
        return std::time_t(duration_cast
718
                           (__t.time_since_epoch()).count());
719
      }
720
 
721
      static time_point
722
      from_time_t(std::time_t __t) noexcept
723
      {
724
        typedef chrono::time_point      __from;
725
        return time_point_cast
726
               (__from(chrono::seconds(__t)));
727
      }
728
    };
729
 
730
#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
731
    /// steady_clock
732
    struct steady_clock
733
    {
734
      typedef chrono::nanoseconds                               duration;
735
      typedef duration::rep                                     rep;
736
      typedef duration::period                                  period;
737
      typedef chrono::time_point        time_point;
738
 
739
      static constexpr bool is_steady = true;
740
 
741
      static time_point
742
      now() noexcept;
743
    };
744
#else
745
    typedef system_clock steady_clock;
746
#endif
747
 
748
    typedef system_clock high_resolution_clock;
749
 
750
  _GLIBCXX_END_NAMESPACE_VERSION
751
  } // namespace chrono
752
 
753
  // @} group chrono
754
} // namespace
755
 
756
#endif //_GLIBCXX_USE_C99_STDINT_TR1
757
 
758
#endif // C++11
759
 
760
#endif //_GLIBCXX_CHRONO

powered by: WebSVN 2.1.0

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