OSDN Git Service

9d01a602dae6d8f68926ddc79c8e914668571667
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / allocator.h
1 // Allocators -*- C++ -*-
2
3 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 // 2011 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 /*
27  * Copyright (c) 1996-1997
28  * Silicon Graphics Computer Systems, Inc.
29  *
30  * Permission to use, copy, modify, distribute and sell this software
31  * and its documentation for any purpose is hereby granted without fee,
32  * provided that the above copyright notice appear in all copies and
33  * that both that copyright notice and this permission notice appear
34  * in supporting documentation.  Silicon Graphics makes no
35  * representations about the suitability of this software for any
36  * purpose.  It is provided "as is" without express or implied warranty.
37  */
38
39 /** @file bits/allocator.h
40  *  This is an internal header file, included by other library headers.
41  *  Do not attempt to use it directly. @headername{memory}
42  */
43
44 #ifndef _ALLOCATOR_H
45 #define _ALLOCATOR_H 1
46
47 // Define the base class to std::allocator.
48 #include <bits/c++allocator.h>
49
50 #ifdef __GXX_EXPERIMENTAL_CXX0X__
51 #include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
52 #endif
53
54 namespace std _GLIBCXX_VISIBILITY(default)
55 {
56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
57
58   /**
59    * @defgroup allocators Allocators
60    * @ingroup memory
61    *
62    * Classes encapsulating memory operations.
63    */
64
65   template<typename _Tp>
66     class allocator;
67
68   /// allocator<void> specialization.
69   template<>
70     class allocator<void>
71     {
72     public:
73       typedef size_t      size_type;
74       typedef ptrdiff_t   difference_type;
75       typedef void*       pointer;
76       typedef const void* const_pointer;
77       typedef void        value_type;
78
79       template<typename _Tp1>
80         struct rebind
81         { typedef allocator<_Tp1> other; };
82     };
83
84   /**
85    * @brief  The @a standard allocator, as per [20.4].
86    * @ingroup allocators
87    *
88    *  Further details:
89    *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
90    */
91   template<typename _Tp>
92     class allocator: public __glibcxx_base_allocator<_Tp>
93     {
94    public:
95       typedef size_t     size_type;
96       typedef ptrdiff_t  difference_type;
97       typedef _Tp*       pointer;
98       typedef const _Tp* const_pointer;
99       typedef _Tp&       reference;
100       typedef const _Tp& const_reference;
101       typedef _Tp        value_type;
102
103       template<typename _Tp1>
104         struct rebind
105         { typedef allocator<_Tp1> other; };
106
107       allocator() throw() { }
108
109       allocator(const allocator& __a) throw()
110       : __glibcxx_base_allocator<_Tp>(__a) { }
111
112       template<typename _Tp1>
113         allocator(const allocator<_Tp1>&) throw() { }
114
115       ~allocator() throw() { }
116
117       // Inherit everything else.
118     };
119
120   template<typename _T1, typename _T2>
121     inline bool
122     operator==(const allocator<_T1>&, const allocator<_T2>&)
123     { return true; }
124
125   template<typename _Tp>
126     inline bool
127     operator==(const allocator<_Tp>&, const allocator<_Tp>&)
128     { return true; }
129
130   template<typename _T1, typename _T2>
131     inline bool
132     operator!=(const allocator<_T1>&, const allocator<_T2>&)
133     { return false; }
134
135   template<typename _Tp>
136     inline bool
137     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
138     { return false; }
139
140   // Inhibit implicit instantiations for required instantiations,
141   // which are defined via explicit instantiations elsewhere.
142 #if _GLIBCXX_EXTERN_TEMPLATE
143   extern template class allocator<char>;
144   extern template class allocator<wchar_t>;
145 #endif
146
147   // Undefine.
148 #undef __glibcxx_base_allocator
149
150   // To implement Option 3 of DR 431.
151   template<typename _Alloc, bool = __is_empty(_Alloc)>
152     struct __alloc_swap
153     { static void _S_do_it(_Alloc&, _Alloc&) { } };
154
155   template<typename _Alloc>
156     struct __alloc_swap<_Alloc, false>
157     {
158       static void
159       _S_do_it(_Alloc& __one, _Alloc& __two)
160       {
161         // Precondition: swappable allocators.
162         if (__one != __two)
163           swap(__one, __two);
164       }
165     };
166
167   // Optimize for stateless allocators.
168   template<typename _Alloc, bool = __is_empty(_Alloc)>
169     struct __alloc_neq
170     {
171       static bool
172       _S_do_it(const _Alloc&, const _Alloc&)
173       { return false; }
174     };
175
176   template<typename _Alloc>
177     struct __alloc_neq<_Alloc, false>
178     {
179       static bool
180       _S_do_it(const _Alloc& __one, const _Alloc& __two)
181       { return __one != __two; }
182     };
183
184 #ifdef __GXX_EXPERIMENTAL_CXX0X__
185   // A very basic implementation for now.  In general we have to wait for
186   // the availability of the infrastructure described in N2983:  we should
187   // try when either T has a move constructor which cannot throw or T is
188   // CopyContructible.
189   // NB: This code doesn't properly belong here, we should find a more
190   // suited place common to std::vector and std::deque.
191   template<typename _Tp,
192            bool = __has_trivial_copy(typename _Tp::value_type)>
193     struct __shrink_to_fit
194     { static void _S_do_it(_Tp&) { } };
195
196   template<typename _Tp>
197     struct __shrink_to_fit<_Tp, true>
198     {
199       static void
200       _S_do_it(_Tp& __v)
201       {
202         __try
203           { _Tp(__v).swap(__v); }
204         __catch(...) { }
205       }
206     };
207
208
209   /// [allocator.tag]
210   struct allocator_arg_t { };
211
212   constexpr allocator_arg_t allocator_arg = allocator_arg_t();
213
214 _GLIBCXX_HAS_NESTED_TYPE(allocator_type)
215
216   template<typename _Tp, typename _Alloc,
217            bool = __has_allocator_type<_Tp>::value>
218     struct __uses_allocator_helper
219     : public false_type { };
220
221   template<typename _Tp, typename _Alloc>
222     struct __uses_allocator_helper<_Tp, _Alloc, true>
223     : public integral_constant<bool, is_convertible<_Alloc,
224                                      typename _Tp::allocator_type>::value>
225     { };
226
227   /// [allocator.uses.trait]
228   template<typename _Tp, typename _Alloc>
229     struct uses_allocator
230     : public integral_constant<bool,
231                                __uses_allocator_helper<_Tp, _Alloc>::value>
232     { };
233
234 #endif
235
236 _GLIBCXX_END_NAMESPACE_VERSION
237 } // namespace std
238
239 #endif