forked from cms-sw/cmssw
/
DataProxy.h
153 lines (126 loc) · 5.33 KB
/
DataProxy.h
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
#ifndef CondCore_ESSources_DataProxy_H
#define CondCore_ESSources_DataProxy_H
//#include <iostream>
#include <memory>
#include <string>
// user include files
#include "FWCore/Framework/interface/DataProxyTemplate.h"
#include "CondCore/CondDB/interface/PayloadProxy.h"
// expose a cond::PayloadProxy as a eventsetup::DataProxy
namespace cond {
template <typename DataT>
struct DefaultInitializer {
void operator()(DataT&) {}
};
} // namespace cond
template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT> >
class DataProxy : public edm::eventsetup::DataProxyTemplate<RecordT, DataT> {
public:
typedef DataProxy<RecordT, DataT> self;
typedef std::shared_ptr<cond::persistency::PayloadProxy<DataT> > DataP;
explicit DataProxy(std::shared_ptr<cond::persistency::PayloadProxy<DataT> > pdata) : m_data(pdata) {}
//virtual ~DataProxy();
// ---------- const member functions ---------------------
// ---------- static member functions --------------------
// ---------- member functions ---------------------------
protected:
const DataT* make(const RecordT&, const edm::eventsetup::DataKey&) override {
m_data->make();
m_initializer(const_cast<DataT&>((*m_data)()));
return &(*m_data)();
}
void invalidateCache() override {
// don't, preserve data for future access
// m_data->invalidateCache();
}
void invalidateTransientCache() override { m_data->invalidateTransientCache(); }
private:
//DataProxy(); // stop default
const DataProxy& operator=(const DataProxy&) = delete; // stop default
// ---------- member data --------------------------------
std::shared_ptr<cond::persistency::PayloadProxy<DataT> > m_data;
Initializer m_initializer;
};
namespace cond {
/* ABI bridging between the cond world and eventsetup world
* keep them separated!
*/
class DataProxyWrapperBase {
public:
typedef std::shared_ptr<cond::persistency::BasePayloadProxy> ProxyP;
typedef std::shared_ptr<edm::eventsetup::DataProxy> edmProxyP;
// limitation of plugin manager...
typedef std::pair<std::string, std::string> Args;
virtual edm::eventsetup::TypeTag type() const = 0;
virtual ProxyP proxy() const = 0;
virtual edmProxyP edmProxy() const = 0;
DataProxyWrapperBase();
explicit DataProxyWrapperBase(std::string const& il);
// late initialize (to allow to load ALL library first)
virtual void lateInit(cond::persistency::Session& session,
const std::string& tag,
const boost::posix_time::ptime& snapshotTime,
std::string const& il,
std::string const& cs) = 0;
void addInfo(std::string const& il, std::string const& cs, std::string const& tag);
virtual ~DataProxyWrapperBase();
std::string const& label() const { return m_label; }
std::string const& connString() const { return m_connString; }
std::string const& tag() const { return m_tag; }
private:
std::string m_label;
std::string m_connString;
std::string m_tag;
};
} // namespace cond
/* bridge between the cond world and eventsetup world
* keep them separated!
*/
template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT> >
class DataProxyWrapper : public cond::DataProxyWrapperBase {
public:
typedef ::DataProxy<RecordT, DataT, Initializer> DataProxy;
typedef cond::persistency::PayloadProxy<DataT> PayProxy;
typedef std::shared_ptr<PayProxy> DataP;
DataProxyWrapper(cond::persistency::Session& session,
const std::string& tag,
const std::string& ilabel,
const char* source = nullptr)
: cond::DataProxyWrapperBase(ilabel),
m_source(source ? source : ""),
//'errorPolicy set to true: PayloadProxy should catch and re-throw ORA exceptions' still needed?
m_proxy(new PayProxy(source)),
m_edmProxy(new DataProxy(m_proxy)) {
m_proxy->setUp(session);
//NOTE: We do this so that the type 'DataT' will get registered
// when the plugin is dynamically loaded
m_type = edm::eventsetup::DataKey::makeTypeTag<DataT>();
}
// constructor from plugin...
explicit DataProxyWrapper(const char* source = nullptr) : m_source(source ? source : "") {
//NOTE: We do this so that the type 'DataT' will get registered
// when the plugin is dynamically loaded
m_type = edm::eventsetup::DataKey::makeTypeTag<DataT>();
}
// late initialize (to allow to load ALL library first)
void lateInit(cond::persistency::Session& session,
const std::string& tag,
const boost::posix_time::ptime& snapshotTime,
std::string const& il,
std::string const& cs) override {
m_proxy.reset(new PayProxy(m_source.empty() ? (const char*)nullptr : m_source.c_str()));
m_proxy->setUp(session);
m_proxy->loadTag(tag, snapshotTime);
m_edmProxy.reset(new DataProxy(m_proxy));
addInfo(il, cs, tag);
}
edm::eventsetup::TypeTag type() const override { return m_type; }
ProxyP proxy() const override { return m_proxy; }
edmProxyP edmProxy() const override { return m_edmProxy; }
private:
std::string m_source;
edm::eventsetup::TypeTag m_type;
std::shared_ptr<cond::persistency::PayloadProxy<DataT> > m_proxy;
edmProxyP m_edmProxy;
};
#endif /* CONDCORE_PLUGINSYSTEM_DATAPROXY_H */