| The Gaudi Framework v30r0 (c919700c)

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

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Private Member Functions | Private Attributes | List of all members
configGenerator Class Reference
Collaboration diagram for configGenerator:
[legend]

## Public Member Functions
| configGenerator (const string &pkgName, const string &outputDirName)
int | genConfig (const Strings_t &modules, const string &userModule)
| main entry point of this class: More...
void | setConfigurableModule (const std::string &moduleName)
| customize the Module name where configurable base classes are defined More...
void | setConfigurableDefaultName (const std::string &defaultName)
| customize the default name for configurable instances More...
void | setConfigurableAlgorithm (const std::string &cfgAlgorithm)
| customize the configurable base class for Algorithm component More...
void | setConfigurableAlgTool (const std::string &cfgAlgTool)
| customize the configurable base class for AlgTool component More...
void | setConfigurableAuditor (const std::string &cfgAuditor)
| customize the configurable base class for AlgTool component More...
void | setConfigurableService (const std::string &cfgService)
| customize the configurable base class for Service component More...

## Private Member Functions
bool | genComponent (const std::string &libName, const std::string &componentName, component_t componentType, const vector< PropertyBase * > &properties)
void | genImport (std::ostream &s, const boost::format &frmt, std::string indent)
void | genHeader (std::ostream &pyOut, std::ostream &dbOut)
void | genBody (std::ostream &pyOut, std::ostream &dbOut)
void | genTrailer (std::ostream &pyOut, std::ostream &dbOut)
void | pythonizeValue (const PropertyBase *prop, string &pvalue, string &ptype)
| handle the "marshalling" of Properties More...

## Private Attributes
string | m_pkgName
| name of the package we are processing More...
string | m_outputDirName
| absolute path to the directory where genconf will store auto-generated files (Configurables and ConfigurableDb) More...
stringstream | m_pyBuf
| buffer of auto-generated configurables More...
bool | m_importGaudiHandles = false
| switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the components has a XyzHandle<T>) More...
bool | m_importDataObjectHandles = false
stringstream | m_dbBuf
| buffer of generated configurables informations for the "Db" file The "Db" file is holding informations about the generated configurables This file is later one used by the PropertyProxy.py to locate Configurables and know their default values, host module,... More...
std::map< component_t, std::string > | m_configurable
| Configurable customization. More...

## Detailed Description

Definition at line 143 of file genconf.cpp.

## Constructor & Destructor Documentation

configGenerator::configGenerator | ( | const string & | pkgName,
|  | const string & | outputDirName
| ) |  |
| inline

Definition at line 174 of file genconf.cpp.

175 : m_pkgName( pkgName ), m_outputDirName( outputDirName )
176 {
177 }
configGenerator::m_outputDirName
string m_outputDirName
absolute path to the directory where genconf will store auto-generated files (Configurables and Confi...
Definition: genconf.cpp:150
configGenerator::m_pkgName
string m_pkgName
name of the package we are processing
Definition: genconf.cpp:146

## Member Function Documentation

void configGenerator::genBody | ( | std::ostream & | pyOut,
|  | std::ostream & | dbOut
| ) |  |
| inline private

Definition at line 218 of file genconf.cpp.

219 {
220 pyOut << m_pyBuf.str() << flush;
221 dbOut << m_dbBuf.str() << flush;
222 }
configGenerator::m_pyBuf
stringstream m_pyBuf
buffer of auto-generated configurables
Definition: genconf.cpp:153
std::stringstream::str
T str(T...args)
configGenerator::m_dbBuf
stringstream m_dbBuf
buffer of generated configurables informations for the "Db" file The "Db" file is holding information...
Definition: genconf.cpp:164
std::flush
T flush(T...args)

bool configGenerator::genComponent | ( | const std::string & | libName,
|  | const std::string & | componentName,
|  | component_t | componentType,
|  | const vector< PropertyBase * > & | properties
| ) |  |
| private

Definition at line 683 of file genconf.cpp.

686 {
687 auto cname = pythonizeName( componentName );
688
689 std::vector<std::pair<std::string, std::string>> propDoc;
690 propDoc.reserve( properties.size() );
691
692 m_pyBuf << "\nclass " << cname << "( " << m_configurable[componentType] << " ) :\n";
693 m_pyBuf << " __slots__ = { \n";
694 for ( const auto& prop : properties ) {
695 const string& pname = prop->name();
696 // Validate property name (it must be a valid Python identifier)
697 if ( !boost::regex_match( pname, pythonIdentifier ) ) {
698 std::cout << "ERROR: invalid property name \"" << pname << "\" in component " << cname
699 << " (invalid Python identifier)" << std::endl;
700 // try to make the buffer at least more or less valid python code.
701 m_pyBuf << " #ERROR-invalid identifier '" << pname << "'\n"
702 << " }\n";
703 return false;
704 }
705
706 string pvalue, ptype;
707 pythonizeValue( prop, pvalue, ptype );
708 m_pyBuf << " '" << pname << "' : " << pvalue << ", # " << ptype << "\n";
709
710 if ( prop->documentation() != "none" ) {
711 propDoc.emplace_back( pname, prop->documentation() + " [" + prop->ownerTypeName() + "]" );
712 }
713 }
714 m_pyBuf << " }\n";
715 m_pyBuf << " _propertyDocDct = { \n";
716 for ( const auto& prop : propDoc ) {
717 m_pyBuf << std::setw( 5 ) << "'" << prop.first << "' : "
718 << "\"\"\" " << prop.second << " \"\"\",\n";
719 }
720 m_pyBuf << " }\n";
721
722 m_pyBuf << " def __init__(self, name = " << m_configurable[component_t::DefaultName] << ", **kwargs):\n"
723 << " super(" << cname << ", self).__init__(name)\n"
724 << " for n,v in kwargs.items():\n"
725 << " setattr(self, n, v)\n"
726 << " def getDlls( self ):\n"
727 << " return '" << libName << "'\n"
728 << " def getType( self ):\n"
729 << " return '" << componentName << "'\n"
730 << " pass # class " << cname << "\n"
731 << flush;
732
733 // name of the auto-generated module
734 const string pyName = ( fs::path( m_outputDirName ) / fs::path( libName + "Conf.py" ) ).string();
735 const string modName = fs::basename( fs::path( pyName ).leaf() );
736
737 // now the db part
738 m_dbBuf << m_pkgName << "." << modName << " " << libName << " " << cname << "\n" << flush;
739
740 return true;
741 }
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
std::endl
T endl(T...args)
configGenerator::m_pyBuf
stringstream m_pyBuf
buffer of auto-generated configurables
Definition: genconf.cpp:153
std::setw
T setw(T...args)
configGenerator::m_dbBuf
stringstream m_dbBuf
buffer of generated configurables informations for the "Db" file The "Db" file is holding information...
Definition: genconf.cpp:164
compareOutputFiles.pname
pname
Definition: compareOutputFiles.py:442
std::flush
T flush(T...args)
std::vector::size
T size(T...args)
configGenerator::m_outputDirName
string m_outputDirName
absolute path to the directory where genconf will store auto-generated files (Configurables and Confi...
Definition: genconf.cpp:150
std::vector
STL class.
configGenerator::pythonizeValue
void pythonizeValue(const PropertyBase *prop, string &pvalue, string &ptype)
handle the "marshalling" of Properties
Definition: genconf.cpp:744
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171
configGenerator::m_pkgName
string m_pkgName
name of the package we are processing
Definition: genconf.cpp:146
std::cout
svn_tag_release.basename
def basename(url)
Definition: svn_tag_release.py:28
std::vector::reserve
T reserve(T...args)
std::vector::emplace_back
T emplace_back(T...args)

int configGenerator::genConfig | ( | const Strings_t & | modules,
|  | const string & | userModule
| ) |  |

main entry point of this class:

- iterate over all the modules (ie: library names)
- for each module extract component informations
- eventually generate the header/body/trailer python file and "Db" file

not enough information... skip it

no Properties, so don't bother create Configurables...

write-out files for this library

Definition at line 438 of file genconf.cpp.

440 {
441 //--- Disable checking StatusCode -------------------------------------------
442 StatusCode::disableChecking();
443
444 const auto endLib = libs.end();
445
446 static const std::string gaudiSvc = "GaudiCoreSvc";
447 const bool isGaudiSvc = ( std::find( libs.begin(), endLib, gaudiSvc ) != endLib );
448
449 //--- Instantiate ApplicationMgr --------------------------------------------
450 if ( !isGaudiSvc && createAppMgr() ) {
451 cout << "ERROR: ApplicationMgr can not be created. Check environment" << endl;
452 return EXIT_FAILURE;
453 }
454
455 //--- Iterate over component factories --------------------------------------
456 using Gaudi::PluginService::Details::Registry;
457 Registry& registry = Registry::instance();
458
459 auto bkgNames = registry.loadedFactoryNames();
460
461 ISvcLocator* svcLoc = Gaudi::svcLocator();
462 IInterface* dummySvc = new Service( "DummySvc", svcLoc );
463 dummySvc->addRef();
464
465 bool allGood = true;
466
467 // iterate over all the requested libraries
468 for ( const auto& iLib : libs ) {
469
470 LOG_INFO << ":::: processing library: " << iLib << "...";
471
472 // reset state
473 m_importGaudiHandles = false;
474 m_importDataObjectHandles = false;
475 m_pyBuf.str( "" );
476 m_dbBuf.str( "" );
477
478 //--- Load component library ----------------------------------------------
479 System::ImageHandle handle;
480 unsigned long err = System::loadDynamicLib( iLib, &handle );
481 if ( err != 1 ) {
482 LOG_ERROR << System::getLastErrorString();
483 allGood = false;
484 continue;
485 }
486
487 for ( const auto& factoryName : registry.loadedFactoryNames() ) {
488 if ( bkgNames.find( factoryName ) != bkgNames.end() ) {
489 if ( Gaudi::PluginService::Details::logger().level() <= 1 ) {
490 LOG_INFO << "\t==> skipping [" << factoryName << "]...";
491 }
492 continue;
493 }
494
495 const Registry::FactoryInfo info = registry.getInfo( factoryName );
496 const std::string& rtype = info.rtype;
497
498 // do not generate configurables for the Reflex-compatible aliases
499 if ( info.properties.find( "ReflexName" ) != info.properties.end() ) continue;
500
501 // Atlas contributed code (patch #1247)
502 // Skip the generation of configurables if the component does not come
503 // from the same library we are processing (i.e. we found a symbol that
504 // is coming from a library loaded by the linker).
505 if ( !DsoUtils::inDso( info.ptr, DsoUtils::libNativeName( iLib ) ) ) {
506 LOG_WARNING << "library [" << iLib << "] exposes factory [" << factoryName << "] which is declared in ["
507 << DsoUtils::dsoName( info.ptr ) << "] !!";
508 continue;
509 }
510
511 component_t type = component_t::Unknown;
512 if ( factoryName == "ApplicationMgr" )
513 type = component_t::ApplicationMgr;
514 else if ( rtype == typeid( IInterface* ).name() )
515 type = component_t::IInterface;
516 else if ( rtype == typeid( IAlgorithm* ).name() )
517 type = component_t::Algorithm;
518 else if ( rtype == typeid( IService* ).name() )
519 type = component_t::Service;
520 else if ( rtype == typeid( IAlgTool* ).name() )
521 type = component_t::AlgTool;
522 else if ( rtype == typeid( IAuditor* ).name() )
523 type = component_t::Auditor;
524 else if ( rtype == typeid( IConverter* ).name() )
525 type = component_t::Converter;
526 else if ( rtype == typeid( DataObject* ).name() )
527 type = component_t::DataObject;
528 // handle possible problems with templated components
529 std::string name = boost::trim_copy( factoryName );
530
531 if ( type == component_t::IInterface ) {
534 continue;
535 }
536
537 if ( type == component_t::Converter || type == component_t::DataObject ) {
539 continue;
540 }
541
542 if ( type == component_t::Unknown ) {
543 LOG_WARNING << "Unknown (return) type [" << System::typeinfoName( rtype.c_str() ) << "] !!"
544 << " Component [" << factoryName << "] is skipped !";
545 continue;
546 }
547
548 LOG_INFO << " - component: " << info.className << " ("
549 << ( info.className != name ? ( name + ": " ) : std::string() ) << type << ")";
550
551 string cname = "DefaultName";
552 SmartIF<IProperty> prop;
553 try {
554 switch ( type ) {
555 case component_t::Algorithm:
556 prop = SmartIF<IAlgorithm>( Algorithm::Factory::create( factoryName, cname, svcLoc ) );
557 break;
558 case component_t::Service:
559 prop = SmartIF<IService>( Service::Factory::create( factoryName, cname, svcLoc ) );
560 break;
561 case component_t::AlgTool:
562 prop = SmartIF<IAlgTool>( AlgTool::Factory::create( factoryName, cname, toString( type ), dummySvc ) );
563 // FIXME: AlgTool base class increase artificially by 1 the refcount.
564 prop->release();
565 break;
566 case component_t::Auditor:
567 prop = SmartIF<IAuditor>( Auditor::Factory::create( factoryName, cname, svcLoc ) );
568 break;
569 case component_t::ApplicationMgr:
570 prop = SmartIF<ISvcLocator>( svcLoc );
571 break;
572 default:
573 continue; // unknown
574 }
575 } catch ( exception& e ) {
576 LOG_ERROR << "Error instantiating " << name << " from " << iLib;
577 LOG_ERROR << "Got exception: " << e.what();
578 allGood = false;
579 continue;
580 } catch ( ... ) {
581 LOG_ERROR << "Error instantiating " << name << " from " << iLib;
582 allGood = false;
583 continue;
584 }
585 if ( prop ) {
586 if ( !genComponent( iLib, name, type, prop->getProperties() ) ) {
587 allGood = false;
588 }
589 prop.reset();
590 } else {
591 LOG_ERROR << "could not cast IInterface* object to an IProperty* !";
592 LOG_ERROR << "return type from PluginSvc is [" << rtype << "]...";
593 LOG_ERROR << "NO Configurable will be generated for [" << name << "] !";
594 allGood = false;
595 }
596 } //> end loop over factories
597
601 const std::string pyName = ( fs::path( m_outputDirName ) / fs::path( iLib + "Conf.py" ) ).string();
602 const std::string dbName = ( fs::path( m_outputDirName ) / fs::path( iLib + ".confdb" ) ).string();
603
604 std::fstream py( pyName, std::ios_base::out | std::ios_base::trunc );
605 std::fstream db( dbName, std::ios_base::out | std::ios_base::trunc );
606
607 genHeader( py, db );
608 if ( !userModule.empty() ) py << "from " << userModule << " import *" << endl;
609 genBody( py, db );
610 genTrailer( py, db );
611
612 } //> end loop over libraries
613
614 dummySvc->release();
615 dummySvc = 0;
616
617 return allGood ? EXIT_SUCCESS : EXIT_FAILURE;
618 }
SmartIF< IProperty >
std::string::empty
T empty(T...args)
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
IConverter
The data converters are responsible to translate data from one representation into another...
Definition: IConverter.h:58
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
component_t
component_t
Definition: genconf.cpp:98
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:336
Gaudi::PluginService::Details::Logger::level
Level level() const
Definition: PluginServiceDetails.h:226
LOG_ERROR
#define LOG_ERROR
Definition: genconf.cpp:75
std::endl
T endl(T...args)
System::ImageHandle
void * ImageHandle
Definition of an image handle.
Definition: ModuleInfo.h:31
configGenerator::m_pyBuf
stringstream m_pyBuf
buffer of auto-generated configurables
Definition: genconf.cpp:153
Gaudi::PluginService::Details::logger
GAUDIPS_API Logger & logger()
Return the current logger instance.
Definition: PluginService.cpp:339
std::string
STL class.
configGenerator::m_importDataObjectHandles
bool m_importDataObjectHandles
Definition: genconf.cpp:158
Gaudi::svcLocator
GAUDI_API ISvcLocator * svcLocator()
std::exception::what
T what(T...args)
LOG_INFO
#define LOG_INFO
Definition: genconf.cpp:77
IService
General service interface definition.
Definition: IService.h:18
IInterface
Definition of the basic interface.
Definition: IInterface.h:277
gaudirun.type
type
Definition: gaudirun.py:133
std::fstream
STL class.
configGenerator::genHeader
void genHeader(std::ostream &pyOut, std::ostream &dbOut)
Definition: genconf.cpp:652
std::stringstream::str
T str(T...args)
GaudiPluginService.cpluginsvc.registry
def registry()
Definition: cpluginsvc.py:70
configGenerator::m_dbBuf
stringstream m_dbBuf
buffer of generated configurables informations for the "Db" file The "Db" file is holding information...
Definition: genconf.cpp:164
std::exception
STL class.
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:28
IProperty::getProperties
virtual const std::vector< Gaudi::Details::PropertyBase * > & getProperties() const =0
Get list of properties.
GaudiPython.Bindings.DataObject
DataObject
Definition: Bindings.py:55
std::find
T find(T...args)
configGenerator::m_outputDirName
string m_outputDirName
absolute path to the directory where genconf will store auto-generated files (Configurables and Confi...
Definition: genconf.cpp:150
IInterface::release
virtual unsigned long release()=0
Release Interface instance.
LOG_WARNING
#define LOG_WARNING
Definition: genconf.cpp:76
configGenerator::m_importGaudiHandles
bool m_importGaudiHandles
switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the compon...
Definition: genconf.cpp:157
std::string::c_str
T c_str(T...args)
IAlgTool
The interface implemented by the AlgTool base class.
Definition: IAlgTool.h:23
Gaudi::PluginService::Details::Registry
In-memory database of the loaded factories.
Definition: PluginServiceDetails.h:110
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
StatusCode::disableChecking
static GAUDI_API void disableChecking()
Definition: StatusCode.cpp:20
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
configGenerator::genTrailer
void genTrailer(std::ostream &pyOut, std::ostream &dbOut)
Definition: genconf.cpp:675
System::getLastErrorString
GAUDI_API const std::string getLastErrorString()
Get last system error as string.
Definition: System.cpp:298
configGenerator::genComponent
bool genComponent(const std::string &libName, const std::string &componentName, component_t componentType, const vector< PropertyBase * > &properties)
Definition: genconf.cpp:683
Service
Base class for all services.
Definition: Service.h:36
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
createAppMgr
int createAppMgr()
Definition: genconf.cpp:804
IAuditor
The IAuditor is the interface implmented by the AlgAuditor base class.
Definition: IAuditor.h:18
std::cout
DsoUtils::libNativeName
std::string libNativeName(const std::string &libName)
Definition: DsoUtils.h:19
configGenerator::genBody
void genBody(std::ostream &pyOut, std::ostream &dbOut)
Definition: genconf.cpp:218
GaudiMath::Interpolation::toString
std::string toString(const Type &)
Definition: Interpolation.cpp:42
System::loadDynamicLib
GAUDI_API unsigned long loadDynamicLib(const std::string &name, ImageHandle *handle)
Load dynamic link library.
Definition: System.cpp:154

void configGenerator::genHeader | ( | std::ostream & | pyOut,
|  | std::ostream & | dbOut
| ) |  |
| private

Definition at line 652 of file genconf.cpp.

654 {
655 // python file part
656 std::string now = Gaudi::Time::current().format( true );
657 py << "#" << now //<< "\n"
658 << "\"\"\"Automatically generated. DO NOT EDIT please\"\"\"\n";
659 if ( m_importGaudiHandles ) {
660 py << "from GaudiKernel.GaudiHandles import *\n";
661 }
662
663 if ( m_importDataObjectHandles ) {
664 py << "from GaudiKernel.DataObjectHandleBase import DataObjectHandleBase\n";
665 }
666
667 genImport( py, boost::format( "from %1%.Configurable import *" ) );
668
669 // db file part
670 db << "## -*- ascii -*- \n"
671 << "# db file automatically generated by genconf on: " << now << "\n"
672 << flush;
673 }
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:120
Gaudi::Time::current
static Time current()
Returns the current time.
Definition: Time.cpp:112
std::string
STL class.
configGenerator::m_importDataObjectHandles
bool m_importDataObjectHandles
Definition: genconf.cpp:158
std::flush
T flush(T...args)
configGenerator::genImport
void genImport(std::ostream &s, const boost::format &frmt, std::string indent)
Definition: genconf.cpp:620
configGenerator::m_importGaudiHandles
bool m_importGaudiHandles
switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the compon...
Definition: genconf.cpp:157
Gaudi::Time::format
std::string format(bool local, std::string spec="%c") const
Format the time using strftime.
Definition: Time.cpp:260

void configGenerator::genImport | ( | std::ostream & | s,
|  | const boost::format & | frmt,
|  | std::string | indent = `""`
| ) |  |
| private

Definition at line 620 of file genconf.cpp.

621 {
622
623 std::string::size_type pos = 0, nxtpos = 0;
624 std::string mod;
625
626 while ( std::string::npos != pos ) {
627 // find end of module name
628 nxtpos = m_configurable[component_t::Module].find_first_of( ',', pos );
629
630 // Prepare import string
631 mod = m_configurable[component_t::Module].substr( pos, nxtpos - pos );
632 std::ostringstream import;
633 import << boost::format( frmt ) % mod;
634
635 // append a normal import or a try/except enclosed one depending
636 // on availability of a fall-back module (next in the list)
637 if ( std::string::npos == nxtpos ) {
638 // last possible module
639 s << indent << import.str() << "\n" << flush;
640 pos = std::string::npos;
641 } else {
642 // we have a fallback for this
643 s << indent << "try:\n" << indent << py_tab << import.str() << "\n" << indent << "except ImportError:\n" << flush;
644 pos = nxtpos + 1;
645 }
646 // increase indentation level for next iteration
647 indent += py_tab;
648 }
649 }
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:120
Gaudi.CommonGaudiConfigurables.mod
mod
Definition: CommonGaudiConfigurables.py:22
std::string
STL class.
std::ostringstream
STL class.
std::flush
T flush(T...args)
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::genTrailer | ( | std::ostream & | pyOut,
|  | std::ostream & | dbOut
| ) |  |
| private

Definition at line 675 of file genconf.cpp.

677 {
678 // db file part
679 db << "## " << m_pkgName << "\n" << std::flush;
680 }
std::flush
T flush(T...args)
configGenerator::m_pkgName
string m_pkgName
name of the package we are processing
Definition: genconf.cpp:146

void configGenerator::pythonizeValue | ( | const PropertyBase * | prop,
|  | string & | pvalue,
|  | string & | ptype
| ) |  |
| private

handle the "marshalling" of Properties

Definition at line 744 of file genconf.cpp.

746 {
747 const std::string cvalue = p->toString();
748 const std::type_index ti = std::type_index( *p->type_info() );
749 if ( ti == typeIndex<bool>() ) {
750 pvalue = ( cvalue == "0" || cvalue == "False" || cvalue == "false" ) ? "False" : "True";
751 ptype = "bool";
752 } else if ( ti == typeIndex<char>() || ti == typeIndex<signed char>() || ti == typeIndex<unsigned char>() ||
753 ti == typeIndex<short>() || ti == typeIndex<unsigned short>() || ti == typeIndex<int>() ||
754 ti == typeIndex<unsigned int>() || ti == typeIndex<long>() || ti == typeIndex<unsigned long>() ) {
755 pvalue = cvalue;
756 ptype = "int";
757 } else if ( ti == typeIndex<long long>() || ti == typeIndex<unsigned long long>() ) {
758 pvalue = cvalue + "L";
759 ptype = "long";
760 } else if ( ti == typeIndex<float>() || ti == typeIndex<double>() ) {
761 // forces python to handle this as a float: put a dot in there...
762 pvalue = boost::to_lower_copy( cvalue );
763 if ( pvalue == "nan" ) {
764 pvalue = "float('nan')";
765 std::cout << "WARNING: default value for [" << p->name() << "] is NaN !!" << std::endl;
766 } else if ( std::string::npos == pvalue.find( "." ) && std::string::npos == pvalue.find( "e" ) ) {
767 pvalue = cvalue + ".0";
768 }
769 ptype = "float";
770 } else if ( ti == typeIndex<string>() ) {
771 pvalue = "'" + cvalue + "'";
772 ptype = "str";
773 } else if ( ti == typeIndex<GaudiHandleBase>() ) {
774 const GaudiHandleProperty& hdl = dynamic_cast<const GaudiHandleProperty&>( *p );
775 const GaudiHandleBase& base = hdl.value();
776
777 pvalue = base.pythonRepr();
778 ptype = "GaudiHandle";
779 m_importGaudiHandles = true;
780 } else if ( ti == typeIndex<GaudiHandleArrayBase>() ) {
781 const GaudiHandleArrayProperty& hdl = dynamic_cast<const GaudiHandleArrayProperty&>( *p );
782 const GaudiHandleArrayBase& base = hdl.value();
783
784 pvalue = base.pythonRepr();
785 ptype = "GaudiHandleArray";
786 m_importGaudiHandles = true;
787 } else if ( ti == typeIndex<DataObjectHandleBase>() ) {
788 const DataObjectHandleProperty& hdl = dynamic_cast<const DataObjectHandleProperty&>( *p );
789 const DataObjectHandleBase& base = hdl.value();
790
791 pvalue = base.pythonRepr();
792 ptype = "DataObjectHandleBase";
793 m_importDataObjectHandles = true;
794 } else {
795 std::ostringstream v_str;
796 v_str.setf( std::ios::showpoint ); // to correctly display floats
797 p->toStream( v_str );
798 pvalue = v_str.str();
799 ptype = "list";
800 }
801 }
std::ostringstream::setf
T setf(T...args)
std::endl
T endl(T...args)
GaudiHandleProperty
Definition: Property.h:828
DataObjectHandleProperty
DataObjectHandleProperty.h GaudiKernel/DataObjectHandleProperty.h.
Definition: DataObjectHandleProperty.h:23
std::string
STL class.
configGenerator::m_importDataObjectHandles
bool m_importDataObjectHandles
Definition: genconf.cpp:158
std::ostringstream
STL class.
std::type_index
GaudiHandleProperty::value
const GaudiHandleBase & value() const
Definition: Property.h:851
std::ostringstream::str
T str(T...args)
GaudiHandleArrayProperty::value
const GaudiHandleArrayBase & value() const
Definition: Property.h:891
GaudiHandleArrayBase::pythonRepr
std::string pythonRepr() const override
Python representation of array of handles, i.e.
Definition: GaudiHandle.cpp:86
std::string::find
T find(T...args)
GaudiHandleArrayBase
Base class of array&#39;s of various gaudihandles.
Definition: GaudiHandle.h:351
DataObjectHandleBase
DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.
Definition: DataObjectHandleBase.h:25
GaudiHandleBase::pythonRepr
std::string pythonRepr() const override
Python representation of handle, i.e.
Definition: GaudiHandle.cpp:53
configGenerator::m_importGaudiHandles
bool m_importGaudiHandles
switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the compon...
Definition: genconf.cpp:157
DataObjectHandleBase::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandleBase.cpp:118
DataObjectHandleProperty::value
const DataObjectHandleBase & value() const
Definition: DataObjectHandleProperty.cpp:94
GaudiHandleBase
Base class to handles to be used in lieu of naked pointers to various Gaudi components.
Definition: GaudiHandle.h:93
GaudiHandleArrayProperty
Definition: Property.h:868
std::cout

void configGenerator::setConfigurableAlgorithm | ( | const std::string & | cfgAlgorithm | ) |
| inline

customize the configurable base class for Algorithm component

Definition at line 195 of file genconf.cpp.

196 {
197 m_configurable[component_t::Algorithm] = cfgAlgorithm;
198 }
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::setConfigurableAlgTool | ( | const std::string & | cfgAlgTool | ) |
| inline

customize the configurable base class for AlgTool component

Definition at line 201 of file genconf.cpp.

201 { m_configurable[component_t::AlgTool] = cfgAlgTool; }
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::setConfigurableAuditor | ( | const std::string & | cfgAuditor | ) |
| inline

customize the configurable base class for AlgTool component

Definition at line 204 of file genconf.cpp.

204 { m_configurable[component_t::Auditor] = cfgAuditor; }
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::setConfigurableDefaultName | ( | const std::string & | defaultName | ) |
| inline

customize the default name for configurable instances

Definition at line 189 of file genconf.cpp.

190 {
191 m_configurable[component_t::DefaultName] = defaultName;
192 }
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::setConfigurableModule | ( | const std::string & | moduleName | ) |
| inline

customize the Module name where configurable base classes are defined

Definition at line 186 of file genconf.cpp.

186 { m_configurable[component_t::Module] = moduleName; }
System::moduleName
GAUDI_API const std::string & moduleName()
Get the name of the (executable/DLL) file without file-type.
Definition: ModuleInfo.cpp:54
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

void configGenerator::setConfigurableService | ( | const std::string & | cfgService | ) |
| inline

customize the configurable base class for Service component

Definition at line 207 of file genconf.cpp.

208 {
209 m_configurable[component_t::Service] = cfgService;
210 m_configurable[component_t::ApplicationMgr] = cfgService;
211 }
configGenerator::m_configurable
std::map< component_t, std::string > m_configurable
Configurable customization.
Definition: genconf.cpp:171

## Member Data Documentation

std::map<component_t, std::string> configGenerator::m_configurable
| private

Configurable customization.

Contains customization for:

- Name of the module where configurable base classes are defined
- Name of the configurable base class for the Algorithm component
- Name of the configurable base class for the AlgTool component
- Name of the configurable base class for the Service component

Definition at line 171 of file genconf.cpp.

stringstream configGenerator::m_dbBuf
| private

buffer of generated configurables informations for the "Db" file The "Db" file is holding informations about the generated configurables This file is later one used by the PropertyProxy.py to locate Configurables and know their default values, host module,...

Definition at line 164 of file genconf.cpp.

bool configGenerator::m_importDataObjectHandles = false
| private

Definition at line 158 of file genconf.cpp.

bool configGenerator::m_importGaudiHandles = false
| private

switch to decide if the generated configurables need to import GaudiHandles (ie: if one of the components has a XyzHandle<T>)

Definition at line 157 of file genconf.cpp.

string configGenerator::m_outputDirName
| private

absolute path to the directory where genconf will store auto-generated files (Configurables and ConfigurableDb)

Definition at line 150 of file genconf.cpp.

string configGenerator::m_pkgName
| private

name of the package we are processing

Definition at line 146 of file genconf.cpp.

stringstream configGenerator::m_pyBuf
| private

buffer of auto-generated configurables

Definition at line 153 of file genconf.cpp.

The documentation for this class was generated from the following file:

- GaudiKernel/src/Util/genconf.cpp