| The Gaudi Framework v30r0 (c919700c)

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