libstdc++
types_traits.hpp
Go to the documentation of this file.
1 // -*- C++ -*-
2 
3 // Copyright (C) 2005-2022 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 terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 3, or (at your option) any later
9 // version.
10 
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // 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 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
26 
27 // Permission to use, copy, modify, sell, and distribute this software
28 // is hereby granted without fee, provided that the above copyright
29 // notice appears in all copies, and that both that copyright notice
30 // and this permission notice appear in supporting documentation. None
31 // of the above authors, nor IBM Haifa Research Laboratories, make any
32 // representation about the suitability of this software for any
33 // purpose. It is provided "as is" without express or implied
34 // warranty.
35 
36 /**
37  * @file detail/types_traits.hpp
38  * Contains a traits class of types used by containers.
39  */
40 
41 #ifndef PB_DS_TYPES_TRAITS_HPP
42 #define PB_DS_TYPES_TRAITS_HPP
43 
44 #include <algorithm>
45 #include <utility>
48 #include <memory>
49 
50 namespace __gnu_pbds
51 {
52  namespace detail
53  {
54  /**
55  * @addtogroup traits Traits
56  * @{
57  */
58 
59  /// Primary template.
60  template<typename Key, typename Mapped>
62  {
63  static const bool __simple = is_simple<Key>::value
64  && is_simple<Mapped>::value;
65  typedef integral_constant<int, __simple> indicator;
66  };
67 
68  /// Specialization.
69  template<typename Key>
71  {
72  typedef integral_constant<int, is_simple<Key>::value> indicator;
73  };
74 
75 
76  /// Stored value.
77  template<typename _Tv>
78  struct stored_value
79  {
80  typedef _Tv value_type;
81  value_type m_value;
82  };
83 
84  /// Stored hash.
85  template<typename _Th>
86  struct stored_hash
87  {
88  typedef _Th hash_type;
89  hash_type m_hash;
90  };
91 
92  /// Primary template for representation of stored data.
93  /// Two types of data can be stored: value and hash.
94  template<typename _Tv, typename _Th, bool Store_Hash>
95  struct stored_data
96  : public stored_value<_Tv>, public stored_hash<_Th>
97  { };
98 
99  /// Specialization for representation of stored data of just value type.
100  template<typename _Tv, typename _Th>
101  struct stored_data<_Tv, _Th, false>
102  : public stored_value<_Tv>
103  { };
104 
105  /// Choose value_type to be a key/value pair or just a key.
106  template<typename Key, typename Mapped>
108  {
110  };
111 
112  /// Specialization for sets where the key is the value_type.
113  template<typename Key>
115  {
116  typedef Key type;
117  };
118 
119  /// Base class for conditionally defining a static data member.
120  template<typename Key, typename Mapped, typename _Alloc, bool Store_Hash>
122  { };
123 
124  /// Specialization that defines a static data member of type null_type.
125  template<typename Key,typename _Alloc, bool Store_Hash>
126  struct maybe_null_type<Key, null_type, _Alloc, Store_Hash>
127  {
128  static null_type s_null_type;
129  };
130 
131  template<typename Key,typename _Alloc, bool Store_Hash>
132  null_type
134 
135  /// Consistent API for accessing allocator-related types.
136  template<typename _Alloc, typename T>
138 #if __cplusplus >= 201103L
140  {
141  using reference = T&;
142  using const_reference = const T&;
143  };
144 #else
145  : _Alloc::template rebind<T>::other
146  {
147  typedef typename _Alloc::template rebind<T>::other allocator_type;
148  };
149 #endif
150 
151 
152  /// Traits for abstract types.
153  template<typename Key, typename Mapped, typename _Alloc, bool Store_Hash>
155  : public maybe_null_type<Key, Mapped, _Alloc, Store_Hash>
156  {
157  public:
158  typedef typename _Alloc::size_type size_type;
160  typedef Key key_type;
161  typedef Mapped mapped_type;
162 
163  private:
167 
169 
170  public:
171  typedef typename __rebind_ma::pointer mapped_pointer;
172  typedef typename __rebind_ma::const_pointer mapped_const_pointer;
173  typedef typename __rebind_ma::reference mapped_reference;
174  typedef typename __rebind_ma::const_reference mapped_const_reference;
175 
176  typedef typename __rebind_va::pointer pointer;
177  typedef typename __rebind_va::const_pointer const_pointer;
178  typedef typename __rebind_va::reference reference;
179  typedef typename __rebind_va::const_reference const_reference;
180 
182 
183  typedef typename __rebind_ka::pointer key_pointer;
184  typedef typename __rebind_ka::const_pointer key_const_pointer;
185  typedef typename __rebind_ka::reference key_reference;
186  typedef typename __rebind_ka::const_reference key_const_reference;
188  typedef integral_constant<int, Store_Hash> store_extra;
189  typedef typename __nothrowcopy::indicator no_throw_indicator;
190 
191  store_extra m_store_extra_indicator;
192  no_throw_indicator m_no_throw_copies_indicator;
193  };
194  ///@}
195  } // namespace detail
196 } // namespace __gnu_pbds
197 
198 #endif
Choose value_type to be a key/value pair or just a key.
Struct holding two objects of arbitrary type.
Traits for abstract types.
Base class for conditionally defining a static data member.
Consistent API for accessing allocator-related types.
GNU extensions for policy-based data structures for public use.
Represents no type, or absence of type, for template tricks.
Uniform interface to all allocator types.
Primary template for representation of stored data. Two types of data can be stored: value and hash...