Implementation of property with value of concrete type. More...

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

Inheritance diagram for Gaudi::Property< TYPE, VERIFIER, HANDLERS >:

Collaboration diagram for Gaudi::Property< TYPE, VERIFIER, HANDLERS >:

[legend]

Public Types
using	StorageType = TYPE
	Hosted type. More...

using	ValueType = typename std::remove_reference< StorageType >::type

using	VerifierType = VERIFIER

using	HandlersType = HANDLERS

Public Member Functions
template<class T = StorageType>
	Property (std::string name, T &&value, std::string doc="", std::string semantics="")
	the constructor with property name, value and documentation. More...

template<typename OWNER , typename T = ValueType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>, typename = std::enable_if_t<std::is_default_constructible_v<T>>>
	Property (OWNER *owner, std::string name)
	Autodeclaring constructor with property name, value and documentation. More...

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	Property (OWNER *owner, std::string name, T &&value, std::string doc="", std::string semantics="")
	Autodeclaring constructor with property name, value and documentation. More...

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	Property (OWNER *owner, std::string name, T &&value, std::function< void(PropertyBase &)> handler, std::string doc="", std::string semantics="")
	Autodeclaring constructor with property name, value, updateHandler and documentation. More...

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	Property (OWNER owner, std::string name, T &&value, void(OWNER::handler)(PropertyBase &), std::string doc="", std::string semantics="")
	Autodeclaring constructor with property name, value, pointer to member function updateHandler and documentation. More...

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	Property (OWNER owner, std::string name, T &&value, void(OWNER::handler)(), std::string doc="", std::string semantics="")
	Autodeclaring constructor with property name, value, pointer to member function updateHandler and documentation. More...

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	Property (OWNER *owner, std::string name, T &&value, std::function< void(PropertyBase &)> handler, Details::Property::ImmediatelyInvokeHandler invoke, std::string doc="", std::string semantics="")
	Autodeclaring constructor with property name, value, updateHandler and documentation. More...

template<typename T , typename = not_copying<T>>
	Property (T &&v)
	Construct an anonymous property from a value. More...

template<typename T = StorageType, typename = std::enable_if_t<!std::is_reference_v<T>>>
	Property ()
	Construct an anonymous property with default constructed value. More...

Details::PropertyBase &	declareReadHandler (std::function< void(Details::PropertyBase &)> fun) override
	set new callback for reading More...

Details::PropertyBase &	declareUpdateHandler (std::function< void(Details::PropertyBase &)> fun) override
	set new callback for update More...

const std::function< void(Details::PropertyBase &)>	readCallBack () const override
	get a reference to the readCallBack More...

const std::function< void(Details::PropertyBase &)>	updateCallBack () const override
	get a reference to the updateCallBack More...

bool	useUpdateHandler () override
	manual trigger for callback for update More...

	operator const ValueType & () const
	Automatic conversion to value (const reference). More...

template<typename Dummy = TYPE, typename = std::enable_if_t<std::is_constructible_v<std::string_view, Dummy>>>
	operator std::string_view () const

std::ostream &	fillStream (std::ostream &stream) const override
	Properly quote string properties when printing them. More...

	operator std::string_view () const

template<class T >
bool	operator== (const T &other) const
	equality comparison More...

template<class T >
bool	operator!= (const T &other) const
	inequality comparison More...

template<class T >
bool	operator< (const T &other) const
	"less" comparison More...

template<class T = ValueType>
Property &	operator= (T &&v)
	Assignment from value. More...

const VerifierType &	verifier () const
	Accessor to verifier. More...

VerifierType &	verifier ()
	Accessor to verifier. More...

template<class... Args>
decltype(	operator() (Args &&... args) const noexcept(noexcept(std::declval< ValueType >()(std::declval< Args && >()...))) std::declval< ValueType >()(std::declval< Args && >()...))

bool	assign (const Details::PropertyBase &source) override
	get the value from another property More...

bool	load (Details::PropertyBase &dest) const override
	set value to another property More...

StatusCode	fromString (const std::string &source) override
	string -> value More...

std::string	toString () const override
	value -> string More...

void	toStream (std::ostream &out) const override
	value -> stream More...


const ValueType &	value () const

ValueType &	value ()

bool	setValue (const ValueType &v)

bool	set (const ValueType &v)

Details::PropertyBase *	clone () const override
	clones the current property More...

Helpers for easy use of string and vector properties.
They are instantiated only if they are implemented in the wrapped class.
template<class = ValueType>
Property &	operator++ ()

template<class = ValueType>
ValueType	operator++ (int)

template<class = ValueType>
Property &	operator-- ()

template<class = ValueType>
ValueType	operator-- (int)

template<class T = ValueType>
Property &	operator+= (const T &other)

template<class T = ValueType>
Property &	operator-= (const T &other)

Public Member Functions inherited from Gaudi::Details::PropertyBase
const std::string	name () const
	property name More...

std::string	documentation () const
	property documentation More...

std::string	semantics () const
	property semantics More...

const std::type_info *	type_info () const
	property type-info More...

std::string	type () const
	property type More...

template<class HT >
PropertyBase &	declareReadHandler (void(HT::MF)(PropertyBase &), HT instance)

template<class HT >
PropertyBase &	declareUpdateHandler (void(HT::MF)(PropertyBase &), HT instance)

virtual	~PropertyBase ()
	virtual destructor More...

void	setName (std::string value)
	set the new value for the property name More...

void	setDocumentation (std::string value)
	set the documentation string More...

void	setSemantics (std::string value)
	set the semantics string More...

void	setOwnerType (const std::type_info &ownerType)
	set the type of the owner class (used for documentation) More...

template<class OWNER >
void	setOwnerType ()
	set the type of the owner class (used for documentation) More...

const std::type_info *	ownerType () const
	get the type of the owner class (used for documentation) More...

std::string	ownerTypeName () const
	get the string for the type of the owner class (used for documentation) More...

Private Attributes
StorageType	m_value
	Storage. More...

VerifierType	m_verifier

HandlersType	m_handlers

template<class T >
using	not_copying = std::enable_if_t<!is_this_type_v< T > >

template<class T >
static constexpr bool	is_this_type_v = std::is_same_v<Property, std::remove_reference_t<T>>
	helper typedefs for SFINAE More...

Additional Inherited Members
Protected Member Functions inherited from Gaudi::Details::PropertyBase
	PropertyBase (const std::type_info &type, std::string name="", std::string doc="", std::string semantics="")
	constructor from the property name and the type More...

	PropertyBase (std::string name, const std::type_info &type)
	constructor from the property name and the type More...

	PropertyBase (const PropertyBase &)=default
	copy constructor More...

PropertyBase &	operator= (const PropertyBase &)=default
	assignment operator More...

Detailed Description

template<class TYPE, class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>
class Gaudi::Property< TYPE, VERIFIER, HANDLERS >

Implementation of property with value of concrete type.

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

Date: 2006-02-27

Author: Marco Clemencic

Date: 2016-06-16

Definition at line 39 of file Property.h.

Member Typedef Documentation

◆ HandlersType

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

using Gaudi::Property< TYPE, VERIFIER, HANDLERS >::HandlersType = HANDLERS

Definition at line 46 of file Property.h.

◆ not_copying

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T >

using Gaudi::Property< TYPE, VERIFIER, HANDLERS >::not_copying = std::enable_if_t<!is_this_type_v<T> >

private

Definition at line 59 of file Property.h.

◆ StorageType

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

using Gaudi::Property< TYPE, VERIFIER, HANDLERS >::StorageType = TYPE

Hosted type.

Definition at line 43 of file Property.h.

◆ ValueType

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

using Gaudi::Property< TYPE, VERIFIER, HANDLERS >::ValueType = typename std::remove_reference<StorageType>::type

Definition at line 44 of file Property.h.

◆ VerifierType

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

using Gaudi::Property< TYPE, VERIFIER, HANDLERS >::VerifierType = VERIFIER

Definition at line 45 of file Property.h.

Constructor & Destructor Documentation

◆ Property() [1/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T = StorageType>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	std::string	name,
		T &&	value,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

the constructor with property name, value and documentation.

Definition at line 65 of file Property.h.

         : Details::PropertyBase( typeid( ValueType ), std::move( name ), std::move( doc ), std::move( semantics ) )
         , m_value( std::forward<T>( value ) ) {
       m_verifier( m_value );
     }

◆ Property() [2/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<typename OWNER , typename T = ValueType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>, typename = std::enable_if_t<std::is_default_constructible_v<T>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name
	)

inline

Autodeclaring constructor with property name, value and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 74 of file Property.h.

                                              : Property( std::move( name ), ValueType{}, "" ) {
       owner->declareProperty( *this );
       setOwnerType<OWNER>();
     }

◆ Property() [3/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name,
		T &&	value,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

Autodeclaring constructor with property name, value and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 82 of file Property.h.

         : Property( std::move( name ), std::forward<T>( value ), std::move( doc ), std::move( semantics ) ) {
       owner->declareProperty( *this );
       setOwnerType<OWNER>();
     }

◆ Property() [4/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name,
		T &&	value,
		std::function< void(PropertyBase &)>	handler,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

Autodeclaring constructor with property name, value, updateHandler and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 91 of file Property.h.

         : Property( owner, std::move( name ), std::forward<T>( value ), std::move( doc ), std::move( semantics ) ) {
       declareUpdateHandler( std::move( handler ) );
     }

◆ Property() [5/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name,
		T &&	value,
		void(OWNER::*)(PropertyBase &)	handler,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

Autodeclaring constructor with property name, value, pointer to member function updateHandler and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 100 of file Property.h.

         : Property(
               owner, std::move( name ), std::forward<T>( value ),
               [owner, handler]( PropertyBase& p ) { ( owner->*handler )( p ); }, std::move( doc ),
               std::move( semantics ) ) {}

◆ Property() [6/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name,
		T &&	value,
		void(OWNER::*)()	handler,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

Autodeclaring constructor with property name, value, pointer to member function updateHandler and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 109 of file Property.h.

         : Property(
               owner, std::move( name ), std::forward<T>( value ),
               [owner, handler]( PropertyBase& ) { ( owner->*handler )(); }, std::move( doc ), std::move( semantics ) ) {
     }

◆ Property() [7/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class OWNER , class T = StorageType, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property	(	OWNER *	owner,
		std::string	name,
		T &&	value,
		std::function< void(PropertyBase &)>	handler,
		Details::Property< TYPE, VERIFIER, HANDLERS >::ImmediatelyInvokeHandler	invoke,
		std::string	doc = `""`,
		std::string	semantics = `""`
	)

inline

Autodeclaring constructor with property name, value, updateHandler and documentation.

Note: the use std::enable_if is required to avoid ambiguities

Definition at line 119 of file Property.h.

         : Property( owner, std::move( name ), std::forward<T>( value ), std::move( handler ), std::move( doc ),
                     std::move( semantics ) ) {
       if ( invoke ) useUpdateHandler();
     }

◆ Property() [8/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<typename T , typename = not_copying<T>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property ( T && v )

inline

Construct an anonymous property from a value.

This constructor is not generated if T is the current type, so that the compiler picks up the copy constructor instead of this one.

Definition at line 130 of file Property.h.

130 : Details::PropertyBase( typeid( ValueType ), "", "", "" ), m_value( std::forward<T>( v ) ) {}

◆ Property() [9/9]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<typename T = StorageType, typename = std::enable_if_t<!std::is_reference_v<T>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::Property ( )

inline

Construct an anonymous property with default constructed value.

Can be used only if StorageType is default constructible.

Definition at line 135 of file Property.h.

135 : Details::PropertyBase( typeid( ValueType ), "", "", "" ), m_value() {}

Member Function Documentation

◆ assign()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::assign ( const Details::PropertyBase & source )

inlineoverridevirtual

get the value from another property

Implements Gaudi::Details::PropertyBase.

Definition at line 372 of file Property.h.

                                                               {
       // Check if the property is of "the same" type, except for strings
       const Property* p =
           ( std::is_same_v<ValueType, std::string> ) ? nullptr : dynamic_cast<const Property*>( &source );
       if ( p ) {
         *this = p->value();
       } else {
         return this->fromString( source.toString() ).isSuccess();
       }
       return true;
     }

◆ clone()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

Details::PropertyBase* Gaudi::Property< TYPE, VERIFIER, HANDLERS >::clone ( ) const

inlineoverridevirtual

clones the current property

Implements Gaudi::Details::PropertyBase.

Definition at line 249 of file Property.h.

249 { return new Property( *this ); }

◆ declareReadHandler()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

Details::PropertyBase& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::declareReadHandler ( std::function< void(Details::PropertyBase &)> fun )

inlineoverridevirtual

set new callback for reading

Implements Gaudi::Details::PropertyBase.

Definition at line 141 of file Property.h.

                                                                                                       {
       m_handlers.setReadHandler( std::move( fun ) );
       return *this;
     }

◆ declareUpdateHandler()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

Details::PropertyBase& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::declareUpdateHandler ( std::function< void(Details::PropertyBase &)> fun )

inlineoverridevirtual

set new callback for update

Implements Gaudi::Details::PropertyBase.

Definition at line 146 of file Property.h.

                                                                                                         {
       m_handlers.setUpdateHandler( std::move( fun ) );
       return *this;
     }

◆ fillStream()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

std::ostream& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::fillStream ( std::ostream & stream ) const

inlineoverridevirtual

Properly quote string properties when printing them.

Reimplemented from Gaudi::Details::PropertyBase.

Definition at line 184 of file Property.h.

                                                                 {
       stream << " '" << name() << "':";
       if constexpr ( std::is_same_v<ValueType, std::string> ) {
         using Gaudi::Utils::toStream;
         toStream( value(), stream );
       } else {
         stream << toString();
       }
       return stream;
     }

◆ fromString()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

StatusCode Gaudi::Property< TYPE, VERIFIER, HANDLERS >::fromString ( const std::string & source )

inlineoverridevirtual

string -> value

Implements Gaudi::Details::PropertyBase.

Definition at line 389 of file Property.h.

                                                               {
       try {
         using Converter = Details::Property::StringConverter<ValueType>;
         *this           = Converter().fromString( m_value, source );
         return StatusCode::SUCCESS;
       } catch ( const std::exception& err ) {
         using Details::Property::parsingErrorPolicy;
         using Details::Property::ParsingErrorPolicy;
         const std::string errMsg =
             "Cannot convert '" + source + "' for property '" + name() + "' in class '" + ownerTypeName() + "'";
         switch ( parsingErrorPolicy() ) {
         case ParsingErrorPolicy::Ignore:
           break;
         case ParsingErrorPolicy::Exception:
           throw GaudiException( errMsg, "Property::fromString", StatusCode::FAILURE, err );
           break;
         case ParsingErrorPolicy::Warning:
           std::cerr << "WARNING: " << errMsg << "': " << err.what() << '\n';
           break;
         case ParsingErrorPolicy::Abort:
           std::cerr << "FATAL: " << errMsg << "': " << err.what() << '\n';
           std::abort();
           break;
         }
         return StatusCode::FAILURE;
       }
     }

◆ load()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::load ( Details::PropertyBase & dest ) const

inlineoverridevirtual

set value to another property

Implements Gaudi::Details::PropertyBase.

Definition at line 384 of file Property.h.

                                                           {
       // delegate to the 'opposite' method
       return dest.assign( *this );
     }

◆ operator const ValueType &()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator const ValueType & ( ) const

inline

Automatic conversion to value (const reference).

Definition at line 167 of file Property.h.

                                       {
       m_handlers.useReadHandler( *this );
       return m_value;
     }

◆ operator std::string_view() [1/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<typename Dummy = TYPE, typename = std::enable_if_t<std::is_constructible_v<std::string_view, Dummy>>>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator std::string_view ( ) const

inline

Definition at line 178 of file Property.h.

                                     {
       m_handlers.useReadHandler( *this );
       return m_value;
     }

◆ operator std::string_view() [2/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator std::string_view ( ) const

inline

Definition at line 195 of file Property.h.

                                     {
       m_handlers.useReadHandler( *this );
       return m_value;
     }

◆ operator!=()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T >

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator!= ( const T & other ) const

inline

inequality comparison

Definition at line 208 of file Property.h.

                                             {
       return m_value != other;
     }

◆ operator()()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class... Args>

decltype( Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator() ( Args &&... args ) const

inlinenoexcept

Definition at line 365 of file Property.h.

                                                                                    {
       return value()( std::forward<Args>( args )... );
     }

◆ operator++() [1/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class = ValueType>

Property& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator++ ( )

inline

Definition at line 308 of file Property.h.

                            {
       ++value();
       return *this;
     }

◆ operator++() [2/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class = ValueType>

ValueType Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator++ ( int )

inline

Definition at line 313 of file Property.h.

                                 {
       return m_value++;
     }

◆ operator+=()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T = ValueType>

Property& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator+= ( const T & other )

inline

Definition at line 326 of file Property.h.

                                            {
       m_value += other;
       return *this;
     }

◆ operator--() [1/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class = ValueType>

Property& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator-- ( )

inline

Definition at line 317 of file Property.h.

                            {
       --value();
       return *this;
     }

◆ operator--() [2/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class = ValueType>

ValueType Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator-- ( int )

inline

Definition at line 322 of file Property.h.

                                 {
       return m_value--;
     }

◆ operator-=()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T = ValueType>

Property& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator-= ( const T & other )

inline

Definition at line 331 of file Property.h.

                                            {
       m_value -= other;
       return *this;
     }

◆ operator<()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T >

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator< ( const T & other ) const

inline

"less" comparison

Definition at line 214 of file Property.h.

                                            {
       return m_value < other;
     }

◆ operator=()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T = ValueType>

Property& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator= ( T && v )

inline

Assignment from value.

Definition at line 226 of file Property.h.

                                  {
       m_verifier( v );
       m_value = std::forward<T>( v );
       m_handlers.useUpdateHandler( *this );
       return *this;
     }

◆ operator==()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T >

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::operator== ( const T & other ) const

inline

equality comparison

Definition at line 202 of file Property.h.

                                             {
       return m_value == other;
     }

◆ readCallBack()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

const std::function<void( Details::PropertyBase& )> Gaudi::Property< TYPE, VERIFIER, HANDLERS >::readCallBack ( ) const

inlineoverridevirtual

get a reference to the readCallBack

Implements Gaudi::Details::PropertyBase.

Definition at line 152 of file Property.h.

                                                                                   {
       return m_handlers.getReadHandler();
     }

◆ set()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::set ( const ValueType & v )

inline

Definition at line 245 of file Property.h.

                                    {
       *this = v;
       return true;
     }

◆ setValue()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::setValue ( const ValueType & v )

inline

Definition at line 241 of file Property.h.

                                                     {
       *this = v;
       return true;
     }

◆ toStream()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

void Gaudi::Property< TYPE, VERIFIER, HANDLERS >::toStream ( std::ostream & out ) const

inlineoverridevirtual

value -> stream

Implements Gaudi::Details::PropertyBase.

Definition at line 422 of file Property.h.

                                                     {
       m_handlers.useReadHandler( *this );
       using Utils::toStream;
       toStream( m_value, out );
     }

◆ toString()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

std::string Gaudi::Property< TYPE, VERIFIER, HANDLERS >::toString ( ) const

inlineoverridevirtual

value -> string

Implements Gaudi::Details::PropertyBase.

Definition at line 417 of file Property.h.

                                         {
       using Converter = Details::Property::StringConverter<ValueType>;
       return Converter().toString( *this );
     }

◆ updateCallBack()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

const std::function<void( Details::PropertyBase& )> Gaudi::Property< TYPE, VERIFIER, HANDLERS >::updateCallBack ( ) const

inlineoverridevirtual

get a reference to the updateCallBack

Implements Gaudi::Details::PropertyBase.

Definition at line 156 of file Property.h.

                                                                                     {
       return m_handlers.getUpdateHandler();
     }

◆ useUpdateHandler()

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::useUpdateHandler ( )

inlineoverridevirtual

manual trigger for callback for update

Implements Gaudi::Details::PropertyBase.

Definition at line 161 of file Property.h.

                                      {
       m_handlers.useUpdateHandler( *this );
       return true;
     }

◆ value() [1/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

ValueType& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::value ( )

inline

Definition at line 240 of file Property.h.

240 { return const_cast<ValueType&>( (const ValueType&)*this ); }

◆ value() [2/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

const ValueType& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::value ( ) const

inline

Definition at line 239 of file Property.h.

239 { return *this; }

◆ verifier() [1/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

VerifierType& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::verifier ( )

inline

Accessor to verifier.

Definition at line 236 of file Property.h.

236 { return m_verifier; }

◆ verifier() [2/2]

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

const VerifierType& Gaudi::Property< TYPE, VERIFIER, HANDLERS >::verifier ( ) const

inline

Accessor to verifier.

Definition at line 234 of file Property.h.

234 { return m_verifier; }

Member Data Documentation

◆ is_this_type_v

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

template<class T >

constexpr bool Gaudi::Property< TYPE, VERIFIER, HANDLERS >::is_this_type_v = std::is_same_v<Property, std::remove_reference_t<T>>

inlinestaticconstexprprivate

helper typedefs for SFINAE

Definition at line 57 of file Property.h.

◆ m_handlers

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

HandlersType Gaudi::Property< TYPE, VERIFIER, HANDLERS >::m_handlers

private

Definition at line 53 of file Property.h.

◆ m_value

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

StorageType Gaudi::Property< TYPE, VERIFIER, HANDLERS >::m_value

private

Storage.

Definition at line 51 of file Property.h.

◆ m_verifier

template<class TYPE , class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>

VerifierType Gaudi::Property< TYPE, VERIFIER, HANDLERS >::m_verifier

private

Definition at line 52 of file Property.h.

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

GaudiKernel/include/Gaudi/Property.h

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<class TYPE, class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler> class Gaudi::Property< TYPE, VERIFIER, HANDLERS >

Member Typedef Documentation

◆ HandlersType

◆ not_copying

◆ StorageType

◆ ValueType

◆ VerifierType

Constructor & Destructor Documentation

◆ Property() [1/9]

◆ Property() [2/9]

◆ Property() [3/9]

◆ Property() [4/9]

◆ Property() [5/9]

◆ Property() [6/9]

◆ Property() [7/9]

◆ Property() [8/9]

◆ Property() [9/9]

Member Function Documentation

◆ assign()

◆ clone()

◆ declareReadHandler()

◆ declareUpdateHandler()

◆ fillStream()

◆ fromString()

◆ load()

◆ operator const ValueType &()

◆ operator std::string_view() [1/2]

◆ operator std::string_view() [2/2]

◆ operator!=()

◆ operator()()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=()

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator-=()

◆ operator<()

◆ operator=()

◆ operator==()

◆ readCallBack()

◆ set()

◆ setValue()

◆ toStream()

◆ toString()

◆ updateCallBack()

◆ useUpdateHandler()

◆ value() [1/2]

◆ value() [2/2]

◆ verifier() [1/2]

◆ verifier() [2/2]

Member Data Documentation

◆ is_this_type_v

◆ m_handlers

◆ m_value

◆ m_verifier

template<class TYPE, class VERIFIER = Details::Property::NullVerifier, class HANDLERS = Details::Property::UpdateHandler>
class Gaudi::Property< TYPE, VERIFIER, HANDLERS >