1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
/* Copyright 2006-2008 Joaquin M Lopez Munoz.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* See http://www.boost.org/libs/flyweight for library home page.
*/
#ifndef BOOST_FLYWEIGHT_KEY_VALUE_HPP
#define BOOST_FLYWEIGHT_KEY_VALUE_HPP
#if defined(_MSC_VER)&&(_MSC_VER>=1200)
#pragma once
#endif
#include <boost/flyweight/detail/value_tag.hpp>
#include <boost/flyweight/key_value_fwd.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/is_same.hpp>
#include <new>
/* key-value policy: flywewight lookup is based on Key, which also serves
* to construct Value only when needed (new factory entry). key_value is
* used to avoid the construction of temporary values when such construction
* is expensive.
* Optionally, KeyFromValue extracts the key from a value, which
* is needed in expressions like this:
*
* typedef flyweight<key_value<Key,Value> > fw_t;
* fw_t fw;
* Value v;
* fw=v; // no key explicitly given
*
* If no KeyFromValue is provided, this latter expression fails to compile.
*/
namespace boost{
namespace flyweights{
namespace detail{
template<typename Key,typename Value,typename KeyFromValue>
struct optimized_key_value:value_marker
{
typedef Key key_type;
typedef Value value_type;
class rep_type
{
public:
/* template ctors */
#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit rep_type
#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \
:value_ptr(0) \
{ \
new(spc_ptr())key_type(BOOST_PP_ENUM_PARAMS(n,t)); \
}
#include <boost/flyweight/detail/perfect_fwd.hpp>
rep_type(const value_type& x):value_ptr(&x){}
rep_type(const rep_type& x):value_ptr(x.value_ptr)
{
if(!x.value_ptr)new(key_ptr())key_type(*x.key_ptr());
}
~rep_type()
{
if(!value_ptr) key_ptr()->~key_type();
else if(value_cted())value_ptr->~value_type();
}
operator const key_type&()const
{
if(value_ptr)return key_from_value(*value_ptr);
else return *key_ptr();
}
operator const value_type&()const
{
/* This is always called after construct_value() or copy_value(),
* so we access spc directly rather than through value_ptr to
* save us an indirection.
*/
return *static_cast<value_type*>(spc_ptr());
}
private:
friend struct optimized_key_value;
void* spc_ptr()const{return static_cast<void*>(&spc);}
bool value_cted()const{return value_ptr==spc_ptr();}
key_type* key_ptr()const
{
return static_cast<key_type*>(static_cast<void*>(&spc));
}
static const key_type& key_from_value(const value_type& x)
{
KeyFromValue k;
return k(x);
}
void construct_value()const
{
if(!value_cted()){
/* value_ptr must be ==0, oherwise copy_value would have been called */
key_type k(*key_ptr());
key_ptr()->~key_type();
value_ptr= /* guarantees key won't be re-dted at ~rep_type if the */
static_cast<value_type*>(spc_ptr())+1; /* next statement throws */
value_ptr=new(spc_ptr())value_type(k);
}
}
void copy_value()const
{
if(!value_cted())value_ptr=new(spc_ptr())value_type(*value_ptr);
}
mutable typename boost::aligned_storage<
(sizeof(key_type)>sizeof(value_type))?
sizeof(key_type):sizeof(value_type),
(boost::alignment_of<key_type>::value >
boost::alignment_of<value_type>::value)?
boost::alignment_of<key_type>::value:
boost::alignment_of<value_type>::value
>::type spc;
mutable const value_type* value_ptr;
};
static void construct_value(const rep_type& r)
{
r.construct_value();
}
static void copy_value(const rep_type& r)
{
r.copy_value();
}
};
template<typename Key,typename Value>
struct regular_key_value:value_marker
{
typedef Key key_type;
typedef Value value_type;
class rep_type
{
public:
/* template ctors */
#define BOOST_FLYWEIGHT_PERFECT_FWD_NAME explicit rep_type
#define BOOST_FLYWEIGHT_PERFECT_FWD_BODY(n) \
:key(BOOST_PP_ENUM_PARAMS(n,t)),value_ptr(0){}
#include <boost/flyweight/detail/perfect_fwd.hpp>
rep_type(const value_type& x):key(no_key_from_value_failure()){}
rep_type(const rep_type& x):key(x.key),value_ptr(0){}
~rep_type()
{
if(value_ptr)value_ptr->~value_type();
}
operator const key_type&()const{return key;}
operator const value_type&()const
{
/* This is always called after construct_value(),so we access spc
* directly rather than through value_ptr to save us an indirection.
*/
return *static_cast<value_type*>(spc_ptr());
}
private:
friend struct regular_key_value;
void* spc_ptr()const{return static_cast<void*>(&spc);}
struct no_key_from_value_failure
{
BOOST_MPL_ASSERT_MSG(
false,
NO_KEY_FROM_VALUE_CONVERSION_PROVIDED,
(key_type,value_type));
operator const key_type&()const;
};
void construct_value()const
{
if(!value_ptr)value_ptr=new(spc_ptr())value_type(key);
}
key_type key;
mutable typename boost::aligned_storage<
sizeof(value_type),
boost::alignment_of<value_type>::value
>::type spc;
mutable const value_type* value_ptr;
};
static void construct_value(const rep_type& r)
{
r.construct_value();
}
static void copy_value(const rep_type&){}
};
} /* namespace flyweights::detail */
template<typename Key,typename Value,typename KeyFromValue>
struct key_value:
mpl::if_<
is_same<KeyFromValue,no_key_from_value>,
detail::regular_key_value<Key,Value>,
detail::optimized_key_value<Key,Value,KeyFromValue>
>::type
{};
} /* namespace flyweights */
} /* namespace boost */
#endif
|
