blob: 2dbd3b6b682ac3843dfdff3c0b489708c67a347f (
plain)
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
|
#pragma once
namespace phosphor
{
namespace inventory
{
namespace manager
{
namespace details
{
namespace holder
{
/** @struct Base
* @brief Adapt from any type base class.
*
* Provides an un-templated base class for use with an adapt to any type
* adapter to enable containers of mixed types.
*/
struct Base
{
Base() = default;
virtual ~Base() = default;
Base(const Base&) = delete;
Base& operator=(const Base&) = delete;
Base(Base&&) = default;
Base& operator=(Base&&) = default;
};
/** @struct Holder
* @brief Adapt from any type.
*
* Adapts any type to enable containers of mixed types.
*
* @tparam T - The adapted type.
*/
template <typename T>
struct Holder : public Base
{
Holder() = delete;
virtual ~Holder() = default;
Holder(const Holder&) = delete;
Holder & operator=(const Holder&) = delete;
Holder(Holder&&) = default;
Holder& operator=(Holder&&) = default;
explicit Holder(T&& held) : _held(std::forward<T>(held)) {}
/** @brief Construct an adapter.
*
* @param[in] held - The object to be adapted.
*
* @returns - std::unique pointer to the adapted object.
*
* @tparam Ret - The type of the pointer to be returned.
* @tparam Held - The type of the object to be adapted.
*/
template <typename Ret, typename Held>
static auto make_unique(Held&& held)
{
return std::make_unique<Ret>(
std::forward<Held>(held));
}
/** @brief Construct an adapter.
*
* @param[in] held - The object to be adapted.
*
* @returns - std::shared pointer to the adapted object.
*
* @tparam Ret - The type of the pointer to be returned.
* @tparam Held - The type of the object to be adapted.
*/
template <typename Ret, typename Held>
static auto make_shared(Held&& held)
{
return std::make_shared<Ret>(
std::forward<Held>(held));
}
protected:
T _held;
};
/** @struct CallableBase
* @brief Adapt any callable function object base class.
*
* Provides an un-templated base class for use with an adapt to any
* callable function object type.
*
* @tparam Ret - The return type of the callable.
* @tparam Args - The argument types of the callable.
*/
template <typename Ret, typename ...Args>
struct CallableBase
{
CallableBase() = default;
virtual ~CallableBase() = default;
CallableBase(const CallableBase&) = delete;
CallableBase& operator=(const CallableBase&) = delete;
CallableBase(CallableBase&&) = default;
CallableBase& operator=(CallableBase&&) = default;
virtual Ret operator()(Args&&...args) const = 0;
virtual Ret operator()(Args&&...args)
{
return const_cast<const CallableBase&>(*this)(
std::forward<Args>(args)...);
}
};
/** @struct CallableHolder
* @brief Adapt from any callable type.
*
* Adapts any callable type.
*
* @tparam T - The type of the callable.
* @tparam Ret - The return type of the callable.
* @tparam Args - The argument types of the callable.
*/
template <typename T, typename Ret, typename ...Args>
struct CallableHolder final :
public CallableBase<Ret, Args...>,
public Holder<T>
{
CallableHolder() = delete;
~CallableHolder() = default;
CallableHolder(const CallableHolder&) = delete;
CallableHolder & operator=(const CallableHolder&) = delete;
CallableHolder(CallableHolder&&) = default;
CallableHolder& operator=(CallableHolder&&) = default;
explicit CallableHolder(T&& func) : Holder<T>(std::forward<T>(func)) {}
virtual Ret operator()(Args&&...args) const override
{
return this->_held(std::forward<Args>(args)...);
}
virtual Ret operator()(Args&&...args) override
{
return this->_held(std::forward<Args>(args)...);
}
};
} // namespace holder
} // namespace details
} // namespace manager
} // namespace inventory
} // namespace phosphor
// vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
