PropertyHolder< BASE > Class Template Reference

Helper class to implement the IProperty interface. More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/GaudiKernel/PropertyHolder.h>

Inheritance diagram for PropertyHolder< BASE >:

Collaboration diagram for PropertyHolder< BASE >:

Classes
struct	RemProperty

Public Types
using	PropertyHolderImpl = PropertyHolder< BASE >
	Typedef used to refer to this class from derived classes, as in. More...

Public Member Functions
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property. More...
template<typename TYPE , typename = std::enable_if_t<!Gaudi::Details::is_gaudi_property<TYPE>::value>>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property. More...
template<class TYPE , class VERIFIER , class HANDLERS >
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation. More...
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property. More...
StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name More...
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string More...
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation More...
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property More...
const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name More...
StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string More...
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties More...
bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name. More...
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected More...
void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property. More...
virtual StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p)=0
	Set the property from a property with a different name. More...
virtual StatusCode	setProperty (const std::string &s)=0
	Set the property by string. More...
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals. More...
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string. More...
template<class TYPE , typename = std::enable_if_t<!std::is_base_of_v<Gaudi::Details::PropertyBase, TYPE>>>
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
	PropertyHolder (const PropertyHolder &)=delete
PropertyHolder &	operator= (const PropertyHolder &)=delete

Private Types
typedef std::vector< Gaudi::Details::PropertyBase * >	Properties
typedef std::vector< RemProperty >	RemoteProperties

Private Member Functions
Gaudi::Details::PropertyBase *	property (std::string_view name, const std::vector< Gaudi::Details::PropertyBase * > &props) const
	get the property by name form the proposed list More...
void	assertUniqueName (std::string_view name) const
	Issue a runtime warning if the name is already present in the list of properties (see GAUDI-1023). More...

Private Attributes
Properties	m_properties
	Collection of all declared properties. More...
RemoteProperties	m_remoteProperties
	Collection of all declared remote properties. More...
std::vector< std::unique_ptr< Gaudi::Details::PropertyBase > >	m_todelete
	Properties owned by PropertyHolder, to be deleted. More...

Detailed Description

template<class BASE>
class PropertyHolder< BASE >

Helper class to implement the IProperty interface.

PropertyHolder is used by components base classes (Algorithm, Service, etc.) to provide a default implementation the IProperty interface.

When needing to implement the IProperty interface in a class, it is enough to wrap the base of the class with PropertyHolder, as in

class MyClass : public PropertyHolder<BaseClass> {
  // ...
};

where BaseClass should inherit from IProperty and INamedInterface.

Author

Paul Maley

David Quarrie

Marco Clemencic

Definition at line 82 of file PropertyHolder.h.

Member Typedef Documentation

Properties

template<class BASE >

typedef std::vector<Gaudi::Details::PropertyBase*> PropertyHolder< BASE >::Properties

private

Definition at line 282 of file PropertyHolder.h.

PropertyHolderImpl

template<class BASE >

using PropertyHolder< BASE >::PropertyHolderImpl = PropertyHolder<BASE>

Typedef used to refer to this class from derived classes, as in.

class MyClass : public PropertyHolder<BaseClass> {
  using PropertyHolderImpl::declareProperty;
};

Definition at line 93 of file PropertyHolder.h.

RemoteProperties

template<class BASE >

typedef std::vector<RemProperty> PropertyHolder< BASE >::RemoteProperties

private

Definition at line 288 of file PropertyHolder.h.

Constructor & Destructor Documentation

PropertyHolder() [1/2]

template<class BASE >

PropertyHolder< BASE >::PropertyHolder ( )

default

PropertyHolder() [2/2]

template<class BASE >

PropertyHolder< BASE >::PropertyHolder ( const PropertyHolder< BASE > &  )

delete

prevent copies

Member Function Documentation

assertUniqueName()

template<class BASE >

void PropertyHolder< BASE >::assertUniqueName ( std::string_view  name ) const

inlineprivate

Issue a runtime warning if the name is already present in the list of properties (see GAUDI-1023).

Definition at line 272 of file PropertyHolder.h.

                                                     {
    if ( hasProperty( name ) ) {
      auto msgSvc = Gaudi::svcLocator()->service<IMessageSvc>( "MessageSvc" );
      if ( !msgSvc ) std::cerr << "error: cannot get MessageSvc!" << std::endl;
      MsgStream log( msgSvc, this->name() );
      log << MSG::WARNING << "duplicated property name '" << name << "', see https://its.cern.ch/jira/browse/GAUDI-1023"
          << endmsg;
    }
  }

bindPropertiesTo()

template<class BASE >

void PropertyHolder< BASE >::bindPropertiesTo ( Gaudi::Interfaces::IOptionsSvc &  optsSvc )

inline

Definition at line 252 of file PropertyHolder.h.

                                                               {
    auto set_prop = [&optsSvc, this]( auto prop ) { optsSvc.bind( this->name(), prop ); };
    std::for_each( begin( m_properties ), end( m_properties ), set_prop );
    std::for_each( begin( m_remoteProperties ), end( m_remoteProperties ), [&set_prop, this]( auto& rem ) {
      if ( rem.owner ) set_prop( this->property( rem.remName, rem.owner->getProperties() ) );
    } );
  }

declareProperty() [1/3]

template<class BASE >

template<class TYPE , class VERIFIER , class HANDLERS >

Gaudi::Details::PropertyBase* PropertyHolder< BASE >::declareProperty ( const std::string &  name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &  prop, const std::string &  doc = "none"  )

inline

Declare a PropertyBase instance setting name and documentation.

Deprecated:

Prefer the signatures using a fully initialized PropertyBase instance.

Definition at line 127 of file PropertyHolder.h.

                                                                                                         {
    Gaudi::Details::PropertyBase* p = ∝
    p->setName( name );
 
    p->setDocumentation( doc );
    return &declareProperty( *p );
  }

declareProperty() [2/3]

template<class BASE >

template<typename TYPE , typename = std::enable_if_t<!Gaudi::Details::is_gaudi_property<TYPE>::value>>

Gaudi::Details::PropertyBase* PropertyHolder< BASE >::declareProperty ( const std::string &  name, TYPE &  value, const std::string &  doc = "none"  )

inline

Helper to wrap a regular data member and use it as a regular property.

Deprecated:

Prefer the signatures using a a fully initialized PropertyBase instance.

Definition at line 115 of file PropertyHolder.h.

                                                                                 {
    m_todelete.push_back( std::make_unique<Gaudi::Details::PropertyType<TYPE&>>( name, value ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
    p->setDocumentation( doc );
    return &declareProperty( *p );
  }

declareProperty() [3/3]

template<class BASE >

Gaudi::Details::PropertyBase& PropertyHolder< BASE >::declareProperty ( Gaudi::Details::PropertyBase &  prop )

inline

Declare a property.

Record a PropertyBase instance to be managed by PropertyHolder.

Definition at line 106 of file PropertyHolder.h.

                                                                                     {
    assertUniqueName( prop.name() );
    m_properties.push_back( &prop );
    return prop;
  }

declareRemoteProperty()

template<class BASE >

Gaudi::Details::PropertyBase* PropertyHolder< BASE >::declareRemoteProperty ( const std::string &  name, IProperty *  rsvc, const std::string &  rname = ""  )

inline

Declare a remote property.

Bind name to the property rname of rsvc.

Definition at line 139 of file PropertyHolder.h.

                                                                                     {
    if ( !rsvc ) return nullptr;
    const std::string&            nam = rname.empty() ? name : rname;
    Gaudi::Details::PropertyBase* p   = property( nam, rsvc->getProperties() );
    m_remoteProperties.emplace_back( RemProperty{ name, rsvc, nam } );
    return p;
  }

getProperties()

template<class BASE >

const std::vector<Gaudi::Details::PropertyBase*>& PropertyHolder< BASE >::getProperties ( ) const

inlineoverride

get all properties

See also

IProperty

Definition at line 222 of file PropertyHolder.h.

{ return m_properties; }

getProperty() [1/3]

template<class BASE >

StatusCode PropertyHolder< BASE >::getProperty ( Gaudi::Details::PropertyBase *  p ) const

inlineoverride

get the property

See also

IProperty

Definition at line 190 of file PropertyHolder.h.

                                                                       {
    try {
      const Gaudi::Details::PropertyBase* pp = property( p->name() );
      if ( pp && pp->load( *p ) ) return StatusCode::SUCCESS;
    } catch ( ... ) {}
    return StatusCode::FAILURE;
  }

getProperty() [2/3]

template<class BASE >

StatusCode PropertyHolder< BASE >::getProperty ( std::string_view  n, std::string &  v  ) const

inlineoverride

convert the property to the string

See also

IProperty

Definition at line 210 of file PropertyHolder.h.

                                                                          {
    // get the property
    const Gaudi::Details::PropertyBase* p = property( n );
    if ( !p ) return StatusCode::FAILURE;
    // convert the value into the string
    v = p->toString();
    return StatusCode::SUCCESS;
  }

getProperty() [3/3]

template<class BASE >

const Gaudi::Details::PropertyBase& PropertyHolder< BASE >::getProperty ( std::string_view  name ) const

inlineoverride

get the property by name

See also

IProperty

Definition at line 201 of file PropertyHolder.h.

                                                                                    {
    const Gaudi::Details::PropertyBase* p = property( name );
    if ( !p ) throw std::out_of_range( "Property " + std::string{ name } + " not found." );
    return *p;
  }

hasProperty()

template<class BASE >

bool PropertyHolder< BASE >::hasProperty ( std::string_view  name ) const

inlineoverride

Return true if we have a property with the given name.

See also

IProperty

Definition at line 227 of file PropertyHolder.h.

                                                         {
    return any_of( begin( m_properties ), end( m_properties ),
                   [&name]( const Gaudi::Details::PropertyBase* prop ) {
                     return Gaudi::Utils::iequal( prop->name(), name );
                   } ) ||
           any_of( begin( m_remoteProperties ), end( m_remoteProperties ),
                   [&name]( const auto& prop ) { return Gaudi::Utils::iequal( prop.name, name ); } );
  }

operator=()

template<class BASE >

PropertyHolder& PropertyHolder< BASE >::operator= ( const PropertyHolder< BASE > &  )

delete

property() [1/2]

template<class BASE >

Gaudi::Details::PropertyBase* PropertyHolder< BASE >::property ( std::string_view  name ) const

inline

\fixme property and bindPropertiesTo should be protected

Definition at line 238 of file PropertyHolder.h.

                                                                  {
    // local property ?
    Gaudi::Details::PropertyBase* lp = property( name, m_properties );
    if ( lp ) return lp;
    // look for remote property
    for ( const auto& it : m_remoteProperties ) {
      if ( !Gaudi::Utils::iequal( it.name, name ) ) continue;
      const IProperty* p = it.owner;
      if ( !p ) continue;
      return property( it.remName, p->getProperties() );
    }
    return nullptr; // RETURN
  }

property() [2/2]

template<class BASE >

Gaudi::Details::PropertyBase* PropertyHolder< BASE >::property ( std::string_view  name, const std::vector< Gaudi::Details::PropertyBase * > &  props  ) const

inlineprivate

get the property by name form the proposed list

Definition at line 262 of file PropertyHolder.h.

                                                                                                    {
    auto it = std::find_if( props.begin(), props.end(), [name]( Gaudi::Details::PropertyBase* p ) {
      return p && Gaudi::Utils::iequal( p->name(), name );
    } );
    return ( it != props.end() ) ? *it : nullptr; // RETURN
  }

setProperty() [1/8]

template<class BASE >

StatusCode IProperty::setProperty

inline

Set the property from a property.

Definition at line 39 of file IProperty.h.

{ return setProperty( p.name(), p ); }

setProperty() [2/8]

template<class BASE >

StatusCode IProperty::setProperty

inline

Special case for string literals.

Definition at line 47 of file IProperty.h.

{ return setProperty( name, std::string{ v } ); }

setProperty() [3/8]

template<class BASE >

StatusCode PropertyHolder< BASE >::setProperty ( const std::string &  name, const Gaudi::Details::PropertyBase &  p  )

inlineoverride

set the property from another property with a different name

See also

IProperty

Definition at line 157 of file PropertyHolder.h.

                                                                                              {
    Gaudi::Details::PropertyBase* pp = property( name );
    if ( pp && pp->assign( p ) ) return StatusCode::SUCCESS;
    return StatusCode::FAILURE;
  }

setProperty() [4/8]

template<class BASE >

virtual StatusCode IProperty::setProperty

Set the property from a property with a different name.

setProperty() [5/8]

template<class BASE >

StatusCode IProperty::setProperty

inline

Special case for std::string.

Definition at line 49 of file IProperty.h.

                                                                      {
    if ( !hasProperty( name ) ) return StatusCode::FAILURE;
    return setPropertyRepr( name, v );
  }

setProperty() [6/8]

template<class BASE >

template<class TYPE , typename = std::enable_if_t<!std::is_base_of_v<Gaudi::Details::PropertyBase, TYPE>>>

StatusCode IProperty::setProperty ( class TYPE  , typename  = std::enable_if_t<!std::is_base_of_v<Gaudi::Details::PropertyBase, TYPE>>  )

inline

set the property form the value

std::vector<double> data = ... ;
setProperty( "Data" , data ) ;
 
std::map<std::string,double> cuts = ... ;
setProperty( "Cuts" , cuts ) ;
 
std::map<std::string,std::string> dict = ... ;
setProperty( "Dictionary" , dict ) ;

Note: the interface IProperty allows setting of the properties either directly from other properties or from strings only

This is very convenient in resetting of the default properties in the derived classes.

Parameters

name	name of the property
value	value of the property

See also

Gaudi::Utils::setProperty

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2007-05-13

Definition at line 82 of file IProperty.h.

                                                                     {
    using Gaudi::Utils::toString;
    if ( !hasProperty( name ) ) return StatusCode::FAILURE;
    return setPropertyRepr( name, toString( value ) );
  }

setProperty() [7/8]

template<class BASE >

StatusCode PropertyHolder< BASE >::setProperty ( const std::string &  s )

inlineoverride

set the property from the formatted string

See also

IProperty

Definition at line 166 of file PropertyHolder.h.

                                                        {
    std::string name;
    std::string value;
    StatusCode  sc = Gaudi::Parsers::parse( name, value, s );
    if ( sc.isFailure() ) return sc;
    return setPropertyRepr( name, value );
  }

setProperty() [8/8]

template<class BASE >

virtual StatusCode IProperty::setProperty

Set the property by string.

setPropertyRepr()

template<class BASE >

StatusCode PropertyHolder< BASE >::setPropertyRepr ( const std::string &  n, const std::string &  r  )

inlineoverride

set the property from name and value string representation

See also

IProperty

@fixme SUCCESS is not required to be checked for compatibility with Gaudi::Utils::setProperty

Definition at line 177 of file PropertyHolder.h.

                                                                                {
    try {
      Gaudi::Details::PropertyBase* p = property( n );
      return ( p && p->fromString( r ) ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
    } catch ( const std::invalid_argument& err ) {
      throw GaudiException{ "error setting property " + n, this->name(), StatusCode::FAILURE, err };
    }
  }

Member Data Documentation

m_properties

template<class BASE >

Properties PropertyHolder< BASE >::m_properties

private

Collection of all declared properties.

Definition at line 291 of file PropertyHolder.h.

m_remoteProperties

template<class BASE >

RemoteProperties PropertyHolder< BASE >::m_remoteProperties

private

Collection of all declared remote properties.

Definition at line 293 of file PropertyHolder.h.

m_todelete

template<class BASE >

std::vector<std::unique_ptr<Gaudi::Details::PropertyBase> > PropertyHolder< BASE >::m_todelete

private

Properties owned by PropertyHolder, to be deleted.

Definition at line 295 of file PropertyHolder.h.

---

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

• GaudiKernel/include/GaudiKernel/PropertyHolder.h