| The Gaudi Framework v32r1 (f65d50dc)

VFSSvc.cpp
Go to the documentation of this file.
1 #include "VFSSvc.h"
2
3 #include "GaudiKernel/IAlgTool.h"
4 #include "GaudiKernel/IToolSvc.h"
5 #include "GaudiKernel/MsgStream.h"
6
7 DECLARE_COMPONENT( VFSSvc )
8
9 //------------------------------------------------------------------------------
10 StatusCode VFSSvc::initialize() {
11 StatusCode sc = Service::initialize();
12 if ( sc.isFailure() ) return sc;
13
14 m_toolSvc = serviceLocator()->service( "ToolSvc" );
15 if ( !m_toolSvc ) {
16 error() << "Cannot locate ToolSvc" << endmsg;
17 return StatusCode::FAILURE;
18 }
19
20 IAlgTool* tool;
21 for ( const auto& i : m_urlHandlersNames ) {
22 // retrieve the tool and the pointer to the interface
23 sc = m_toolSvc->retrieve( i, IAlgTool::interfaceID(), tool, nullptr, true );
24 if ( sc.isFailure() ) {
25 error() << "Cannot get tool " << i << endmsg;
26 return sc;
27 }
28 m_acquiredTools.push_back( tool ); // this is one tool that we will have to release
29 auto hndlr = SmartIF<IFileAccess>( tool );
30 if ( !hndlr ) {
31 error() << i << " does not implement IFileAccess" << endmsg;
32 return StatusCode::FAILURE;
33 }
34 // We do not need to increase the reference count for the IFileAccess interface
35 // because we hold the tool by its IAlgTool interface.
36 // loop over the list of supported protocols and add them to the map (for quick access)
37 for ( const auto& prot : hndlr->protocols() ) m_urlHandlers[prot].emplace_back( hndlr.get() );
38 }
39
40 // Now let's check if we can handle the fallback protocol
41 if ( m_urlHandlers.find( m_fallBackProtocol ) == m_urlHandlers.end() ) {
42 error() << "No handler specified for fallback protocol prefix " << m_fallBackProtocol.value() << endmsg;
43 return StatusCode::FAILURE;
44 }
45
46 // Note: the list of handled protocols will be filled only if requested
47
48 return sc;
49 }
50 //------------------------------------------------------------------------------
51 StatusCode VFSSvc::finalize() {
52 m_urlHandlers.clear(); // clear the map
53 m_protocols.clear();
54
55 if ( m_toolSvc ) {
56 // release the acquired tools (from the last acquired one)
57 while ( !m_acquiredTools.empty() ) {
58 m_toolSvc->releaseTool( m_acquiredTools.back() ).ignore();
59 m_acquiredTools.pop_back();
60 }
61 m_toolSvc.reset(); // release the tool service
62 }
63 return Service::finalize();
64 }
65 //------------------------------------------------------------------------------
66 std::unique_ptr<std::istream> VFSSvc::open( const std::string& url ) {
67 // get the url prefix endpos
68 auto pos = url.find( "://" );
69
70 if ( std::string::npos == pos ) {
71 // no url prefix, try fallback protocol
72 return VFSSvc::open( m_fallBackProtocol + "://" + url );
73 }
74
75 const std::string url_prefix( url, 0, pos );
76 const auto handlers = m_urlHandlers.find( url_prefix );
77 if ( handlers == m_urlHandlers.end() ) {
78 // if we do not have a handler for the URL prefix,
79 // use the fall back one
80 return VFSSvc::open( m_fallBackProtocol + url.substr( pos ) );
81 }
82
83 std::unique_ptr<std::istream> out; // this might help RVO
84 // try the hendlers for the protocol one after the other until one succeds
85 for ( auto hndlr : handlers->second ) {
86 out = hndlr->open( url );
87 if ( out ) break;
88 }
89 return out;
90 }
91 //------------------------------------------------------------------------------
92 namespace {
95 constexpr struct select1st_t {
96 template <typename S, typename T>
97 const S& operator()( const std::pair<S, T>& x ) const {
98 return x.first;
99 }
100 } select1st{};
101 } // namespace
102
103 const std::vector<std::string>& VFSSvc::protocols() const {
104 if ( m_protocols.empty() ) {
105 // prepare the list of handled protocols
106 std::transform( m_urlHandlers.begin(), m_urlHandlers.end(),
107 std::back_inserter( const_cast<VFSSvc*>( this )->m_protocols ), select1st );
108 }
109 return m_protocols;
110 }
VFSSvc::m_toolSvc
SmartIF< IToolSvc > m_toolSvc
Handle to the tool service.
Definition: VFSSvc.h:54
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:60
SmartIF< IFileAccess >
VFSSvc.h
VFSSvc::open
std::unique_ptr< std::istream > open(const std::string &url) override
Definition: VFSSvc.cpp:66
std::vector::empty
T empty(T... args)
VFSSvc::m_protocols
std::vector< std::string > m_protocols
Protocols registered.
Definition: VFSSvc.h:48
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:164
MsgStream.h
IToolSvc.h
std::string
STL class.
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginServiceV1.h:46
GaudiUtils::Map::end
iterator end()
Definition: Map.h:130
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:50
GaudiUtils::Map::find
iterator find(const key_type &key)
Definition: Map.h:147
std::vector::pop_back
T pop_back(T... args)
IAlgTool.h
VFSSvc::m_fallBackProtocol
Gaudi::Property< std::string > m_fallBackProtocol
Definition: VFSSvc.h:44
std::vector::clear
T clear(T... args)
GaudiUtils::Map::begin
iterator begin()
Definition: Map.h:129
std::pair
std::string::find
T find(T... args)
std::vector< std::string >
std::unique_ptr
STL class.
VFSSvc::finalize
StatusCode finalize() override
Finalize Service.
Definition: VFSSvc.cpp:51
std::back_inserter
T back_inserter(T... args)
VFSSvc::m_acquiredTools
std::vector< IAlgTool * > m_acquiredTools
List of acquired tools (needed to release them).
Definition: VFSSvc.h:57
IAlgTool
The interface implemented by the AlgTool base class.
Definition: IAlgTool.h:23
std::vector::back
T back(T... args)
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:86
std::string::substr
T substr(T... args)
GaudiUtils::Map::clear
void clear()
Definition: Map.h:185
IToolSvc::releaseTool
virtual StatusCode releaseTool(IAlgTool *tool)=0
Release the tool.
std::transform
T transform(T... args)
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:86
VFSSvc
Simple service that allows to read files independently from the storage.
Definition: VFSSvc.h:26
VFSSvc::protocols
const std::vector< std::string > & protocols() const override
Definition: VFSSvc.cpp:103
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:130
IInterface::interfaceID
static const InterfaceID & interfaceID()
Return an instance of InterfaceID identifying the interface.
Definition: IInterface.h:253
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:192
VFSSvc::m_urlHandlers
GaudiUtils::HashMap< std::string, std::vector< IFileAccess * > > m_urlHandlers
Map of the tools handling the known protocols.
Definition: VFSSvc.h:51