OSDN Git Service

2011-05-28 Jonathan Wakely <jwakely.gcc@gmail.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / ext / extptr_allocator.h
1 // <extptr_allocator.h> -*- C++ -*-
2
3 // Copyright (C) 2008, 2009, 2010 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 /**
26  *  @file ext/extptr_allocator.h
27  *  This file is a GNU extension to the Standard C++ Library.
28  *
29  *  @author Bob Walters
30  *
31  * An example allocator which uses an alternative pointer type from
32  * bits/pointer.h.  Supports test cases which confirm container support
33  * for alternative pointers.
34  */
35
36 #ifndef _EXTPTR_ALLOCATOR_H
37 #define _EXTPTR_ALLOCATOR_H 1
38
39 #include <memory>
40 #include <limits>
41 #include <ext/pointer.h>
42
43 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
44 {
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47   /**
48    * @brief An example allocator which uses a non-standard pointer type.
49    * @ingroup allocators
50    *
51    * This allocator specifies that containers use a 'relative pointer' as it's
52    * pointer type.  (See ext/pointer.h)  Memory allocation in this example
53    * is still performed using std::allocator.
54    */
55   template<typename _Tp>
56     class _ExtPtr_allocator
57     {
58     public:
59       typedef std::size_t     size_type;
60       typedef std::ptrdiff_t  difference_type;
61
62       // Note the non-standard pointer types.
63       typedef _Pointer_adapter<_Relative_pointer_impl<_Tp> >       pointer;
64       typedef _Pointer_adapter<_Relative_pointer_impl<const _Tp> > 
65                                                              const_pointer;
66
67       typedef _Tp&       reference;
68       typedef const _Tp& const_reference;
69       typedef _Tp        value_type;
70
71       template<typename _Up>
72         struct rebind
73         { typedef _ExtPtr_allocator<_Up> other; };
74
75       _ExtPtr_allocator() throw() 
76       : _M_real_alloc() { }
77
78       _ExtPtr_allocator(const _ExtPtr_allocator &__rarg) throw()
79       : _M_real_alloc(__rarg._M_real_alloc) { }
80
81       template<typename _Up>
82         _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg) throw()
83         : _M_real_alloc(__rarg._M_getUnderlyingImp()) { }
84
85       ~_ExtPtr_allocator() throw()
86       { }
87
88       pointer address(reference __x) const
89       { return std::__addressof(__x); }
90
91       const_pointer address(const_reference __x) const
92       { return std::__addressof(__x); }
93
94       pointer allocate(size_type __n, void* __hint = 0)
95       { return _M_real_alloc.allocate(__n,__hint); }
96
97       void deallocate(pointer __p, size_type __n)
98       { _M_real_alloc.deallocate(__p.get(), __n); }
99
100       size_type max_size() const throw()
101       { return std::numeric_limits<size_type>::max() / sizeof(_Tp); }
102
103 #ifdef __GXX_EXPERIMENTAL_CXX0X__
104       template<typename _Up, typename... _Args>
105         void
106         construct(_Up* __p, _Args&&... __args)
107         { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
108
109       template<typename _Up>
110         void 
111         destroy(_Up* __p)
112         { __p->~_Up(); }
113 #else
114       void construct(pointer __p, const _Tp& __val)
115       { ::new(__p.get()) _Tp(__val); }
116
117       void destroy(pointer __p)
118       { __p->~_Tp(); }
119 #endif
120
121       template<typename _Up>
122         inline bool
123         operator==(const _ExtPtr_allocator<_Up>& __rarg)
124         { return _M_real_alloc == __rarg._M_getUnderlyingImp(); }
125
126       inline bool
127       operator==(const _ExtPtr_allocator& __rarg)
128       { return _M_real_alloc == __rarg._M_real_alloc; }
129
130       template<typename _Up>
131         inline bool
132         operator!=(const _ExtPtr_allocator<_Up>& __rarg)
133         { return _M_real_alloc != __rarg._M_getUnderlyingImp(); }
134
135       inline bool
136       operator!=(const _ExtPtr_allocator& __rarg)
137       { return _M_real_alloc != __rarg._M_real_alloc; }
138
139       template<typename _Up>
140         inline friend void
141         swap(_ExtPtr_allocator<_Up>&, _ExtPtr_allocator<_Up>&);
142
143       // A method specific to this implementation.
144       const std::allocator<_Tp>&
145       _M_getUnderlyingImp() const
146       { return _M_real_alloc; }
147
148     private:
149       std::allocator<_Tp>  _M_real_alloc;
150     };
151
152   // _ExtPtr_allocator<void> specialization.
153   template<>
154     class _ExtPtr_allocator<void>
155     {
156     public:
157       typedef std::size_t      size_type;
158       typedef std::ptrdiff_t   difference_type;
159       typedef void             value_type;
160
161       // Note the non-standard pointer types
162       typedef _Pointer_adapter<_Relative_pointer_impl<void> >       pointer;
163       typedef _Pointer_adapter<_Relative_pointer_impl<const void> >
164                                                               const_pointer;
165
166       template<typename _Up>
167         struct rebind
168         { typedef _ExtPtr_allocator<_Up> other; };
169
170     private:
171       std::allocator<void>  _M_real_alloc;
172     };
173
174   template<typename _Tp>
175     inline void
176     swap(_ExtPtr_allocator<_Tp>& __larg, _ExtPtr_allocator<_Tp>& __rarg)
177     {
178       std::allocator<_Tp> __tmp( __rarg._M_real_alloc );
179       __rarg._M_real_alloc = __larg._M_real_alloc;
180       __larg._M_real_alloc = __tmp;
181     }
182
183 _GLIBCXX_END_NAMESPACE_VERSION
184 } // namespace
185
186 #endif /* _EXTPTR_ALLOCATOR_H */