Fixes for VS 2008
[dyninst.git] / external / boost / any.hpp
1 // See http://www.boost.org/libs/any for Documentation.\r
2 \r
3 #ifndef BOOST_ANY_INCLUDED\r
4 #define BOOST_ANY_INCLUDED\r
5 \r
6 // what:  variant type boost::any\r
7 // who:   contributed by Kevlin Henney,\r
8 //        with features contributed and bugs found by\r
9 //        Ed Brey, Mark Rodgers, Peter Dimov, and James Curran\r
10 // when:  July 2001\r
11 // where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95\r
12 \r
13 #include <algorithm>\r
14 #include <typeinfo>\r
15 \r
16 #include "boost/config.hpp"\r
17 #include <boost/type_traits/remove_reference.hpp>\r
18 #include <boost/type_traits/is_reference.hpp>\r
19 #include <boost/throw_exception.hpp>\r
20 #include <boost/static_assert.hpp>\r
21 \r
22 namespace boost\r
23 {\r
24     class any\r
25     {\r
26     public: // structors\r
27 \r
28         any()\r
29           : content(0)\r
30         {\r
31         }\r
32 \r
33         template<typename ValueType>\r
34         any(const ValueType & value)\r
35           : content(new holder<ValueType>(value))\r
36         {\r
37         }\r
38 \r
39         any(const any & other)\r
40           : content(other.content ? other.content->clone() : 0)\r
41         {\r
42         }\r
43 \r
44         ~any()\r
45         {\r
46             delete content;\r
47         }\r
48 \r
49     public: // modifiers\r
50 \r
51         any & swap(any & rhs)\r
52         {\r
53             std::swap(content, rhs.content);\r
54             return *this;\r
55         }\r
56 \r
57         template<typename ValueType>\r
58         any & operator=(const ValueType & rhs)\r
59         {\r
60             any(rhs).swap(*this);\r
61             return *this;\r
62         }\r
63 \r
64         any & operator=(const any & rhs)\r
65         {\r
66             any(rhs).swap(*this);\r
67             return *this;\r
68         }\r
69 \r
70     public: // queries\r
71 \r
72         bool empty() const\r
73         {\r
74             return !content;\r
75         }\r
76 \r
77         const std::type_info & type() const\r
78         {\r
79             return content ? content->type() : typeid(void);\r
80         }\r
81 \r
82 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\r
83     private: // types\r
84 #else\r
85     public: // types (public so any_cast can be non-friend)\r
86 #endif\r
87 \r
88         class placeholder\r
89         {\r
90         public: // structors\r
91 \r
92             virtual ~placeholder()\r
93             {\r
94             }\r
95 \r
96         public: // queries\r
97 \r
98             virtual const std::type_info & type() const = 0;\r
99 \r
100             virtual placeholder * clone() const = 0;\r
101 \r
102         };\r
103 \r
104         template<typename ValueType>\r
105         class holder : public placeholder\r
106         {\r
107         public: // structors\r
108 \r
109             holder(const ValueType & value)\r
110               : held(value)\r
111             {\r
112             }\r
113 \r
114         public: // queries\r
115 \r
116             virtual const std::type_info & type() const\r
117             {\r
118                 return typeid(ValueType);\r
119             }\r
120 \r
121             virtual placeholder * clone() const\r
122             {\r
123                 return new holder(held);\r
124             }\r
125 \r
126         public: // representation\r
127 \r
128             ValueType held;\r
129 \r
130         private: // intentionally left unimplemented\r
131             holder & operator=(const holder &);\r
132         };\r
133 \r
134 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS\r
135 \r
136     private: // representation\r
137 \r
138         template<typename ValueType>\r
139         friend ValueType * any_cast(any *);\r
140 \r
141         template<typename ValueType>\r
142         friend ValueType * unsafe_any_cast(any *);\r
143 \r
144 #else\r
145 \r
146     public: // representation (public so any_cast can be non-friend)\r
147 \r
148 #endif\r
149 \r
150         placeholder * content;\r
151 \r
152     };\r
153 \r
154     class bad_any_cast : public std::bad_cast\r
155     {\r
156     public:\r
157         virtual const char * what() const throw()\r
158         {\r
159             return "boost::bad_any_cast: "\r
160                    "failed conversion using boost::any_cast";\r
161         }\r
162     };\r
163 \r
164     template<typename ValueType>\r
165     ValueType * any_cast(any * operand)\r
166     {\r
167         return operand && operand->type() == typeid(ValueType)\r
168                     ? &static_cast<any::holder<ValueType> *>(operand->content)->held\r
169                     : 0;\r
170     }\r
171 \r
172     template<typename ValueType>\r
173     inline const ValueType * any_cast(const any * operand)\r
174     {\r
175         return any_cast<ValueType>(const_cast<any *>(operand));\r
176     }\r
177 \r
178     template<typename ValueType>\r
179     ValueType any_cast(any & operand)\r
180     {\r
181         typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;\r
182 \r
183 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\r
184         // If 'nonref' is still reference type, it means the user has not\r
185         // specialized 'remove_reference'.\r
186 \r
187         // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro\r
188         // to generate specialization of remove_reference for your class\r
189         // See type traits library documentation for details\r
190         BOOST_STATIC_ASSERT(!is_reference<nonref>::value);\r
191 #endif\r
192 \r
193         nonref * result = any_cast<nonref>(&operand);\r
194         if(!result)\r
195             boost::throw_exception(bad_any_cast());\r
196         return *result;\r
197     }\r
198 \r
199     template<typename ValueType>\r
200     inline ValueType any_cast(const any & operand)\r
201     {\r
202         typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;\r
203 \r
204 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\r
205         // The comment in the above version of 'any_cast' explains when this\r
206         // assert is fired and what to do.\r
207         BOOST_STATIC_ASSERT(!is_reference<nonref>::value);\r
208 #endif\r
209 \r
210         return any_cast<const nonref &>(const_cast<any &>(operand));\r
211     }\r
212 \r
213     // Note: The "unsafe" versions of any_cast are not part of the\r
214     // public interface and may be removed at any time. They are\r
215     // required where we know what type is stored in the any and can't\r
216     // use typeid() comparison, e.g., when our types may travel across\r
217     // different shared libraries.\r
218     template<typename ValueType>\r
219     inline ValueType * unsafe_any_cast(any * operand)\r
220     {\r
221         return &static_cast<any::holder<ValueType> *>(operand->content)->held;\r
222     }\r
223 \r
224     template<typename ValueType>\r
225     inline const ValueType * unsafe_any_cast(const any * operand)\r
226     {\r
227         return unsafe_any_cast<ValueType>(const_cast<any *>(operand));\r
228     }\r
229 }\r
230 \r
231 // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.\r
232 //\r
233 // Distributed under the Boost Software License, Version 1.0. (See\r
234 // accompanying file LICENSE_1_0.txt or copy at\r
235 // http://www.boost.org/LICENSE_1_0.txt)\r
236 \r
237 #endif\r