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

#include <GaudiKernel/PropertyHolder.h>

Inheritance diagram for PropertyHolder< BASE >:

Collaboration diagram for PropertyHolder< BASE >:

[legend]

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

Public Member Functions
	PropertyHolder ()=default

	~PropertyHolder () override=default

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property. More...

template<class TYPE , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase, TYPE>::value && !std::is_base_of<GaudiHandleArrayBase, TYPE>::value && !std::is_base_of<DataObjectHandleBase, TYPE>::value>::type>
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 , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase, TYPE>::value && !std::is_base_of<GaudiHandleArrayBase, TYPE>::value && !std::is_base_of<DataObjectHandleBase, TYPE>::value>::type>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none") const

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


Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, GaudiHandleBase &ref, const std::string &doc="none")
	Specializations for various GaudiHandles. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, GaudiHandleArrayBase &ref, const std::string &doc="none")

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, DataObjectHandleBase &ref, const std::string &doc="none")

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

Member Typedef Documentation

template<class BASE>

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

private

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

template<class BASE>

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

private

Definition at line 392 of file PropertyHolder.h.

template<class BASE>

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

private

Definition at line 391 of file PropertyHolder.h.

Constructor & Destructor Documentation

template<class BASE>

PropertyHolder< BASE >::PropertyHolder ( )

default

template<class BASE>

PropertyHolder< BASE >::~PropertyHolder ( )

overridedefault

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

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

template<class BASE>

template<class TYPE , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase, TYPE>::value && !std::is_base_of<GaudiHandleArrayBase, TYPE>::value && !std::is_base_of<DataObjectHandleBase, TYPE>::value>::type>

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

   {
     assertUniqueName( name );
     m_todelete.emplace_back( new Gaudi::Property<TYPE&>( name, value ) );
     Gaudi::Details::PropertyBase* p = m_todelete.back().get();
     p->setDocumentation( doc );
     m_properties.push_back( p );
     return p;
   }

template<class BASE>

template<class TYPE , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase, TYPE>::value && !std::is_base_of<GaudiHandleArrayBase, TYPE>::value && !std::is_base_of<DataObjectHandleBase, TYPE>::value>::type>

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

inline

Deprecated:: Kept for backward compatibility, use the non-const version instead, will be removed in v29r0.

Definition at line 128 of file PropertyHolder.h.

   {
     return const_cast<PropertyHolder*>( this )->declareProperty<TYPE>( name, value, doc );
   }

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

   {
     assertUniqueName( name );
     Gaudi::Details::PropertyBase* p = &prop;
     p->setName( name );
     p->setDocumentation( doc );
     m_properties.push_back( p );
     return p;
   }

template<class BASE>

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

inline

Specializations for various GaudiHandles.

Definition at line 164 of file PropertyHolder.h.

   {
     assertUniqueName( name );
     m_todelete.emplace_back( new GaudiHandleProperty( name, ref ) );
     Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
     p->setDocumentation( doc );
     m_properties.push_back( p );
 
     return p;
   }

template<class BASE>

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

inline

Definition at line 176 of file PropertyHolder.h.

   {
     assertUniqueName( name );
     m_todelete.emplace_back( new GaudiHandleArrayProperty( name, ref ) );
     Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
     p->setDocumentation( doc );
     m_properties.push_back( p );
 
     return p;
   }

template<class BASE>

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

inline

Definition at line 188 of file PropertyHolder.h.

   {
     assertUniqueName( name );
     m_todelete.emplace_back( new DataObjectHandleProperty( name, ref ) );
     Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
     p->setDocumentation( doc );
     m_properties.push_back( p );
 
     return 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 150 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 329 of file PropertyHolder.h.

329 { return m_properties; }

PropertyHolder::m_properties

Properties m_properties

Collection of all declared properties.

Definition: PropertyHolder.h:395

template<class BASE>

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

inlineoverride

get the property

See also: IProperty

Definition at line 291 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 304 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 314 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 334 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 343 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 366 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 208 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 223 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 237 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 283 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 395 of file PropertyHolder.h.

template<class BASE>

RemoteProperties PropertyHolder< BASE >::m_remoteProperties

private

Collection of all declared remote properties.

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

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

GaudiKernel/GaudiKernel/PropertyHolder.h

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<class BASE> class PropertyHolder< BASE >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class BASE>
class PropertyHolder< BASE >