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/] [shared_ptr.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// shared_ptr and weak_ptr implementation -*- C++ -*-
2
 
3
// Copyright (C) 2007-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
// <http://www.gnu.org/licenses/>.
24
 
25
// GCC Note: Based on files from version 1.32.0 of the Boost library.
26
 
27
//  shared_count.hpp
28
//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29
 
30
//  shared_ptr.hpp
31
//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32
//  Copyright (C) 2001, 2002, 2003 Peter Dimov
33
 
34
//  weak_ptr.hpp
35
//  Copyright (C) 2001, 2002, 2003 Peter Dimov
36
 
37
//  enable_shared_from_this.hpp
38
//  Copyright (C) 2002 Peter Dimov
39
 
40
// Distributed under the Boost Software License, Version 1.0. (See
41
// accompanying file LICENSE_1_0.txt or copy at
42
// http://www.boost.org/LICENSE_1_0.txt)
43
 
44
/** @file bits/shared_ptr.h
45
 *  This is an internal header file, included by other library headers.
46
 *  Do not attempt to use it directly. @headername{memory}
47
 */
48
 
49
#ifndef _SHARED_PTR_H
50
#define _SHARED_PTR_H 1
51
 
52
#include <bits/shared_ptr_base.h>
53
 
54
namespace std _GLIBCXX_VISIBILITY(default)
55
{
56
_GLIBCXX_BEGIN_NAMESPACE_VERSION
57
 
58
  /**
59
   * @addtogroup pointer_abstractions
60
   * @{
61
   */
62
 
63
  /// 2.2.3.7 shared_ptr I/O
64
  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
65
    inline std::basic_ostream<_Ch, _Tr>&
66
    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
67
               const __shared_ptr<_Tp, _Lp>& __p)
68
    {
69
      __os << __p.get();
70
      return __os;
71
    }
72
 
73
  /// 2.2.3.10 shared_ptr get_deleter (experimental)
74
  template<typename _Del, typename _Tp, _Lock_policy _Lp>
75
    inline _Del*
76
    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
77
    {
78
#ifdef __GXX_RTTI
79
      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
80
#else
81
      return 0;
82
#endif
83
    }
84
 
85
 
86
  /**
87
   *  @brief  A smart pointer with reference-counted copy semantics.
88
   *
89
   *  The object pointed to is deleted when the last shared_ptr pointing to
90
   *  it is destroyed or reset.
91
  */
92
  template<typename _Tp>
93
    class shared_ptr : public __shared_ptr<_Tp>
94
    {
95
    public:
96
      /**
97
       *  @brief  Construct an empty %shared_ptr.
98
       *  @post   use_count()==0 && get()==0
99
       */
100
      constexpr shared_ptr() noexcept
101
      : __shared_ptr<_Tp>() { }
102
 
103
      shared_ptr(const shared_ptr&) noexcept = default;
104
 
105
      /**
106
       *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
107
       *  @param  __p  A pointer that is convertible to element_type*.
108
       *  @post   use_count() == 1 && get() == __p
109
       *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
110
       */
111
      template<typename _Tp1>
112
        explicit shared_ptr(_Tp1* __p)
113
        : __shared_ptr<_Tp>(__p) { }
114
 
115
      /**
116
       *  @brief  Construct a %shared_ptr that owns the pointer @a __p
117
       *          and the deleter @a __d.
118
       *  @param  __p  A pointer.
119
       *  @param  __d  A deleter.
120
       *  @post   use_count() == 1 && get() == __p
121
       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
122
       *
123
       *  Requirements: _Deleter's copy constructor and destructor must
124
       *  not throw
125
       *
126
       *  __shared_ptr will release __p by calling __d(__p)
127
       */
128
      template<typename _Tp1, typename _Deleter>
129
        shared_ptr(_Tp1* __p, _Deleter __d)
130
        : __shared_ptr<_Tp>(__p, __d) { }
131
 
132
      /**
133
       *  @brief  Construct a %shared_ptr that owns a null pointer
134
       *          and the deleter @a __d.
135
       *  @param  __p  A null pointer constant.
136
       *  @param  __d  A deleter.
137
       *  @post   use_count() == 1 && get() == __p
138
       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
139
       *
140
       *  Requirements: _Deleter's copy constructor and destructor must
141
       *  not throw
142
       *
143
       *  The last owner will call __d(__p)
144
       */
145
      template<typename _Deleter>
146
        shared_ptr(nullptr_t __p, _Deleter __d)
147
        : __shared_ptr<_Tp>(__p, __d) { }
148
 
149
      /**
150
       *  @brief  Construct a %shared_ptr that owns the pointer @a __p
151
       *          and the deleter @a __d.
152
       *  @param  __p  A pointer.
153
       *  @param  __d  A deleter.
154
       *  @param  __a  An allocator.
155
       *  @post   use_count() == 1 && get() == __p
156
       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
157
       *
158
       *  Requirements: _Deleter's copy constructor and destructor must
159
       *  not throw _Alloc's copy constructor and destructor must not
160
       *  throw.
161
       *
162
       *  __shared_ptr will release __p by calling __d(__p)
163
       */
164
      template<typename _Tp1, typename _Deleter, typename _Alloc>
165
        shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
166
        : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
167
 
168
      /**
169
       *  @brief  Construct a %shared_ptr that owns a null pointer
170
       *          and the deleter @a __d.
171
       *  @param  __p  A null pointer constant.
172
       *  @param  __d  A deleter.
173
       *  @param  __a  An allocator.
174
       *  @post   use_count() == 1 && get() == __p
175
       *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
176
       *
177
       *  Requirements: _Deleter's copy constructor and destructor must
178
       *  not throw _Alloc's copy constructor and destructor must not
179
       *  throw.
180
       *
181
       *  The last owner will call __d(__p)
182
       */
183
      template<typename _Deleter, typename _Alloc>
184
        shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
185
        : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
186
 
187
      // Aliasing constructor
188
 
189
      /**
190
       *  @brief  Constructs a %shared_ptr instance that stores @a __p
191
       *          and shares ownership with @a __r.
192
       *  @param  __r  A %shared_ptr.
193
       *  @param  __p  A pointer that will remain valid while @a *__r is valid.
194
       *  @post   get() == __p && use_count() == __r.use_count()
195
       *
196
       *  This can be used to construct a @c shared_ptr to a sub-object
197
       *  of an object managed by an existing @c shared_ptr.
198
       *
199
       * @code
200
       * shared_ptr< pair<int,int> > pii(new pair<int,int>());
201
       * shared_ptr<int> pi(pii, &pii->first);
202
       * assert(pii.use_count() == 2);
203
       * @endcode
204
       */
205
      template<typename _Tp1>
206
        shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
207
        : __shared_ptr<_Tp>(__r, __p) { }
208
 
209
      /**
210
       *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
211
       *          otherwise construct a %shared_ptr that shares ownership
212
       *          with @a __r.
213
       *  @param  __r  A %shared_ptr.
214
       *  @post   get() == __r.get() && use_count() == __r.use_count()
215
       */
216
      template<typename _Tp1, typename = typename
217
               std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
218
        shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
219
        : __shared_ptr<_Tp>(__r) { }
220
 
221
      /**
222
       *  @brief  Move-constructs a %shared_ptr instance from @a __r.
223
       *  @param  __r  A %shared_ptr rvalue.
224
       *  @post   *this contains the old value of @a __r, @a __r is empty.
225
       */
226
      shared_ptr(shared_ptr&& __r) noexcept
227
      : __shared_ptr<_Tp>(std::move(__r)) { }
228
 
229
      /**
230
       *  @brief  Move-constructs a %shared_ptr instance from @a __r.
231
       *  @param  __r  A %shared_ptr rvalue.
232
       *  @post   *this contains the old value of @a __r, @a __r is empty.
233
       */
234
      template<typename _Tp1, typename = typename
235
               std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
236
        shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
237
        : __shared_ptr<_Tp>(std::move(__r)) { }
238
 
239
      /**
240
       *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
241
       *          and stores a copy of the pointer stored in @a __r.
242
       *  @param  __r  A weak_ptr.
243
       *  @post   use_count() == __r.use_count()
244
       *  @throw  bad_weak_ptr when __r.expired(),
245
       *          in which case the constructor has no effect.
246
       */
247
      template<typename _Tp1>
248
        explicit shared_ptr(const weak_ptr<_Tp1>& __r)
249
        : __shared_ptr<_Tp>(__r) { }
250
 
251
#if _GLIBCXX_USE_DEPRECATED
252
      template<typename _Tp1>
253
        shared_ptr(std::auto_ptr<_Tp1>&& __r);
254
#endif
255
 
256
      template<typename _Tp1, typename _Del>
257
        shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
258
        : __shared_ptr<_Tp>(std::move(__r)) { }
259
 
260
      /**
261
       *  @brief  Construct an empty %shared_ptr.
262
       *  @param  __p  A null pointer constant.
263
       *  @post   use_count() == 0 && get() == nullptr
264
       */
265
      constexpr shared_ptr(nullptr_t __p) noexcept
266
      : __shared_ptr<_Tp>(__p) { }
267
 
268
      shared_ptr& operator=(const shared_ptr&) noexcept = default;
269
 
270
      template<typename _Tp1>
271
        shared_ptr&
272
        operator=(const shared_ptr<_Tp1>& __r) noexcept
273
        {
274
          this->__shared_ptr<_Tp>::operator=(__r);
275
          return *this;
276
        }
277
 
278
#if _GLIBCXX_USE_DEPRECATED
279
      template<typename _Tp1>
280
        shared_ptr&
281
        operator=(std::auto_ptr<_Tp1>&& __r)
282
        {
283
          this->__shared_ptr<_Tp>::operator=(std::move(__r));
284
          return *this;
285
        }
286
#endif
287
 
288
      shared_ptr&
289
      operator=(shared_ptr&& __r) noexcept
290
      {
291
        this->__shared_ptr<_Tp>::operator=(std::move(__r));
292
        return *this;
293
      }
294
 
295
      template<class _Tp1>
296
        shared_ptr&
297
        operator=(shared_ptr<_Tp1>&& __r) noexcept
298
        {
299
          this->__shared_ptr<_Tp>::operator=(std::move(__r));
300
          return *this;
301
        }
302
 
303
      template<typename _Tp1, typename _Del>
304
        shared_ptr&
305
        operator=(std::unique_ptr<_Tp1, _Del>&& __r)
306
        {
307
          this->__shared_ptr<_Tp>::operator=(std::move(__r));
308
          return *this;
309
        }
310
 
311
    private:
312
      // This constructor is non-standard, it is used by allocate_shared.
313
      template<typename _Alloc, typename... _Args>
314
        shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
315
                   _Args&&... __args)
316
        : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
317
        { }
318
 
319
      template<typename _Tp1, typename _Alloc, typename... _Args>
320
        friend shared_ptr<_Tp1>
321
        allocate_shared(const _Alloc& __a, _Args&&... __args);
322
    };
323
 
324
  // 20.7.2.2.7 shared_ptr comparisons
325
  template<typename _Tp1, typename _Tp2>
326
    inline bool
327
    operator==(const shared_ptr<_Tp1>& __a,
328
               const shared_ptr<_Tp2>& __b) noexcept
329
    { return __a.get() == __b.get(); }
330
 
331
  template<typename _Tp>
332
    inline bool
333
    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
334
    { return !__a; }
335
 
336
  template<typename _Tp>
337
    inline bool
338
    operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
339
    { return !__a; }
340
 
341
  template<typename _Tp1, typename _Tp2>
342
    inline bool
343
    operator!=(const shared_ptr<_Tp1>& __a,
344
               const shared_ptr<_Tp2>& __b) noexcept
345
    { return __a.get() != __b.get(); }
346
 
347
  template<typename _Tp>
348
    inline bool
349
    operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
350
    { return (bool)__a; }
351
 
352
  template<typename _Tp>
353
    inline bool
354
    operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
355
    { return (bool)__a; }
356
 
357
  template<typename _Tp1, typename _Tp2>
358
    inline bool
359
    operator<(const shared_ptr<_Tp1>& __a,
360
              const shared_ptr<_Tp2>& __b) noexcept
361
    {
362
      typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
363
      return std::less<_CT>()(__a.get(), __b.get());
364
    }
365
 
366
  template<typename _Tp>
367
    inline bool
368
    operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
369
    { return std::less<_Tp*>()(__a.get(), nullptr); }
370
 
371
  template<typename _Tp>
372
    inline bool
373
    operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
374
    { return std::less<_Tp*>()(nullptr, __a.get()); }
375
 
376
  template<typename _Tp1, typename _Tp2>
377
    inline bool
378
    operator<=(const shared_ptr<_Tp1>& __a,
379
               const shared_ptr<_Tp2>& __b) noexcept
380
    { return !(__b < __a); }
381
 
382
  template<typename _Tp>
383
    inline bool
384
    operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
385
    { return !(nullptr < __a); }
386
 
387
  template<typename _Tp>
388
    inline bool
389
    operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
390
    { return !(__a < nullptr); }
391
 
392
  template<typename _Tp1, typename _Tp2>
393
    inline bool
394
    operator>(const shared_ptr<_Tp1>& __a,
395
              const shared_ptr<_Tp2>& __b) noexcept
396
    { return (__b < __a); }
397
 
398
  template<typename _Tp>
399
    inline bool
400
    operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
401
    { return std::less<_Tp*>()(nullptr, __a.get()); }
402
 
403
  template<typename _Tp>
404
    inline bool
405
    operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
406
    { return std::less<_Tp*>()(__a.get(), nullptr); }
407
 
408
  template<typename _Tp1, typename _Tp2>
409
    inline bool
410
    operator>=(const shared_ptr<_Tp1>& __a,
411
               const shared_ptr<_Tp2>& __b) noexcept
412
    { return !(__a < __b); }
413
 
414
  template<typename _Tp>
415
    inline bool
416
    operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
417
    { return !(__a < nullptr); }
418
 
419
  template<typename _Tp>
420
    inline bool
421
    operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
422
    { return !(nullptr < __a); }
423
 
424
  template<typename _Tp>
425
    struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
426
    { };
427
 
428
  // 20.7.2.2.8 shared_ptr specialized algorithms.
429
  template<typename _Tp>
430
    inline void
431
    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
432
    { __a.swap(__b); }
433
 
434
  // 20.7.2.2.9 shared_ptr casts.
435
  template<typename _Tp, typename _Tp1>
436
    inline shared_ptr<_Tp>
437
    static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
438
    { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
439
 
440
  template<typename _Tp, typename _Tp1>
441
    inline shared_ptr<_Tp>
442
    const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
443
    { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
444
 
445
  template<typename _Tp, typename _Tp1>
446
    inline shared_ptr<_Tp>
447
    dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
448
    {
449
      if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
450
        return shared_ptr<_Tp>(__r, __p);
451
      return shared_ptr<_Tp>();
452
    }
453
 
454
 
455
  /**
456
   *  @brief  A smart pointer with weak semantics.
457
   *
458
   *  With forwarding constructors and assignment operators.
459
   */
460
  template<typename _Tp>
461
    class weak_ptr : public __weak_ptr<_Tp>
462
    {
463
    public:
464
      constexpr weak_ptr() noexcept
465
      : __weak_ptr<_Tp>() { }
466
 
467
      template<typename _Tp1, typename = typename
468
               std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
469
        weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
470
        : __weak_ptr<_Tp>(__r) { }
471
 
472
      template<typename _Tp1, typename = typename
473
               std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
474
        weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
475
        : __weak_ptr<_Tp>(__r) { }
476
 
477
      template<typename _Tp1>
478
        weak_ptr&
479
        operator=(const weak_ptr<_Tp1>& __r) noexcept
480
        {
481
          this->__weak_ptr<_Tp>::operator=(__r);
482
          return *this;
483
        }
484
 
485
      template<typename _Tp1>
486
        weak_ptr&
487
        operator=(const shared_ptr<_Tp1>& __r) noexcept
488
        {
489
          this->__weak_ptr<_Tp>::operator=(__r);
490
          return *this;
491
        }
492
 
493
      shared_ptr<_Tp>
494
      lock() const noexcept
495
      {
496
#ifdef __GTHREADS
497
        if (this->expired())
498
          return shared_ptr<_Tp>();
499
 
500
        __try
501
          {
502
            return shared_ptr<_Tp>(*this);
503
          }
504
        __catch(const bad_weak_ptr&)
505
          {
506
            return shared_ptr<_Tp>();
507
          }
508
#else
509
        return this->expired() ? shared_ptr<_Tp>() : shared_ptr<_Tp>(*this);
510
#endif
511
      }
512
    };
513
 
514
  // 20.7.2.3.6 weak_ptr specialized algorithms.
515
  template<typename _Tp>
516
    inline void
517
    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
518
    { __a.swap(__b); }
519
 
520
 
521
  /// Primary template owner_less
522
  template<typename _Tp>
523
    struct owner_less;
524
 
525
  /// Partial specialization of owner_less for shared_ptr.
526
  template<typename _Tp>
527
    struct owner_less<shared_ptr<_Tp>>
528
    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
529
    { };
530
 
531
  /// Partial specialization of owner_less for weak_ptr.
532
  template<typename _Tp>
533
    struct owner_less<weak_ptr<_Tp>>
534
    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
535
    { };
536
 
537
  /**
538
   *  @brief Base class allowing use of member function shared_from_this.
539
   */
540
  template<typename _Tp>
541
    class enable_shared_from_this
542
    {
543
    protected:
544
      constexpr enable_shared_from_this() noexcept { }
545
 
546
      enable_shared_from_this(const enable_shared_from_this&) noexcept { }
547
 
548
      enable_shared_from_this&
549
      operator=(const enable_shared_from_this&) noexcept
550
      { return *this; }
551
 
552
      ~enable_shared_from_this() { }
553
 
554
    public:
555
      shared_ptr<_Tp>
556
      shared_from_this()
557
      { return shared_ptr<_Tp>(this->_M_weak_this); }
558
 
559
      shared_ptr<const _Tp>
560
      shared_from_this() const
561
      { return shared_ptr<const _Tp>(this->_M_weak_this); }
562
 
563
    private:
564
      template<typename _Tp1>
565
        void
566
        _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
567
        { _M_weak_this._M_assign(__p, __n); }
568
 
569
      template<typename _Tp1>
570
        friend void
571
        __enable_shared_from_this_helper(const __shared_count<>& __pn,
572
                                         const enable_shared_from_this* __pe,
573
                                         const _Tp1* __px) noexcept
574
        {
575
          if (__pe != 0)
576
            __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
577
        }
578
 
579
      mutable weak_ptr<_Tp>  _M_weak_this;
580
    };
581
 
582
  /**
583
   *  @brief  Create an object that is owned by a shared_ptr.
584
   *  @param  __a     An allocator.
585
   *  @param  __args  Arguments for the @a _Tp object's constructor.
586
   *  @return A shared_ptr that owns the newly created object.
587
   *  @throw  An exception thrown from @a _Alloc::allocate or from the
588
   *          constructor of @a _Tp.
589
   *
590
   *  A copy of @a __a will be used to allocate memory for the shared_ptr
591
   *  and the new object.
592
   */
593
  template<typename _Tp, typename _Alloc, typename... _Args>
594
    inline shared_ptr<_Tp>
595
    allocate_shared(const _Alloc& __a, _Args&&... __args)
596
    {
597
      return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
598
                             std::forward<_Args>(__args)...);
599
    }
600
 
601
  /**
602
   *  @brief  Create an object that is owned by a shared_ptr.
603
   *  @param  __args  Arguments for the @a _Tp object's constructor.
604
   *  @return A shared_ptr that owns the newly created object.
605
   *  @throw  std::bad_alloc, or an exception thrown from the
606
   *          constructor of @a _Tp.
607
   */
608
  template<typename _Tp, typename... _Args>
609
    inline shared_ptr<_Tp>
610
    make_shared(_Args&&... __args)
611
    {
612
      typedef typename std::remove_const<_Tp>::type _Tp_nc;
613
      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
614
                                       std::forward<_Args>(__args)...);
615
    }
616
 
617
  /// std::hash specialization for shared_ptr.
618
  template<typename _Tp>
619
    struct hash<shared_ptr<_Tp>>
620
    : public __hash_base<size_t, shared_ptr<_Tp>>
621
    {
622
      size_t
623
      operator()(const shared_ptr<_Tp>& __s) const noexcept
624
      { return std::hash<_Tp*>()(__s.get()); }
625
    };
626
 
627
  // @} group pointer_abstractions
628
 
629
_GLIBCXX_END_NAMESPACE_VERSION
630
} // namespace
631
 
632
#endif // _SHARED_PTR_H

powered by: WebSVN 2.1.0

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