|
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
|
#ifndef DataFormats_Common_Wrapper_h
#define DataFormats_Common_Wrapper_h
/*----------------------------------------------------------------------
Wrapper: A template wrapper around EDProducts to hold the product ID.
----------------------------------------------------------------------*/
#include "DataFormats/Common/interface/Uninitialized.h"
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/WrapperBase.h"
#include "DataFormats/Common/interface/WrapperDetail.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "FWCore/Utilities/interface/Visibility.h"
#include <algorithm>
#include <cassert>
#include <memory>
#include <string>
#include <typeinfo>
namespace edm {
template <typename T>
class Wrapper : public WrapperBase {
public:
typedef T value_type;
typedef T wrapped_type; // used with the dictionary to identify Wrappers
Wrapper() : WrapperBase(), obj{construct_()}, present(false) {}
explicit Wrapper(std::unique_ptr<T> ptr);
Wrapper(Wrapper<T> const& rh) = delete; // disallow copy construction
Wrapper<T>& operator=(Wrapper<T> const&) = delete; // disallow assignment
template <typename... Args>
explicit Wrapper(Emplace, Args&&...);
~Wrapper() override {}
T const* product() const { return (present ? &obj : nullptr); }
T const* operator->() const { return product(); }
T& bareProduct() { return obj; }
//these are used by FWLite
static std::type_info const& productTypeInfo() { return typeid(T); }
static std::type_info const& typeInfo() { return typeid(Wrapper<T>); }
// the constructor takes ownership of T*
Wrapper(T*);
//Used by ROOT storage
CMS_CLASS_VERSION(4)
private:
constexpr T construct_() {
if constexpr (requires { T(); }) {
return T();
} else {
return T(edm::kUninitialized);
}
}
bool isPresent_() const override { return present; }
std::type_info const& dynamicTypeInfo_() const override { return typeid(T); }
std::type_info const& wrappedTypeInfo_() const override { return typeid(Wrapper<T>); }
std::type_info const& valueTypeInfo_() const override;
std::type_info const& memberTypeInfo_() const override;
bool isMergeable_() const override;
bool mergeProduct_(WrapperBase const* newProduct) override;
bool hasIsProductEqual_() const override;
bool isProductEqual_(WrapperBase const* newProduct) const override;
bool hasSwap_() const override;
void swapProduct_(WrapperBase* newProduct) override;
void do_fillView(ProductID const& id,
std::vector<void const*>& pointers,
FillViewHelperVector& helpers) const override;
void do_setPtr(std::type_info const& iToType, unsigned long iIndex, void const*& oPtr) const override;
void do_fillPtrVector(std::type_info const& iToType,
std::vector<unsigned long> const& iIndices,
std::vector<void const*>& oPtr) const override;
std::shared_ptr<soa::TableExaminerBase> tableExaminer_() const override;
private:
T obj;
bool present;
};
template <typename T>
Wrapper<T>::Wrapper(std::unique_ptr<T> ptr) : WrapperBase(), obj{construct_()}, present(ptr.get() != nullptr) {
if (present) {
obj = std::move(*ptr);
}
}
template <typename T>
template <typename... Args>
Wrapper<T>::Wrapper(Emplace, Args&&... args) : WrapperBase(), obj(std::forward<Args>(args)...), present(true) {}
template <typename T>
Wrapper<T>::Wrapper(T* ptr) : WrapperBase(), present(ptr != 0), obj{construct_()} {
std::unique_ptr<T> temp(ptr);
if (present) {
obj = std::move(*ptr);
}
}
template <typename T>
inline std::type_info const& Wrapper<T>::valueTypeInfo_() const {
return detail::getValueType<T>()();
}
template <typename T>
inline std::type_info const& Wrapper<T>::memberTypeInfo_() const {
return detail::getMemberType<T>()();
}
template <typename T>
inline bool Wrapper<T>::isMergeable_() const {
if constexpr (requires(T& a, T const& b) { a.mergeProduct(b); }) {
return true;
}
return false;
}
template <typename T>
inline bool Wrapper<T>::mergeProduct_(WrapperBase const* newProduct) {
Wrapper<T> const* wrappedNewProduct = dynamic_cast<Wrapper<T> const*>(newProduct);
assert(wrappedNewProduct != nullptr);
if constexpr (requires(T& a, T const& b) { a.mergeProduct(b); }) {
return obj.mergeProduct(wrappedNewProduct->obj);
}
return true;
}
template <typename T>
inline bool Wrapper<T>::hasIsProductEqual_() const {
if constexpr (requires(T& a, T const& b) { a.isProductEqual(b); }) {
return true;
}
return false;
}
template <typename T>
inline bool Wrapper<T>::isProductEqual_(WrapperBase const* newProduct) const {
Wrapper<T> const* wrappedNewProduct = dynamic_cast<Wrapper<T> const*>(newProduct);
assert(wrappedNewProduct != nullptr);
if constexpr (requires(T& a, T const& b) { a.isProductEqual(b); }) {
return obj.isProductEqual(wrappedNewProduct->obj);
}
return true;
}
template <typename T>
inline bool Wrapper<T>::hasSwap_() const {
if constexpr (requires(T& a, T& b) { a.swap(b); }) {
return true;
}
return false;
}
template <typename T>
inline void Wrapper<T>::swapProduct_(WrapperBase* newProduct) {
Wrapper<T>* wrappedNewProduct = dynamic_cast<Wrapper<T>*>(newProduct);
assert(wrappedNewProduct != nullptr);
if constexpr (requires(T& a, T& b) { a.swap(b); }) {
obj.swap(wrappedNewProduct->obj);
}
}
namespace soa {
template <class T>
struct MakeTableExaminer {
static std::shared_ptr<edm::soa::TableExaminerBase> make(void const*) {
return std::shared_ptr<edm::soa::TableExaminerBase>{};
}
};
} // namespace soa
template <typename T>
inline std::shared_ptr<edm::soa::TableExaminerBase> Wrapper<T>::tableExaminer_() const {
return soa::MakeTableExaminer<T>::make(&obj);
}
} // namespace edm
#include "DataFormats/Common/interface/WrapperView.icc"
#endif
|