| The Gaudi Framework v27r1

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

- File List
- File Members

GaudiHandle.cpp
Go to the documentation of this file.
1 #include "GaudiKernel/GaudiHandle.h"
2 #include <iostream>
3 #include <string>
4
5 //
6 // GaudiHandleBase implementation
7 //
8
9 void GaudiHandleBase::setTypeAndName( std::string myTypeAndName ) {
10 m_typeAndName = std::move(myTypeAndName);
11 }
12
13 std::string GaudiHandleBase::type() const {
14 std::string::size_type slash = m_typeAndName.find('/');
15 if ( slash != std::string::npos ) {
16 // return only part before /
17 return m_typeAndName.substr(0,slash);
18 } else {
19 // return full string
20 return m_typeAndName;
21 }
22 }
23
24 std::string GaudiHandleBase::name() const {
25 auto slash = m_typeAndName.find('/');
26 if ( slash == std::string::npos ) {
27 // only type is given, or string is empty.
28 // return default name (=type or empty, in this case full string)
29 return m_typeAndName;
30 } else if ( slash != m_typeAndName.length() -1 ) {
31 // an explicit name is given, so return it
32 return m_typeAndName.substr(slash+1);
33 } else {
34 // ends with /, i.e. explicit empty name.
35 // Should probably never happen.
36 return "";
37 }
38 }
39
40 void GaudiHandleBase::setName( const std::string& myName ) {
41 m_typeAndName = type() + '/' + myName;
42 }
43
44 std::string GaudiHandleBase::pythonPropertyClassName() const {
45 return componentType() + "Handle";
46 }
47
48 std::string GaudiHandleBase::messageName() const {
49 std::string propName = propertyName();
50 if ( propName.empty() ) {
51 propName = pythonPropertyClassName() + "('" + m_typeAndName + "')";
52 }
53 return parentName() + "." + propName;
54 }
55
56 std::string GaudiHandleBase::pythonRepr() const {
57 return pythonPropertyClassName() + "('" + m_typeAndName + "')";
58 }
59
60 //
61 // GaudiHandleArrayBase implementation
62 //
63 bool GaudiHandleArrayBase::setTypesAndNames( const std::vector< std::string >& myTypesAndNamesList ) {
64 clear();
65 for ( const auto& it : myTypesAndNamesList ) {
66 if ( !push_back( it ) ) return false;
67 }
68 return true;
69 }
70
71 const std::vector< std::string >
72 GaudiHandleArrayBase::getBaseInfos( std::string (GaudiHandleBase::*pMemFunc)() const ) const {
73 std::vector< std::string > theList;
74 for ( const auto& it : getBaseArray() ) theList.push_back( (it->*pMemFunc)() );
75 return theList;
76 }
77
78 const std::vector< std::string > GaudiHandleArrayBase::typesAndNames() const {
79 return getBaseInfos( &GaudiHandleBase::typeAndName );
80 }
81
82 const std::vector< std::string > GaudiHandleArrayBase::types() const {
83 return getBaseInfos( &GaudiHandleBase::type );
84 }
85
86 const std::vector< std::string > GaudiHandleArrayBase::names() const {
87 return getBaseInfos( &GaudiHandleBase::name );
88 }
89
90 std::string GaudiHandleArrayBase::pythonPropertyClassName() const {
91 return componentType() + "HandleArray";
92 }
93
94 std::string GaudiHandleArrayBase::pythonRepr() const {
95 std::string repr = pythonPropertyClassName() + "([";
96 auto theList = typesAndNames();
97 auto first = theList.begin();
98 auto last = theList.end();
99 if ( first != last ) { repr += "'" + *first + "'"; ++first; }
100 for (;first!=last;++first) repr += ",'" + *first + "'";
101 repr += "])";
102 return repr;
103 }
104
105 //
106 // Public functions
107 //
108 std::ostream& operator<<( std::ostream& os, const GaudiHandleInfo& handle ) {
109 std::string msg;
110 const auto& propName = handle.propertyName();
111 if ( !propName.empty() ) msg += propName + " = ";
112 msg += handle.pythonRepr();
113 os << msg;
114 return os;
115 }
GaudiHandleBase::messageName
std::string messageName() const
name used for printing messages
Definition: GaudiHandle.cpp:48
std::string::empty
T empty(T...args)
GaudiHandleBase::pythonRepr
virtual std::string pythonRepr() const
Python representation of handle, i.e.
Definition: GaudiHandle.cpp:56
operator<<
std::ostream & operator<<(std::ostream &os, const GaudiHandleInfo &handle)
Definition: GaudiHandle.cpp:108
GaudiHandleBase::setTypeAndName
void setTypeAndName(std::string myTypeAndName)
The component "type/name" string.
Definition: GaudiHandle.cpp:9
GaudiMP.FdsRegistry.msg
tuple msg
Definition: FdsRegistry.py:8
GaudiHandleArrayBase::getBaseArray
virtual ConstBaseHandleArray getBaseArray() const =0
Get a read-only vector of const GaudiHandleBase* pointing to the real handles.
GaudiHandleInfo::parentName
const std::string & parentName() const
The name of the parent.
Definition: GaudiHandle.h:49
GaudiHandleArrayBase::names
const std::vector< std::string > names() const
Return a vector with "type/name" strings of all handles in the array.
Definition: GaudiHandle.cpp:86
GaudiHandleArrayBase::getBaseInfos
const std::vector< std::string > getBaseInfos(std::string(GaudiHandleBase::*pMemFunc)() const ) const
Helper function to get a vector of strings filled with the return value of each tool of a member func...
Definition: GaudiHandle.cpp:72
std::string
STL class.
std::vector::push_back
T push_back(T...args)
GaudiHandleInfo::pythonRepr
virtual std::string pythonRepr() const =0
Python representation of handle, i.e.
GaudiHandleArrayBase::types
const std::vector< std::string > types() const
Return a vector with "type" strings of all handles in the array.
Definition: GaudiHandle.cpp:82
GaudiHandleInfo::propertyName
const std::string & propertyName() const
name as used in declareProperty(name,gaudiHandle)
Definition: GaudiHandle.h:39
GaudiHandleArrayBase::setTypesAndNames
bool setTypesAndNames(const std::vector< std::string > &myTypesAndNamesList)
Set the array of handles from list of "type/name" strings in .
Definition: GaudiHandle.cpp:63
GaudiHandleArrayBase::clear
virtual void clear()=0
Clear the list of handles.
GaudiHandleBase::m_typeAndName
std::string m_typeAndName
Definition: GaudiHandle.h:158
std::move
T move(T...args)
std::string::find
T find(T...args)
std::string::length
T length(T...args)
std::vector< std::string >
GaudiHandleArrayBase::push_back
virtual bool push_back(const std::string &myHandleTypeAndName)=0
Add a handle to the array with "type/name" given in .
GaudiHandleBase::type
std::string type() const
The concrete component class name: the part before the '/'.
Definition: GaudiHandle.cpp:13
GaudiHandleBase::pythonPropertyClassName
std::string pythonPropertyClassName() const
Name of the componentType with "Handle" appended.
Definition: GaudiHandle.cpp:44
std::string::substr
T substr(T...args)
GaudiHandleArrayBase::typesAndNames
const std::vector< std::string > typesAndNames() const
Return a vector with "type/name" strings of all handles in the array.
Definition: GaudiHandle.cpp:78
GaudiHandleBase::name
std::string name() const
The instance name: the part after the '/'.
Definition: GaudiHandle.cpp:24
GaudiHandleBase
Base class to handles to be used in lieu of naked pointers to various Gaudi components.
Definition: GaudiHandle.h:93
GaudiHandleBase::typeAndName
std::string typeAndName() const
The full type and name: "type/name".
Definition: GaudiHandle.h:120
GaudiHandleArrayBase::pythonPropertyClassName
std::string pythonPropertyClassName() const override
Name of the componentType with "HandleArray" appended.
Definition: GaudiHandle.cpp:90
GaudiHandleBase::setName
void setName(const std::string &myName)
Set the instance name (part after the '/') without changing the class type.
Definition: GaudiHandle.cpp:40
std::ostream
STL class.
GaudiHandle.h
GaudiHandleInfo::componentType
const std::string & componentType() const
Definition: GaudiHandle.h:34
GaudiHandleInfo
Definition: GaudiHandle.h:15
GaudiHandleArrayBase::pythonRepr
std::string pythonRepr() const override
Python representation of array of handles, i.e.
Definition: GaudiHandle.cpp:94