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 >
	requires (!Gaudi::Details::is_gaudi_property_v< TYPE >) Gaudi
	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...
	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 68 of file PropertyHolder.h.

Member Typedef Documentation

Properties

template<class BASE >

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

private

Definition at line 268 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 79 of file PropertyHolder.h.

RemoteProperties

template<class BASE >

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

private

Definition at line 274 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 258 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 238 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/2]

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 121 of file PropertyHolder.h.

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

declareProperty() [2/2]

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 92 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 133 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 210 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 181 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 199 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 191 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 214 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 224 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;
  }

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 248 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;
  }

requires()

template<class BASE >

template<typename TYPE >

PropertyHolder< BASE >::requires ( !Gaudi::Details::is_gaudi_property_v< TYPE >  )

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 101 of file PropertyHolder.h.

                                                                                 {
    auto make_property = [&]( const std::string& n, TYPE& v ) {
      if constexpr ( requires { typename TYPE::PropertyType; } ) {
        return std::make_unique<typename TYPE::PropertyType>( n, v );
      } else {
        return std::make_unique<Gaudi::Property<TYPE&>>( n, v );
      }
    };
    m_todelete.push_back( make_property( name, value ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
    p->setDocumentation( doc );
    return &declareProperty( *p );
  }

setProperty() [1/7]

template<class BASE >

StatusCode IProperty::setProperty

inline

Set the property from a property.

Definition at line 38 of file IProperty.h.

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

setProperty() [2/7]

template<class BASE >

StatusCode IProperty::setProperty

inline

Special case for string literals.

Definition at line 46 of file IProperty.h.

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

setProperty() [3/7]

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 151 of file PropertyHolder.h.

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

setProperty() [4/7]

template<class BASE >

virtual StatusCode IProperty::setProperty

Set the property from a property with a different name.

setProperty() [5/7]

template<class BASE >

StatusCode IProperty::setProperty

inline

Special case for std::string.

Definition at line 48 of file IProperty.h.

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

setProperty() [6/7]

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 159 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() [7/7]

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 169 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 277 of file PropertyHolder.h.

m_remoteProperties

template<class BASE >

RemoteProperties PropertyHolder< BASE >::m_remoteProperties

private

Collection of all declared remote properties.

Definition at line 279 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 281 of file PropertyHolder.h.

---

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

• GaudiKernel/include/GaudiKernel/PropertyHolder.h