|
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
|
#ifndef DataFormats_Common_Holder_h
#define DataFormats_Common_Holder_h
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/BaseHolder.h"
#include "DataFormats/Common/interface/RefHolder.h"
#include <memory>
namespace edm {
namespace reftobase {
//------------------------------------------------------------------
// Class template Holder<T,REF>
//------------------------------------------------------------------
template <class T, class REF>
class Holder : public BaseHolder<T> {
public:
Holder();
Holder(Holder const& other);
explicit Holder(REF const& iRef);
Holder& operator=(Holder const& rhs);
void swap(Holder& other);
~Holder() override;
BaseHolder<T>* clone() const override;
T const* getPtr() const override;
ProductID id() const override;
size_t key() const override;
bool isEqualTo(BaseHolder<T> const& rhs) const override;
REF const& getRef() const;
std::unique_ptr<RefHolderBase> holder() const override {
return std::unique_ptr<RefHolderBase>(new RefHolder<REF>(ref_));
}
std::unique_ptr<BaseVectorHolder<T> > makeVectorHolder() const override;
EDProductGetter const* productGetter() const override;
/// Checks if product collection is in memory or available
/// in the Event. No type checking is done.
bool isAvailable() const override { return ref_.isAvailable(); }
bool isTransient() const override { return ref_.isTransient(); }
//Used by ROOT storage
CMS_CLASS_VERSION(10)
private:
REF ref_;
};
//------------------------------------------------------------------
// Implementation of Holder<T,REF>
//------------------------------------------------------------------
template <class T, class REF>
inline Holder<T, REF>::Holder() : BaseHolder<T>(), ref_() {}
template <class T, class REF>
inline Holder<T, REF>::Holder(Holder const& other) : BaseHolder<T>(other), ref_(other.ref_) {}
template <class T, class REF>
inline Holder<T, REF>::Holder(REF const& r) : BaseHolder<T>(), ref_(r) {}
template <class T, class REF>
inline Holder<T, REF>& Holder<T, REF>::operator=(Holder const& rhs) {
Holder temp(rhs);
swap(temp);
return *this;
}
template <class T, class REF>
inline void Holder<T, REF>::swap(Holder& other) {
std::swap(ref_, other.ref_);
}
template <class T, class REF>
inline Holder<T, REF>::~Holder() {}
template <class T, class REF>
inline BaseHolder<T>* Holder<T, REF>::clone() const {
return new Holder(*this);
}
template <class T, class REF>
inline T const* Holder<T, REF>::getPtr() const {
return ref_.operator->();
}
template <class T, class REF>
inline ProductID Holder<T, REF>::id() const {
return ref_.id();
}
template <class T, class REF>
inline bool Holder<T, REF>::isEqualTo(BaseHolder<T> const& rhs) const {
Holder const* h = dynamic_cast<Holder const*>(&rhs);
return h && (getRef() == h->getRef());
// if (h == 0) return false;
// return getRef() == h->getRef();
}
template <class T, class REF>
inline REF const& Holder<T, REF>::getRef() const {
return ref_;
}
template <class T, class REF>
inline EDProductGetter const* Holder<T, REF>::productGetter() const {
return ref_.productGetter();
}
} // namespace reftobase
} // namespace edm
#include "DataFormats/Common/interface/HolderToVectorTrait.h"
#include "DataFormats/Common/interface/Ref.h"
namespace edm {
namespace reftobase {
template <typename T, typename REF>
std::unique_ptr<BaseVectorHolder<T> > Holder<T, REF>::makeVectorHolder() const {
typedef typename HolderToVectorTrait<T, REF>::type helper;
return helper::makeVectorHolder();
}
} // namespace reftobase
} // namespace edm
#include "DataFormats/Common/interface/RefKeyTrait.h"
namespace edm {
namespace reftobase {
template <class T, class REF>
inline size_t Holder<T, REF>::key() const {
typedef typename RefKeyTrait<REF>::type helper;
return helper::key(ref_);
}
} // namespace reftobase
} // namespace edm
#endif
|