Property.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_PROPERTY_H
#define GAUDIKERNEL_PROPERTY_H
// ============================================================================
// STD & STL
// ============================================================================
#include <string>
#include <stdexcept>
#include <typeinfo>
// ============================================================================
// Application C++ Class Headers
// ============================================================================
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/PropertyVerifier.h"
#include "GaudiKernel/Parsers.h"
#include "GaudiKernel/ToStream.h"
#include "GaudiKernel/SmartIF.h"
// ============================================================================

// ============================================================================
class Property   ;
class IProperty  ;
class IInterface ;
// ============================================================================

// ============================================================================
// ============================================================================
GAUDI_API std::ostream& operator<<(std::ostream& stream, const Property& prop);
// ============================================================================
class GAUDI_API Property
{
private:
  // the default constructor is disabled
  Property();
public:
  const std::string&    name      () const { return m_name             ; }
  const   std::string&  documentation() const { return m_documentation; }
  const std::type_info* type_info () const { return m_typeinfo         ; }
  std::string           type      () const { return m_typeinfo->name() ; }
  virtual bool load   (       Property& dest   ) const = 0 ;
  virtual bool assign ( const Property& source )       = 0 ;
public:
  virtual std::string  toString   ()  const = 0 ;
  virtual void toStream(std::ostream& out) const = 0;
  virtual StatusCode   fromString ( const std::string& value ) = 0 ;
public:
  const std::function<void(Property&)>&  readCallBack() const { return m_readCallBack; }
  const std::function<void(Property&)>& updateCallBack() const { return m_updateCallBack; }

  virtual Property&  declareReadHandler   ( std::function<void(Property&)> fun ) ;
  virtual Property&  declareUpdateHandler ( std::function<void(Property&)> fun ) ;

  template< class HT >
  inline Property& declareReadHandler( void ( HT::* MF ) ( Property& ) , HT* instance )
  { return declareReadHandler( [=](Property& p) { (instance->*MF)(p); } ) ; }

  template< class HT >
  inline Property& declareUpdateHandler( void ( HT::* MF ) ( Property& ) , HT* instance )
  { return declareUpdateHandler ( [=](Property& p) { (instance->*MF)(p); } ); }

  virtual void useReadHandler   () const ;
  virtual bool useUpdateHandler ()       ;
public:
  virtual ~Property() = default;
  virtual Property*          clone     () const = 0 ;
  void setName ( std::string value ) { m_name = std::move(value) ; }
  void setDocumentation( std::string documentation ) {
    m_documentation = std::move(documentation); }
  virtual std::ostream& fillStream ( std::ostream& ) const ;
protected:
  Property
  ( const std::type_info& type      ,
    std::string    name = "" ) ;
  Property
  ( std::string    name      ,
    const std::type_info& type      ) ;
  Property           ( const Property& ) = default;
  Property& operator=( const Property& ) = default;
private:
  // property name
  std::string              m_name           ;
  // property doc string
  std::string              m_documentation;
  // property type
  const std::type_info*    m_typeinfo       ;
protected:
  // call back functor for reading
  mutable std::function<void(Property&)> m_readCallBack;
  // call back functor for update
  std::function<void(Property&)> m_updateCallBack;
};
// ============================================================================
// ============================================================================
template <class TYPE>
class PropertyWithValue : public Property
{
public:
  // ==========================================================================
  typedef Gaudi::Utils::PropertyTypeTraits<TYPE>         Traits ;
  typedef typename Traits::PVal                          PVal   ;
  // ==========================================================================
protected:
  // ==========================================================================
  inline PropertyWithValue
  ( std::string        name  ,
    PVal               value ,
    const bool         owner ) ;
  inline PropertyWithValue ( const PropertyWithValue& rhs ) ;
  template <class OTHER>
  inline PropertyWithValue ( const PropertyWithValue<OTHER>& right ) ;
  ~PropertyWithValue() override ;
  PropertyWithValue& operator=( const TYPE& value ) ;
  // assignment operator (don't let the compiler generate a buggy one)
  PropertyWithValue& operator=( const PropertyWithValue& rhs ) ;
  // assignment operator
  template <class OTHER>
  PropertyWithValue& operator=( const PropertyWithValue<OTHER>& right ) ;
  // ==========================================================================
public:
  // ==========================================================================
  operator const TYPE&      () const { return value() ;}
  inline const TYPE& value() const ;
  // ==========================================================================
public:
  // ==========================================================================
  virtual bool setValue ( const TYPE&     value  )  = 0  ;
  bool assign   ( const Property& source )       override;
  bool load     (       Property& dest   ) const override;
  StatusCode fromString ( const std::string& s )  override;
  std::string  toString   () const  override;
  void  toStream (std::ostream& out) const  override;
  // ==========================================================================
protected:
  // ==========================================================================
  inline void  i_set ( const TYPE& value ) {
    Traits::assign(*m_value, value);
  }
  inline PVal  i_get () const {
    return m_value;
  }
  // ==========================================================================
private:
  // ==========================================================================
  PVal m_value ;                                   // the actual property value
  bool  m_own  ;                                   //      owner of the storage
  // ==========================================================================
};

// ============================================================================
// ============================================================================
template <class TYPE>
inline
PropertyWithValue<TYPE>::PropertyWithValue
( std::string  name  ,
  PVal         value ,
  const bool   own   )
  : Property ( typeid( TYPE ) , std::move(name) )
  , m_value  ( value )
  , m_own    ( own   )
{}
// ============================================================================
// copy constructor
// ============================================================================
template <class TYPE>
inline PropertyWithValue<TYPE>::PropertyWithValue
( const PropertyWithValue& right )
  : Property( right         )
  , m_value ( right.m_value )
  , m_own   ( right.m_own   )
{
  m_value = Traits::copy ( right.value() , m_own ) ;
}
// ============================================================================
// "copy" constructor form any other type
// ============================================================================
template <class TYPE>
template <class OTHER>
inline PropertyWithValue<TYPE>::PropertyWithValue
( const PropertyWithValue<OTHER>& right )
  : Property( right         )
  , m_value ( right.m_value )
  , m_own   ( right.m_own   )
{
  m_value = Traits::copy ( right.value() , m_own ) ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline PropertyWithValue<TYPE>::~PropertyWithValue()
{
  Traits::dele ( m_value , m_own ) ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline PropertyWithValue<TYPE>&
PropertyWithValue<TYPE>::operator=( const TYPE& value )
{
  if ( !setValue ( value ) )
  { throw std::out_of_range( "Value not verified" ) ; }
  return *this ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline bool
PropertyWithValue<TYPE>::assign ( const Property& source )
{
  // 1) Is the property of "the same" type?
  const PropertyWithValue<TYPE>* p =
    dynamic_cast<const PropertyWithValue<TYPE>*>       ( &source ) ;
  if ( p ) { return setValue ( p->value() ) ; }       // RETURN
  // 2) Else use the string representation
  return this->fromString( source.toString() ).isSuccess() ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline bool
PropertyWithValue<TYPE>::load( Property& dest ) const
{
  // delegate to the 'opposite' method ;
  return dest.assign( *this ) ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline std::string
PropertyWithValue<TYPE>::toString () const
{
  useReadHandler();
  return Gaudi::Utils::toString( *m_value ) ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline void
PropertyWithValue<TYPE>::toStream (std::ostream& out) const
{
  useReadHandler();
  Gaudi::Utils::toStream( *m_value, out ) ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline StatusCode
PropertyWithValue<TYPE>::fromString ( const std::string& source )
{
  TYPE tmp ;
  StatusCode sc = Gaudi::Parsers::parse ( tmp , source ) ;
  if ( sc.isFailure() ) { return sc ; }
  return setValue ( tmp ) ? StatusCode::SUCCESS : StatusCode::FAILURE ;
}
// ============================================================================
// ============================================================================
template <>
inline std::string
PropertyWithValue<std::string>::toString () const
{
  useReadHandler();
  return this->value() ;
}
// ============================================================================
template <>
inline bool PropertyWithValue<std::string>::assign ( const Property& source )
{ return this->fromString( source.toString() ).isSuccess() ; }
// ============================================================================

// ============================================================================
// ============================================================================
template <class TYPE>
inline const TYPE&
PropertyWithValue<TYPE>::value() const
{ useReadHandler() ; return *m_value ; }
// ============================================================================
// assignment operator
// ============================================================================
template <class TYPE>
PropertyWithValue<TYPE>& PropertyWithValue<TYPE>::operator=
( const PropertyWithValue& right )
{
  // assign the base class
  Property::operator=( right ) ;
  // assign the value
  PropertyWithValue<TYPE>::operator=( right.value() ) ;
  return *this ;
}
// ============================================================================
// templated assignment operator
// ============================================================================
template <class TYPE>
template <class OTHER>
PropertyWithValue<TYPE>& PropertyWithValue<TYPE>::operator=
( const PropertyWithValue<OTHER>& right )
{
  // assign the base class
  Property::operator=( right ) ;
  // assign the value
  PropertyWithValue<TYPE>::operator=( right.value() ) ;
  return *this ;
}
// ============================================================================

// ============================================================================
// ============================================================================
template<class TYPE,class VERIFIER>
class PropertyWithVerifier
  : public PropertyWithValue<TYPE>
{
protected:
  // ==========================================================================
  PropertyWithVerifier
  ( std::string                                           name     ,
    typename Gaudi::Utils::PropertyTypeTraits<TYPE>::PVal value    ,
    const bool                                            owner    ,
    const VERIFIER&                                       verifier )
    : PropertyWithValue<TYPE> ( std::move(name) , value , owner )
    , m_verifier ( verifier )
  {}
  ~PropertyWithVerifier() override = default;
  // ==========================================================================
public:
  // ==========================================================================
  inline       VERIFIER& verifier()       { return m_verifier ; }
  inline const VERIFIER& verifier() const { return m_verifier ; }
  bool set( const TYPE& value ) ;
  bool setValue( const TYPE& value ) override { return set( value ) ; }
  template <class OTHER,class OTHERVERIFIER>
  PropertyWithVerifier& operator=
  ( const PropertyWithVerifier<OTHER,OTHERVERIFIER>& right ) ;
  template <class OTHER>
  PropertyWithVerifier& operator=( const PropertyWithValue<OTHER>& right ) ;
  PropertyWithVerifier& operator=( const TYPE& right ) ;
  // ==========================================================================
private:
  // ==========================================================================
  PropertyWithVerifier(); 
  PropertyWithVerifier( const  PropertyWithVerifier& right );
  // ==========================================================================
private:
  // ==========================================================================
  VERIFIER m_verifier ;                                  // the verifier itself
  // ==========================================================================
} ;
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline bool
PropertyWithVerifier<TYPE,VERIFIER>::set( const TYPE& value )
{
  if ( !m_verifier.isValid( &value ) ) { return false ; }
  this->i_set( value ) ;
  return this->useUpdateHandler() ;
}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline PropertyWithVerifier<TYPE,VERIFIER>&
PropertyWithVerifier<TYPE,VERIFIER>::operator=( const TYPE& right )
{
  PropertyWithValue<TYPE>::operator=( right ) ;
  return *this ;
}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER>
inline PropertyWithVerifier<TYPE,VERIFIER>&
PropertyWithVerifier<TYPE,VERIFIER>::operator=( const PropertyWithValue<OTHER>& right )
{
  PropertyWithValue<TYPE>::operator=(right) ;
  return *this ;
}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER,class OTHERVERIFIER>
inline PropertyWithVerifier<TYPE,VERIFIER>&
PropertyWithVerifier<TYPE,VERIFIER>::operator=
( const PropertyWithVerifier<OTHER,OTHERVERIFIER>& right )
{
  PropertyWithValue<TYPE>::operator=(right) ;
  return *this ;
}
// ============================================================================

// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER = BoundedVerifier<TYPE> >
class SimpleProperty
  : public PropertyWithVerifier<TYPE,VERIFIER>
{
protected:
  // ==========================================================================
  typedef Gaudi::Utils::PropertyTypeTraits<TYPE>  Traits ;
  // ==========================================================================
public:
  // ==========================================================================
  SimpleProperty
  ( VERIFIER           verifier = VERIFIER() ) ;
  SimpleProperty
  ( const TYPE&        value                 ,
    VERIFIER           verifier = VERIFIER() ) ;
  SimpleProperty
  ( std::string        name                  ,
    const TYPE&        value                 ,
    VERIFIER           verifier = VERIFIER() ) ;
  template <class OTHER>
  SimpleProperty ( const PropertyWithValue<OTHER>& right ) ;
  SimpleProperty ( const SimpleProperty& right ) ;
  ~SimpleProperty() override = default;
  SimpleProperty* clone() const override;
  SimpleProperty& operator=( const TYPE& value ) ;
  template <class OTHER>
  SimpleProperty& operator=( const PropertyWithValue<OTHER>& right ) ;
  // ==========================================================================
};
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER>
( "" , Traits::new_() , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const TYPE&        value    ,
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER>
( "" , Traits::new_(value) , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( std::string        name     ,
  const TYPE&        value    ,
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER>
( std::move(name) , Traits::new_(value) , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const PropertyWithValue<OTHER>& right )
  : PropertyWithVerifier<TYPE,VERIFIER>
( right.name() , Traits::new_( right.value() ) , true , VERIFIER() )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const SimpleProperty& right )
  : PropertyWithVerifier<TYPE,VERIFIER>
( right.name() , Traits::new_( right.value() ) , true , right.verifier() )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline
SimpleProperty<TYPE,VERIFIER>*
SimpleProperty<TYPE,VERIFIER>::clone() const
{ return new SimpleProperty(*this) ; }
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline
SimpleProperty<TYPE,VERIFIER>&
SimpleProperty<TYPE,VERIFIER>::operator=( const TYPE& value )
{
  PropertyWithVerifier<TYPE,VERIFIER>::operator=( value );
  return *this ;
}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER>
inline
SimpleProperty<TYPE,VERIFIER>&
SimpleProperty<TYPE,VERIFIER>::operator=
( const PropertyWithValue<OTHER>& right )
{
  PropertyWithVerifier<TYPE,VERIFIER>::operator=( right );
  return *this ;
}
// ============================================================================

// ============================================================================
// ============================================================================
template< class TYPE, class VERIFIER = NullVerifier<TYPE> >
class SimplePropertyRef :
  public PropertyWithVerifier<TYPE,VERIFIER>
{
public:
  SimplePropertyRef
  ( std::string        name                  ,
    TYPE&              value                 ,  
    VERIFIER           verifier = VERIFIER() ) ;
  SimplePropertyRef ( const SimplePropertyRef& right ) ;
  ~SimplePropertyRef() override = default;
  SimplePropertyRef* clone() const override;
  SimplePropertyRef& operator=( const TYPE& value ) ;
  template <class OTHER>
  SimplePropertyRef& operator=( const PropertyWithValue<OTHER>& right ) ;
private:
  // the default constructor is disabled
  SimplePropertyRef() ;
};
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimplePropertyRef<TYPE,VERIFIER>::SimplePropertyRef
( std::string        name     ,
  TYPE&              value    ,  
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER> ( std::move(name) , &value , false , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimplePropertyRef<TYPE,VERIFIER>::SimplePropertyRef
( const SimplePropertyRef& right )
  : PropertyWithVerifier<TYPE,VERIFIER>
( right.name() , right.i_get() , false , right.verifier() )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline
SimplePropertyRef<TYPE,VERIFIER>*
SimplePropertyRef<TYPE,VERIFIER>::clone() const
{ return new SimplePropertyRef(*this) ; }
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline
SimplePropertyRef<TYPE,VERIFIER>&
SimplePropertyRef<TYPE,VERIFIER>::operator=( const TYPE& value )
{
  PropertyWithVerifier<TYPE,VERIFIER>::operator=( value ) ;
  return *this ;
}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER>
inline
SimplePropertyRef<TYPE,VERIFIER>&
SimplePropertyRef<TYPE,VERIFIER>::operator=
( const PropertyWithValue<OTHER>& right )
{
  PropertyWithVerifier<TYPE,VERIFIER>::operator=( right );
  return *this ;
}
// ============================================================================




// Typedef Properties for built-in types
typedef SimpleProperty< bool >              BooleanProperty;
typedef SimpleProperty< char >              CharProperty;
typedef SimpleProperty< signed char >       SignedCharProperty;
typedef SimpleProperty< unsigned char >     UnsignedCharProperty;
typedef SimpleProperty< short >             ShortProperty;
typedef SimpleProperty< unsigned short >    UnsignedShortProperty;
typedef SimpleProperty< int >               IntegerProperty;
typedef SimpleProperty< unsigned int >      UnsignedIntegerProperty;
typedef SimpleProperty< long >              LongProperty;
typedef SimpleProperty< unsigned long >     UnsignedLongProperty;
typedef SimpleProperty< long long>          LongLongProperty;
typedef SimpleProperty< unsigned long long> UnsignedLongLongProperty;
typedef SimpleProperty< float >             FloatProperty;
typedef SimpleProperty< double >            DoubleProperty;
typedef SimpleProperty< long double >       LongDoubleProperty;

typedef SimpleProperty< std::string >       StringProperty;


// Typedef PropertyRefs for built-in types
typedef SimplePropertyRef< bool >                BooleanPropertyRef;
typedef SimplePropertyRef< char >                CharPropertyRef;
typedef SimplePropertyRef< signed char >         SignedCharPropertyRef;
typedef SimplePropertyRef< unsigned char >       UnsignedCharPropertyRef;
typedef SimplePropertyRef< short >               ShortPropertyRef;
typedef SimplePropertyRef< unsigned short >      UnsignedShortPropertyRef;
typedef SimplePropertyRef< int >                 IntegerPropertyRef;
typedef SimplePropertyRef< unsigned int >        UnsignedIntegerPropertyRef;
typedef SimplePropertyRef< long >                LongPropertyRef;
typedef SimplePropertyRef< unsigned long >       UnsignedLongPropertyRef;
typedef SimplePropertyRef< long long >           LongLongPropertyRef;
typedef SimplePropertyRef< unsigned long long >  UnsignedLongLongPropertyRef;
typedef SimplePropertyRef< float >               FloatPropertyRef;
typedef SimplePropertyRef< double >              DoublePropertyRef;
typedef SimplePropertyRef< long double >         LongDoublePropertyRef;

typedef SimplePropertyRef< std::string >         StringPropertyRef;


// Typedef "Arrays" of Properties for built-in types
typedef SimpleProperty< std::vector< bool > >                BooleanArrayProperty;
typedef SimpleProperty< std::vector< char > >                CharArrayProperty;
typedef SimpleProperty< std::vector< signed char > >         SignedCharArrayProperty;
typedef SimpleProperty< std::vector< unsigned char > >       UnsignedCharArrayProperty;
typedef SimpleProperty< std::vector< short > >               ShortArrayProperty;
typedef SimpleProperty< std::vector< unsigned short > >      UnsignedShortArrayProperty;
typedef SimpleProperty< std::vector< int > >                 IntegerArrayProperty;
typedef SimpleProperty< std::vector< unsigned int > >        UnsignedIntegerArrayProperty;
typedef SimpleProperty< std::vector< long > >                LongArrayProperty;
typedef SimpleProperty< std::vector< unsigned long > >       UnsignedLongArrayProperty;
typedef SimpleProperty< std::vector< long long > >           LongLongArrayProperty;
typedef SimpleProperty< std::vector< unsigned long long > >  UnsignedLongLongArrayProperty;
typedef SimpleProperty< std::vector< float > >               FloatArrayProperty;
typedef SimpleProperty< std::vector< double > >              DoubleArrayProperty;
typedef SimpleProperty< std::vector< long double > >         LongDoubleArrayProperty;

typedef SimpleProperty< std::vector< std::string > >         StringArrayProperty;


// Typedef "Arrays" of PropertyRefs for built-in types
typedef SimplePropertyRef< std::vector< bool > >                 BooleanArrayPropertyRef;
typedef SimplePropertyRef< std::vector< char > >                 CharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< signed char > >          SignedCharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned char > >        UnsignedCharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< short > >                ShortArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned short > >       UnsignedShortArrayPropertyRef;
typedef SimplePropertyRef< std::vector< int > >                  IntegerArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned int > >         UnsignedIntegerArrayPropertyRef;
typedef SimplePropertyRef< std::vector< long > >                 LongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned long > >        UnsignedLongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< long long > >            LongLongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned long long > >   UnsignedLongLongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< float > >                FloatArrayPropertyRef;
typedef SimplePropertyRef< std::vector< double > >               DoubleArrayPropertyRef;
typedef SimplePropertyRef< std::vector< long double > >          LongDoubleArrayPropertyRef;

typedef SimplePropertyRef< std::vector< std::string > >          StringArrayPropertyRef;

// pre-declaration is sufficient here
class GaudiHandleBase;

class GAUDI_API GaudiHandleProperty : public Property {
public:
  GaudiHandleProperty( std::string name, GaudiHandleBase& ref );

  GaudiHandleProperty& operator=( const GaudiHandleBase& value );

  GaudiHandleProperty* clone() const override;

  bool load( Property& destination ) const override;

  bool assign( const Property& source ) override;

  std::string toString() const override;

  void toStream(std::ostream& out) const override;

  StatusCode fromString(const std::string& s) override;

  const GaudiHandleBase& value() const;

  bool setValue( const GaudiHandleBase& value );

private:
   GaudiHandleBase* m_pValue;
};

// implementation in header file only where the GaudiHandleBase class
// definition is not needed. The rest goes into the .cpp file.
// The goal is to decouple the header files, to avoid that the whole
// world depends on GaudiHandle.h
inline GaudiHandleProperty& GaudiHandleProperty::operator=( const GaudiHandleBase& value ) {
      setValue( value );
      return *this;
}

inline GaudiHandleProperty* GaudiHandleProperty::clone() const {
  return new GaudiHandleProperty( *this );
}

inline bool GaudiHandleProperty::load( Property& destination ) const {
  return destination.assign( *this );
}

inline bool GaudiHandleProperty::assign( const Property& source ) {
  return fromString( source.toString() ).isSuccess();
}

inline const GaudiHandleBase& GaudiHandleProperty::value() const {
  useReadHandler();
  return *m_pValue;
}


// pre-declaration is sufficient here
class GaudiHandleArrayBase;

class GAUDI_API GaudiHandleArrayProperty : public Property {
public:

  GaudiHandleArrayProperty( std::string name, GaudiHandleArrayBase& ref );

  GaudiHandleArrayProperty& operator=( const GaudiHandleArrayBase& value );

  GaudiHandleArrayProperty* clone() const override;

  bool load( Property& destination ) const override;

  bool assign( const Property& source ) override;

  std::string toString() const override;

  void toStream(std::ostream& out) const override;

  StatusCode fromString(const std::string& s) override;

  const GaudiHandleArrayBase& value() const;

  bool setValue( const GaudiHandleArrayBase& value );

private:
   GaudiHandleArrayBase* m_pValue;

};

// implementation in header file only where the GaudiHandleBase class
// definition is not needed. The rest goes into the .cpp file.
// The goal is to decouple the header files, to avoid that the whole
// world depends on GaudiHandle.h
inline GaudiHandleArrayProperty& GaudiHandleArrayProperty::operator=( const GaudiHandleArrayBase& value ) {
  setValue( value );
  return *this;
}

inline GaudiHandleArrayProperty* GaudiHandleArrayProperty::clone() const {
  return new GaudiHandleArrayProperty( *this );
}

inline bool GaudiHandleArrayProperty::load( Property& destination ) const {
  return destination.assign( *this );
}

inline bool GaudiHandleArrayProperty::assign( const Property& source ) {
  return fromString( source.toString() ) != 0;
}

inline const GaudiHandleArrayBase& GaudiHandleArrayProperty::value() const {
  useReadHandler();
  return *m_pValue;
}


namespace Gaudi
{
  namespace Utils
  {
    // ========================================================================
    GAUDI_API bool hasProperty ( const IProperty*   p , const std::string& name ) ;
    // ========================================================================
    GAUDI_API bool hasProperty ( const IInterface*   p , const std::string& name ) ;
    // ========================================================================
    GAUDI_API Property* getProperty
    ( const IProperty*   p , const std::string& name ) ;
    // ========================================================================
    GAUDI_API Property* getProperty
    ( const IInterface*   p , const std::string& name ) ;
    // ========================================================================
    GAUDI_API bool hasProperty
    ( const std::vector<const Property*>* p    ,
      const std::string&                  name ) ;
    // ========================================================================
    GAUDI_API const Property* getProperty
    ( const std::vector<const Property*>* p    ,
      const std::string&                  name ) ;
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const TYPE&        value      ,
      const std::string& doc        ) ;
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const TYPE&        value      )
    { return setProperty ( component , name , value , std::string() ) ; }
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const std::string& value      ,
      const std::string& doc   = "" ) ;
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const char*        value      ,
      const std::string& doc   = "" ) ;
    // ========================================================================
    template <unsigned N>
    StatusCode setProperty
    ( IProperty*           component ,
      const std::string&   name      ,
      const char         (&value)[N] ,
      const std::string& doc   = ""  )
    {
      return component ? setProperty ( component , name , 
                                       std::string ( value , value + N ), doc )
                       : StatusCode::FAILURE;
    }
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const TYPE&        value      ,
      const std::string& doc        )
    {
      return component && hasProperty(component,name) ?
                Gaudi::Utils::setProperty ( component , name , 
                                            Gaudi::Utils::toString ( value ) , doc ) :
                StatusCode::FAILURE;
    }
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IProperty*         component ,
      const std::string& name      ,
      const Property*    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IProperty*         component ,
      const std::string& name      ,
      const Property&    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IProperty*                  component ,
      const std::string&          name      ,
      const SimpleProperty<TYPE>& value     ,
      const std::string&          doc = ""  )
    {
      return setProperty ( component , name , &value , doc ) ;
    }
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const TYPE&        value     ,
      const std::string& doc = ""  )
    {
      if ( !component ) { return StatusCode::FAILURE ; }
      auto property = SmartIF<IProperty>{  component } ;
      return property ? setProperty ( property , name , value , doc ) 
                      : StatusCode::FAILURE;
    }
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const std::string& value     ,
      const std::string& doc  = "" ) ;
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const char*        value     ,
      const std::string& doc  = "" ) ;
    // ========================================================================
    template <unsigned N>
    StatusCode setProperty
    ( IInterface*          component ,
      const std::string&   name      ,
      const char         (&value)[N] ,
      const std::string& doc  = ""   )
    {
      if ( 0 == component ) { return StatusCode::FAILURE ; }
      return setProperty ( component , name , 
                           std::string{ value , value + N }, doc ) ;
    }
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const Property*    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    GAUDI_API StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const Property&    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    template <class TYPE>
    StatusCode
    setProperty
    ( IInterface*                 component ,
      const std::string&          name      ,
      const SimpleProperty<TYPE>& value     ,
      const std::string&          doc = ""  )
    {
      return setProperty ( component , name , &value , doc ) ;
    }
    // ========================================================================
  } // end of namespace Gaudi::Utils
} // end of namespace Gaudi


// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_PROPERTY_H
// ============================================================================