PropertyHolder< BASE > Class Template Reference

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

#include <GaudiKernel/PropertyHolder.h>

Inheritance diagram for PropertyHolder< BASE >:

Collaboration diagram for PropertyHolder< BASE >:

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 Gaudi::Details::PropertyBase &p) override
	set the property form another property More...
StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string More...
StatusCode	setProperty (const std::string &n, const std::string &v) override
	set the property from name and the value More...
template<class TYPE >
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property More...
const Gaudi::Details::PropertyBase &	getProperty (const std::string &name) const override
	get the property by name More...
StatusCode	getProperty (const std::string &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 (const std::string &name) const override
	Return true if we have a property with the given name. More...
	PropertyHolder (const PropertyHolder &)=delete
PropertyHolder &	operator= (const PropertyHolder &)=delete

Protected Member Functions
Gaudi::Details::PropertyBase *	property (const std::string &name) const

Private Types
typedef std::vector< Gaudi::Details::PropertyBase * >	Properties
typedef std::pair< std::string, std::pair< IProperty *, std::string > >	RemProperty
typedef std::vector< RemProperty >	RemoteProperties

Private Member Functions
Gaudi::Details::PropertyBase *	property (const std::string &name, const std::vector< Gaudi::Details::PropertyBase * > &props) const
	get the property by name form the proposed list More...
void	assertUniqueName (const std::string &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 71 of file PropertyHolder.h.

Member Typedef Documentation

template<class BASE>

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

private

Definition at line 300 of file PropertyHolder.h.

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

template<class BASE>

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

private

Definition at line 302 of file PropertyHolder.h.

template<class BASE>

typedef std::pair<std::string, std::pair<IProperty*, std::string> > PropertyHolder< BASE >::RemProperty

private

Definition at line 301 of file PropertyHolder.h.

Constructor & Destructor Documentation

template<class BASE>

PropertyHolder< BASE >::PropertyHolder ( )

default

template<class BASE>

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

delete

prevent copies

Member Function Documentation

template<class BASE>

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

inlineprivate

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

Definition at line 290 of file PropertyHolder.h.

                                                       {
    if ( UNLIKELY( 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;
    }
  }

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

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

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 104 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 );
  }

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

                                                                                                         {
    Gaudi::Details::PropertyBase* p = ∝
    p->setName( name );

    p->setDocumentation( doc );
    return &declareProperty( *p );
  }

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 128 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( name, std::make_pair( rsvc, nam ) );
    return p;
  }

template<class BASE>

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

inlineoverride

get all properties

See also

IProperty

Definition at line 251 of file PropertyHolder.h.

{ return m_properties; }

template<class BASE>

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

inlineoverride

get the property

See also

IProperty

Definition at line 219 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;
  }

template<class BASE>

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

inlineoverride

get the property by name

See also

IProperty

Definition at line 230 of file PropertyHolder.h.

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

template<class BASE>

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

inlineoverride

convert the property to the string

See also

IProperty

Definition at line 239 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;
  }

template<class BASE>

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

inlineoverride

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

See also

IProperty

Definition at line 256 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 );
    } );
  }

template<class BASE>

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

delete

template<class BASE>

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

inlineprotected

Definition at line 264 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.first, name ) ) continue;
      const IProperty* p = it.second.first;
      if ( !p ) continue;
      return property( it.second.second, p->getProperties() );
    }
    return nullptr; // RETURN
  }

template<class BASE>

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

inlineprivate

get the property by name form the proposed list

Definition at line 280 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
  }

template<class BASE>

StatusCode PropertyHolder< BASE >::setProperty ( const Gaudi::Details::PropertyBase &  p )

inlineoverride

set the property form another property

See also

IProperty

Definition at line 145 of file PropertyHolder.h.

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

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

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

template<class BASE>

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

inlineoverride

set the property from name and the value

See also

IProperty

Definition at line 167 of file PropertyHolder.h.

                                                                            {
    Gaudi::Details::PropertyBase* p = property( n );
    return ( p && p->fromString( v ) ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }

template<class BASE>

template<class TYPE >

StatusCode PropertyHolder< BASE >::setProperty ( const std::string &  name, const TYPE &  value  )

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. E.g. without this method one needs to convert everything into strings to use IProperty::setProperty

setProperty ( "OutputLevel" , "1"    ) ;
setProperty ( "Enable"      , "True" ) ;
setProperty ( "ErrorMax"    , "10"   ) ;

For simple cases it is more or less ok, but for complicated properties it is just ugly..

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

                                                                     {
    return Gaudi::Utils::setProperty( this, name, value );
  }

Member Data Documentation

template<class BASE>

Properties PropertyHolder< BASE >::m_properties

private

Collection of all declared properties.

Definition at line 305 of file PropertyHolder.h.

template<class BASE>

RemoteProperties PropertyHolder< BASE >::m_remoteProperties

private

Collection of all declared remote properties.

Definition at line 307 of file PropertyHolder.h.

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

---

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

• GaudiKernel/GaudiKernel/PropertyHolder.h