| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

DataStreamTool.cpp
Go to the documentation of this file.
1 // Include files
2
3 // from Gaudi
4 #include "GaudiKernel/MsgStream.h"
5 #include "GaudiKernel/SmartIF.h"
6 #include "GaudiKernel/Incident.h"
7 #include "GaudiKernel/MsgStream.h"
8 #include "GaudiKernel/ISvcLocator.h"
9 #include "GaudiKernel/ISvcManager.h"
10 #include "GaudiKernel/IAddressCreator.h"
11 #include "GaudiKernel/PropertyMgr.h"
12 #include "GaudiKernel/EventSelectorDataStream.h"
13 #include "GaudiKernel/DataStreamTool.h"
14 #include "GaudiKernel/Service.h"
15
16 //-----------------------------------------------------------------------------
17 // Implementation file for class : DataStreamTool
18 //
19 // 2006-09-21 : Andres Felipe Osorio Oliveros
20 //-----------------------------------------------------------------------------
21
22 //=============================================================================
23 // Standard constructor, initializes variables
24 //=============================================================================
25 DataStreamTool::DataStreamTool( const std::string& type,
26 const std::string& name,
27 const IInterface* parent )
28 : base_class ( type, name , parent )
29 {
30 //declareInterface<IDataStreamTool>(this);
31 }
32 //=============================================================================
33 StatusCode DataStreamTool::initialize() {
34
35
36 StatusCode status = AlgTool::initialize();
37 if( !status.isSuccess() ) {
38 fatal() << "Error. Cannot initialize base class." << endmsg;
39 return status;
40 }
41
42 // Get the references to the services that are needed by the ApplicationMgr itself
43 m_incidentSvc = serviceLocator()->service("IncidentSvc");
44 if( !m_incidentSvc ) {
45 fatal() << "Error retrieving IncidentSvc." << endmsg;
46 return StatusCode::FAILURE;
47 }
48
49 return StatusCode::SUCCESS;
50
51 }
52
53 StatusCode DataStreamTool::addStream(const std::string & input) {
54
55 if ( getStream(input) ) {
56 warning() << "Input stream " << input << "already in use" << endmsg;
57 }
58
59 m_streamSpecs.push_back(input);
60
61 auto strname = name() + '_' + std::to_string( ++m_streamCount );
62 EventSelectorDataStream* s = nullptr;
63
64 StatusCode status = createStream(strname, input , s );
65
66 if( status.isSuccess() && s ) {
67 s->addRef();
68 m_streams.push_back(s);
69 status = StatusCode::SUCCESS;
70 } else {
71 if (s) {
72 s->release();
73 error() << "Error connecting/creating Stream: " << s << endmsg;
74 }
75 error() << "Error connecting/creating Stream: " << input << endmsg;
76 status = StatusCode::FAILURE;
77 }
78 return status;
79 }
80
81 StatusCode DataStreamTool::addStreams(const StreamSpecs & inputs) {
82
83 StatusCode status = StatusCode::SUCCESS;
84 for ( auto& i : inputs ) {
85 status = addStream(i);
86 if (!status.isSuccess()) break;
87 }
88 return status;
89
90 }
91
92 StatusCode DataStreamTool::finalize() {
93 clear().ignore();
94 m_incidentSvc.reset();
95 return AlgTool::finalize();
96 }
97
98 StatusCode DataStreamTool::initializeStream(EventSelectorDataStream* s) {
99 IEvtSelector* sel = nullptr;
100 StatusCode status = s->initialize();
101 if ( status.isSuccess() ) {
102 status = createSelector(s->name(), s->selectorType(), sel);
103 if ( status.isSuccess() ) {
104 SmartIF<IProperty> prop(sel); //Att: IProperty, IService used to point to EventSelector
105 SmartIF<IService> isvc(sel);
106 s->setSelector(sel);
107 sel->release(); // No need for this interface anymore, it is passed to the stream
108 if ( prop && isvc ) {
109 for( const auto& i : s->properties() ) prop->setProperty(i).ignore();
110 prop->setProperty(IntegerProperty("OutputLevel",msgLevel())).ignore();
111 // FIXME: (MCl) Why do we have to initialize the selector here?
112 return isvc->sysInitialize();
113 }
114 }
115 }
116 return StatusCode::FAILURE;
117 }
118
119 // Create (sub-) Event selector service
120 StatusCode DataStreamTool::createSelector(const std::string& nam, const std::string& typ, IEvtSelector*& sel) {
121 auto isvc = make_SmartIF( Service::Factory::create(typ, nam, serviceLocator()) );
122 if ( isvc ) {
123 auto isel = isvc.as<IEvtSelector>();
124 if ( isel ) {
125 sel = isel.get();
126 sel->addRef(); // make sure that sel is not left dangling once isel and isvc go out of scope...
127 return StatusCode::SUCCESS;
128 }
129 }
130 sel = nullptr;
131 error() << "Failed to create IEvtSelector " << typ << "/" << nam << endmsg;
132 return StatusCode::FAILURE;
133 }
134
135
136 StatusCode DataStreamTool::finalizeStream(EventSelectorDataStream* s) {
137 if ( s ) {
138 IEvtSelector* sel = s->selector();
139 if ( sel ) {
140 SmartIF<IService> isvc(sel);
141 if ( isvc ) {
142 isvc->finalize().ignore();
143 s->finalize().ignore();
144 // Fire EndStream "Incident"
145 m_incidentSvc->fireIncident(Incident(name(),IncidentType::EndStream));
146 return StatusCode::SUCCESS;
147 }
148 // Failed to get service interface of sub-event selector
149 return StatusCode::FAILURE;
150 }
151 // No selector (yet) attached - no need to finalize it!
152 return StatusCode::SUCCESS;
153 }
154 return StatusCode::FAILURE;
155 }
156
157
158 StatusCode DataStreamTool::eraseStream ( const std::string& info ) {
159
160 auto i = getStreamIterator(info);
161 if ( i != m_streams.end() ) {
162 (*i)->release();
163 m_streams.erase(i);
164 return StatusCode::SUCCESS;
165 }
166 return StatusCode::FAILURE;
167 }
168
169 StatusCode DataStreamTool::createStream(const std::string& nam, const std::string& info,
170 EventSelectorDataStream*& stream) {
171 stream = new EventSelectorDataStream(nam, info, serviceLocator());
172 return StatusCode::SUCCESS;
173 }
174
175
176 EventSelectorDataStream * DataStreamTool::getStream( const std::string& info ) {
177 auto i = getStreamIterator(info);
178 return i != m_streams.end() ? *i : nullptr;
179 }
180
181 DataStreamTool::Streams::iterator DataStreamTool::getStreamIterator ( const std::string& info ) {
182 return std::find_if( std::begin(m_streams), std::end(m_streams),
183 [&](const EventSelectorDataStream* i) {
184 return i->definition()==info;
185 });
186 }
187
188 EventSelectorDataStream * DataStreamTool::getStream( size_type pos ) {
189 // pos has to point inside the vector
190 return ( (pos >= 0) && ((size_t)pos < m_streams.size()) ) ? m_streams[pos]
191 : nullptr;
192 }
193
194 EventSelectorDataStream * DataStreamTool::lastStream()
195 {
196 return m_streams.back();
197 }
198
199
200
201 StatusCode DataStreamTool::clear()
202 {
203
204 StatusCode iret, status = StatusCode::SUCCESS;
205 iret.ignore();
206
207 // disconnect the streams
208 for ( auto& il : m_streamSpecs ) {
209 EventSelectorDataStream* s = getStream(il);
210 if ( s ) {
211 if ( s->isInitialized() ) {
212 iret = finalizeStream(s);
213 if ( !iret.isSuccess() ) {
214 error() << "Error finalizing Stream" << il << endmsg;
215 status = iret;
216 }
217 }
218 iret = eraseStream( il );
219 if ( !iret.isSuccess() ) {
220 error() << "Error diconnecting Stream" << il << endmsg;
221 status = iret;
222 }
223 }
224 }
225
226 m_streamSpecs.clear();
227
228 return status;
229 }
230
231
232 StatusCode DataStreamTool::connectStream( EventSelectorDataStream *s)
233 {
234
235 if ( !s ) return StatusCode::FAILURE;
236 s->addRef();
237 m_streams.push_back(s);
238 return StatusCode::SUCCESS;
239
240 }
241
242 StatusCode DataStreamTool::connectStream( const std::string & info )
243 {
244 if ( getStream(info) ) {
245 warning() << "Input stream " << info << "already in use" << endmsg;
246 }
247 auto nam = name() + '_' + std::to_string( ++m_streamCount);
248 EventSelectorDataStream* s = nullptr;
249 StatusCode status = createStream(nam, info, s);
250 if ( status.isSuccess() ) return connectStream(s);
251 s->release();
252 return status;
253 }
254
255 /*
256
257 Taking control over Streams and return them to EventSelector
258
259 */
260
261
262 StatusCode DataStreamTool::getNextStream( const EventSelectorDataStream * & esds, size_type & dsid )
263 {
264
265 EventSelectorDataStream * nextStream = getStream(dsid);
266 if ( !nextStream ) return StatusCode::FAILURE; //<-end of streams reached
267
268 esds = nextStream;
269 ++m_streamID;
270
271 return StatusCode::SUCCESS;
272
273 }
274
275 StatusCode DataStreamTool::getPreviousStream( const EventSelectorDataStream * & esds, size_type & dsid )
276 {
277
278 EventSelectorDataStream * previousStream = getStream(dsid);
279 if ( !previousStream ) return StatusCode::FAILURE; //<-begin of streams reached
280
281 esds = previousStream;
282 --m_streamID;
283
284 return StatusCode::SUCCESS;
285
286 }
EventSelectorDataStream::isInitialized
bool isInitialized() const
Check initialization status.
Definition: EventSelectorDataStream.h:115
DataStreamTool::getStreamIterator
Streams::iterator getStreamIterator(const std::string &)
Definition: DataStreamTool.cpp:181
SmartIF< IProperty >
EventSelectorDataStream::name
const std::string & name() const
Retrieve stream name.
Definition: EventSelectorDataStream.h:91
DataStreamTool::getNextStream
StatusCode getNextStream(const EventSelectorDataStream *&, size_type &) override
Definition: DataStreamTool.cpp:262
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
MsgStream.h
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:124
AlgTool::initialize
StatusCode initialize() override
Definition: AlgTool.cpp:290
DataStreamTool::clear
StatusCode clear() override
Definition: DataStreamTool.cpp:201
IEvtSelector
The Event Selector Interface.
Definition: IEvtSelector.h:18
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
std::to_string
T to_string(T...args)
EventSelectorDataStream::selector
IEvtSelector * selector() const
Retrieve event selector object.
Definition: EventSelectorDataStream.h:111
DataStreamTool::createStream
StatusCode createStream(const std::string &, const std::string &, EventSelectorDataStream *&) override
Definition: DataStreamTool.cpp:169
std::vector::end
T end(T...args)
DataStreamTool::initializeStream
StatusCode initializeStream(EventSelectorDataStream *) override
Initialize newly opened stream.
Definition: DataStreamTool.cpp:98
ISvcManager.h
std::string
STL class.
Incident.h
Service.h
AlgTool::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: AlgTool.cpp:86
DataStreamTool::finalize
StatusCode finalize() override
Definition: DataStreamTool.cpp:92
AlgTool::finalize
StatusCode finalize() override
Definition: AlgTool.cpp:360
IService::sysInitialize
virtual StatusCode sysInitialize()=0
Initialize Service.
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:78
std::vector::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
EventSelectorDataStream::initialize
virtual StatusCode initialize()
Parse input criteria.
Definition: EventSelectorDataStream.cpp:62
IIncidentSvc::fireIncident
virtual void fireIncident(const Incident &incident)=0
Fire an Incident.
gaudirun.type
string type
Definition: gaudirun.py:151
read_lhcb_event_file.sel
tuple sel
Definition: read_lhcb_event_file.py:10
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
DataStreamTool.h
StatusCode::FAILURE
Definition: StatusCode.h:29
DataStreamTool::lastStream
EventSelectorDataStream * lastStream() override
Definition: DataStreamTool.cpp:194
implements::addRef
unsigned long addRef() override
Reference Interface instance.
Definition: implements.h:44
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
IInterface
Definition of the basic interface.
Definition: IInterface.h:234
IProperty::setProperty
virtual StatusCode setProperty(const Property &p)=0
Set the property by property.
EventSelectorDataStream::finalize
virtual StatusCode finalize()
Finalize stream and release resources.
Definition: EventSelectorDataStream.cpp:193
SmartIF.h
DataStreamTool::finalizeStream
StatusCode finalizeStream(EventSelectorDataStream *) override
Finalize no longer needed stream.
Definition: DataStreamTool.cpp:136
std::vector::erase
T erase(T...args)
DataStreamTool::createSelector
StatusCode createSelector(const std::string &, const std::string &, IEvtSelector *&) override
Definition: DataStreamTool.cpp:120
EventSelectorDataStream.h
DataStreamTool::m_incidentSvc
SmartIF< IIncidentSvc > m_incidentSvc
Reference to the incident service.
Definition: DataStreamTool.h:101
DataStreamTool::connectStream
StatusCode connectStream(EventSelectorDataStream *)
Connect single stream by reference.
Definition: DataStreamTool.cpp:232
DataStreamTool::DataStreamTool
DataStreamTool(const std::string &type, const std::string &name, const IInterface *parent)
Standard constructor.
Definition: DataStreamTool.cpp:25
IntegerProperty
SimpleProperty< int > IntegerProperty
Definition: Property.h:708
DataStreamTool::getStream
EventSelectorDataStream * getStream(const std::string &) override
Retrieve stream by name.
Definition: DataStreamTool.cpp:176
DataStreamTool::addStream
StatusCode addStream(const std::string &) override
Definition: DataStreamTool.cpp:53
DataStreamTool::eraseStream
StatusCode eraseStream(const std::string &) override
Definition: DataStreamTool.cpp:158
EventSelectorDataStream::definition
const std::string & definition() const
Retrieve definition string.
Definition: EventSelectorDataStream.h:107
std::find_if
T find_if(T...args)
std::vector::size
T size(T...args)
IInterface::release
virtual unsigned long release()=0
Release Interface instance.
DataStreamTool::initialize
StatusCode initialize() override
Definition: DataStreamTool.cpp:33
DataStreamTool::m_streamID
size_type m_streamID
Definition: DataStreamTool.h:92
IAddressCreator.h
std::begin
T begin(T...args)
EventSelectorDataStream
Definition of class EventSelectorDataStream.
Definition: EventSelectorDataStream.h:45
DataStreamTool::getPreviousStream
StatusCode getPreviousStream(const EventSelectorDataStream *&, size_type &) override
Definition: DataStreamTool.cpp:275
EventSelectorDataStream::selectorType
const std::string & selectorType() const
Retrieve event selector type.
Definition: EventSelectorDataStream.h:103
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
PropertyMgr.h
DataStreamTool::m_streamCount
size_type m_streamCount
Definition: DataStreamTool.h:94
std::vector::back
T back(T...args)
gaudirun.s
string s
Definition: gaudirun.py:245
CommonMessaging
Definition: CommonMessaging.h:58
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
DataStreamTool::addStreams
StatusCode addStreams(const StreamSpecs &) override
Definition: DataStreamTool.cpp:81
make_SmartIF
SmartIF< IFace > make_SmartIF(IFace *iface)
Definition: SmartIF.h:143
EventSelectorDataStream::properties
const Properties & properties()
Access properties.
Definition: EventSelectorDataStream.h:87
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:88
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:108
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:112
DataStreamTool::m_streams
Streams m_streams
Definition: DataStreamTool.h:96
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:136
ana.i
list i
Definition: ana.py:128
AlgTool::name
const std::string & name() const override
Retrieve full identifying name of the concrete tool object.
Definition: AlgTool.cpp:65
ISvcLocator.h
EventSelectorDataStream::setSelector
virtual void setSelector(IEvtSelector *pSelector)
Attach event selector object.
Definition: EventSelectorDataStream.cpp:43
DataStreamTool::m_streamSpecs
StreamSpecs m_streamSpecs
Definition: DataStreamTool.h:98
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
implements::release
unsigned long release() override
Release Interface instance.
Definition: implements.h:46