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
|
/*
* This source file is part of MyGUI. For the latest info, see http://mygui.info/
* Distributed under the MIT License
* (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
*/
// -- Based on boost::any, original copyright information follows --
// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
//
// Distributed under the Boost Software License, Version 1.0.
// (See at http://www.boost.org/LICENSE_1_0.txt)
// -- End original copyright --
#ifndef MYGUI_ANY_H_
#define MYGUI_ANY_H_
#include "MyGUI_Prerequest.h"
#include "MyGUI_Diagnostic.h"
#include <algorithm>
#include <typeinfo>
namespace MyGUI
{
/** @example "Class Any usage"
@code
void f()
{
// test class, with simple types everything is similar
struct Data { int value; };
// instance and initialization
Data data;
data.value = 0xDEAD;
// copy of class Data will be created
MyGUI::Any any = data;
// copy of class Data
Data copy_data = *any.castType<Data>();
// now value == 0xDEAD
int value = copy_data.value;
// copy of pointer on class Data will be created
any = &data;
// copy of pointer on class Data and on object data
Data* copy_ptr = *any.castType<Data*>();
// now value == 0
copy_ptr->value = 0;
}
@endcode
*/
class MYGUI_EXPORT Any
{
public:
static const Any Null;
Any();
Any(const Any& other);
Any(Any&& other) noexcept;
~Any();
template<typename ValueType>
Any(const ValueType& value) :
mContent(std::make_unique<Holder<ValueType>>(value))
{
}
template<typename ValueType>
Any& operator=(const ValueType& rhs)
{
mContent = std::make_unique<Holder>(rhs);
return *this;
}
Any& operator=(const Any& rhs);
Any& operator=(Any&& rhs) noexcept;
bool empty() const;
const std::type_info& getType() const;
template<typename ValueType>
ValueType* castType(bool _throw = true) const
{
if (this->getType() == typeid(ValueType))
return &static_cast<Any::Holder<ValueType>*>(this->mContent.get())->held;
MYGUI_ASSERT(
!_throw,
"Bad cast from type '" << getType().name() << "' to '" << typeid(ValueType).name() << "'");
return nullptr;
}
bool compare(const Any& other) const;
private:
class Placeholder
{
public:
virtual ~Placeholder() = default;
public:
virtual const std::type_info& getType() const = 0;
virtual std::unique_ptr<Placeholder> clone() const = 0;
virtual bool compare(const std::unique_ptr<Placeholder>& other) const = 0;
};
template<class T>
struct HasOperatorEqualImpl
{
template<typename U>
static auto test(U*) -> decltype(std::declval<U>() == std::declval<U>());
template<typename>
static auto test(...) -> std::false_type;
using type = typename std::is_same<bool, decltype(test<T>(nullptr))>::type;
static constexpr bool value = type::value;
};
template<class T>
struct HasOperatorEqual : HasOperatorEqualImpl<T>::type
{
};
template<typename T1, typename T2>
struct HasOperatorEqual<std::pair<T1, T2>>
{
static constexpr bool value = HasOperatorEqualImpl<T1>::value && HasOperatorEqualImpl<T2>::value;
};
template<typename ValueType>
class Holder : public Placeholder
{
friend class Any;
public:
Holder(const ValueType& value) :
held(value)
{
}
public:
const std::type_info& getType() const override
{
return typeid(ValueType);
}
std::unique_ptr<Placeholder> clone() const override
{
return std::make_unique<Holder>(held);
}
bool compare(const std::unique_ptr<Placeholder>& other) const override
{
if constexpr (HasOperatorEqual<ValueType>::value)
return getType() == other->getType() && held == static_cast<Holder*>(other.get())->held;
else
MYGUI_EXCEPT("Type '" << getType().name() << "' is not comparable");
}
private:
ValueType held;
};
private:
std::unique_ptr<Placeholder> mContent;
};
} // namespace MyGUI
#endif // MYGUI_ANY_H_
|
