|
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
|
#ifndef DataFormats_Common_VectorHolder_h
#define DataFormats_Common_VectorHolder_h
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/BaseVectorHolder.h"
#include "DataFormats/Common/interface/Holder.h"
#include <memory>
namespace edm {
namespace reftobase {
class RefVectorHolderBase;
template <class T, class REFV>
class VectorHolder : public BaseVectorHolder<T> {
public:
typedef BaseVectorHolder<T> base_type;
typedef typename base_type::size_type size_type;
typedef typename base_type::element_type element_type;
typedef typename base_type::base_ref_type base_ref_type;
typedef typename base_type::const_iterator const_iterator;
typedef REFV ref_vector_type;
VectorHolder() : base_type() {}
VectorHolder(VectorHolder const& rh) : base_type(rh), refVector_(rh.refVector_) {}
#if defined(__GXX_EXPERIMENTAL_CXX0X__)
VectorHolder(VectorHolder&& rh) noexcept : base_type(std::forward(rh)), refVector_(std::move(rh.refVector_)) {}
#endif
explicit VectorHolder(const ref_vector_type& iRefVector) : base_type(), refVector_(iRefVector) {}
explicit VectorHolder(const ProductID& iId) : base_type(), refVector_(iId) {}
~VectorHolder() noexcept override {}
base_type* clone() const override { return new VectorHolder(*this); }
base_type* cloneEmpty() const override { return new VectorHolder(refVector_.id()); }
base_ref_type const at(size_type idx) const override { return base_ref_type(refVector_.at(idx)); }
bool empty() const override { return refVector_.empty(); }
size_type size() const override { return refVector_.size(); }
//size_type capacity() const { return refVector_.capacity(); }
//void reserve(size_type n) { refVector_.reserve(n); }
void clear() override { refVector_.clear(); }
ProductID id() const override { return refVector_.id(); }
EDProductGetter const* productGetter() const override { return refVector_.productGetter(); }
void swap(VectorHolder& other) noexcept {
this->BaseVectorHolder<T>::swap(other);
refVector_.swap(other.refVector_);
}
VectorHolder& operator=(VectorHolder const& rhs) {
VectorHolder temp(rhs);
this->swap(temp);
return *this;
}
#if defined(__GXX_EXPERIMENTAL_CXX0X__)
VectorHolder& operator=(VectorHolder&& rhs) noexcept {
base_type::operator=(std::forward(rhs));
refVector_ = std::move(rhs.refVector_);
return *this;
}
#endif
const_iterator begin() const override {
return const_iterator(new const_iterator_imp_specific(refVector_.begin()));
}
const_iterator end() const override { return const_iterator(new const_iterator_imp_specific(refVector_.end())); }
void push_back(const BaseHolder<T>* r) override {
typedef Holder<T, typename REFV::value_type> holder_type;
const holder_type* h = dynamic_cast<const holder_type*>(r);
if (h == nullptr)
Exception::throwThis(errors::InvalidReference,
"In VectorHolder<T, REFV> trying to push_back wrong reference type");
refVector_.push_back(h->getRef());
}
std::unique_ptr<RefVectorHolderBase> vectorHolder() const override {
return std::unique_ptr<RefVectorHolderBase>(new RefVectorHolder<REFV>(refVector_));
}
/// Checks if product collection is in memory or available
/// in the Event. No type checking is done.
bool isAvailable() const override { return refVector_.isAvailable(); }
//Used by ROOT storage
CMS_CLASS_VERSION(10)
private:
typedef typename base_type::const_iterator_imp const_iterator_imp;
ref_vector_type refVector_;
// the following structure is public
// to allow dictionary to compile
public:
struct const_iterator_imp_specific : public const_iterator_imp {
typedef ptrdiff_t difference_type;
const_iterator_imp_specific() {}
explicit const_iterator_imp_specific(const typename REFV::const_iterator& it) : i(it) {}
~const_iterator_imp_specific() override {}
const_iterator_imp_specific* clone() const override { return new const_iterator_imp_specific(i); }
void increase() override { ++i; }
void decrease() override { --i; }
void increase(difference_type d) override { i += d; }
void decrease(difference_type d) override { i -= d; }
bool equal_to(const const_iterator_imp* o) const override { return i == dc(o); }
bool less_than(const const_iterator_imp* o) const override { return i < dc(o); }
void assign(const const_iterator_imp* o) override { i = dc(o); }
base_ref_type deref() const override { return base_ref_type(*i); }
difference_type difference(const const_iterator_imp* o) const override { return i - dc(o); }
private:
const typename ref_vector_type::const_iterator& dc(const const_iterator_imp* o) const {
if (o == nullptr)
Exception::throwThis(errors::InvalidReference,
"In RefToBaseVector<T> trying to dereference a null pointer");
const const_iterator_imp_specific* oo = dynamic_cast<const const_iterator_imp_specific*>(o);
if (oo == nullptr)
Exception::throwThis(errors::InvalidReference,
"In RefToBaseVector<T> trying to cast iterator to wrong type ");
return oo->i;
}
typename ref_vector_type::const_iterator i;
};
};
// Free swap function
template <typename T, typename REFV>
inline void swap(VectorHolder<T, REFV>& lhs, VectorHolder<T, REFV>& rhs) noexcept {
lhs.swap(rhs);
}
} // namespace reftobase
} // namespace edm
#endif
|