In This Package:

Property.h

Go to the documentation of this file.

// $Id: Property.h,v 1.27 2008/12/01 19:57:43 marcocle Exp $
// ============================================================================
// CVS tag $Name: GAUDI_v20r4-pre $
// ============================================================================
#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 PropertyCallbackFunctor ;
class IProperty  ;
class IInterface ;
// ============================================================================

// ============================================================================
// ============================================================================
std::ostream&
operator<<
  ( std::ostream&   stream ,
    const Property& prop   ) ;
// ============================================================================
class 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 StatusCode   fromString ( const std::string& value ) = 0 ;
public:
  const PropertyCallbackFunctor* readCallBack   () const ;
  const PropertyCallbackFunctor* updateCallBack () const ;
  virtual void  declareReadHandler   ( PropertyCallbackFunctor* pf ) ;
  virtual void  declareUpdateHandler ( PropertyCallbackFunctor* pf ) ;
  template< class HT >
  void declareReadHandler
  ( void ( HT::* MF ) ( Property& ) , HT* instance ) ;
  template< class HT >
  void declareUpdateHandler
  ( void ( HT::* MF ) ( Property& ) , HT* instance ) ;
  virtual void useReadHandler   () const ;
  virtual void useUpdateHandler ()       ;
public:
  virtual ~Property() ;
  virtual Property*          clone     () const = 0 ;
  void setName ( const std::string& value ) { m_name = value ; }
  void setDocumentation( const std::string& documentation ) {
    m_documentation = documentation; };
  virtual std::ostream& fillStream ( std::ostream& ) const ;
protected:
  Property
  ( const std::type_info& type      ,
    const std::string&    name = "" ) ;
  Property
  ( const std::string&    name      ,
    const std::type_info& type      ) ;
  Property           ( const Property& right ) ;
  Property& operator=( const Property& right ) ;
private:
  // the default constructor is disabled
  Property() ;
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 funtor for reading
  mutable PropertyCallbackFunctor* m_readCallBack   ;
  // call back funtor for update
  PropertyCallbackFunctor* m_updateCallBack ;
};
// ============================================================================
#include "GaudiKernel/PropertyCallbackFunctor.h"
// ============================================================================
template< class HT >
inline void Property::declareReadHandler
( void ( HT::* MF ) ( Property& ) , HT* obj )
{ declareReadHandler ( new PropertyCallbackMemberFunctor< HT >( MF , obj ) ) ; }
// ============================================================================
template< class HT >
inline void Property::declareUpdateHandler
( void ( HT::* MF ) ( Property& ) , HT* obj )
{ declareUpdateHandler ( new PropertyCallbackMemberFunctor< HT >( MF , obj ) ) ; }
// ============================================================================
// ============================================================================
template <class TYPE>
class PropertyWithValue
  : public Property
{
protected:
  PropertyWithValue
  ( const std::string& name  ,
    TYPE*              value ,
    const bool         owner ) ;
  PropertyWithValue ( const PropertyWithValue& rhs ) ;
  template <class OTHER>
  PropertyWithValue ( const PropertyWithValue<OTHER>& right ) ;
  virtual ~PropertyWithValue() ;
  PropertyWithValue& operator=( const TYPE& value ) ;
  // assignement operator (don't let the compiler generate a buggy one)
  PropertyWithValue& operator=( const PropertyWithValue& rhs ) ;
  // assignement operator
  template <class OTHER>
  PropertyWithValue& operator=( const PropertyWithValue<OTHER>& right ) ;
public:
  operator const TYPE&      () const { return value() ;}
  const TYPE& value() const ;
public:
  // NB: abstract : to be implemented when verifier is available
  virtual bool setValue ( const TYPE&     value  )  = 0  ;
  virtual bool assign   ( const Property& source )       ;
  virtual bool load     (       Property& dest   ) const ;
  virtual StatusCode fromString ( const std::string& s )  ;
  virtual std::string  toString   () const  ;
protected:
  void  i_set ( const TYPE& value ) ;
  TYPE* i_get () const ;
private:
  TYPE* m_value ;
  bool  m_own ;
};
// ============================================================================
// ============================================================================
template <class TYPE>
inline PropertyWithValue<TYPE>::PropertyWithValue
( const std::string& name  ,
  TYPE*              value ,
  const bool         own   )
  : Property ( typeid( TYPE ) , 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.own     )
{ if ( m_own ) { m_value = new TYPE(right.value()) ; } }
// ============================================================================
// "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.own     )
{ if ( m_own ) { m_value = new TYPE(right.value()) ; } }
// ============================================================================
// ============================================================================
template <class TYPE>
inline PropertyWithValue<TYPE>::~PropertyWithValue()
{ if ( m_own ) { delete m_value ; } ;  m_value = 0 ; }
// ============================================================================
// ============================================================================
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 ( 0 != 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
{
  // gelegate 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 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
{ 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 ; }
// ============================================================================
// the actual modification of internale data
// ============================================================================
template <class TYPE>
inline  void PropertyWithValue<TYPE>::i_set
( const TYPE& value ) { *m_value = value ; }
// ============================================================================
// protected accessor to internal data
// ============================================================================
template <class TYPE>
inline TYPE* PropertyWithValue<TYPE>::i_get() const { return m_value ; }
// ============================================================================
// assignement 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 assignement 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
  ( const std::string& name     ,
    TYPE*              value    ,
    const bool         owner    ,
    const VERIFIER&    verifier )
    : PropertyWithValue<TYPE> ( name , value , owner )
    , m_verifier ( verifier )
  {}
  virtual ~PropertyWithVerifier() {};
public:
  inline       VERIFIER& verifier()       { return m_verifier ; }
  inline const VERIFIER& verifier() const { return m_verifier ; }
  bool set( const TYPE& value ) ;
  virtual bool setValue( const TYPE& value ) { 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 ;
} ;
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
inline bool
PropertyWithVerifier<TYPE,VERIFIER>::set( const TYPE& value )
{
  if ( !m_verifier.isValid( &value ) ) { return false ; }
  i_set( value ) ;
  this->useUpdateHandler() ;
  return true ;
}
// ============================================================================
// ============================================================================
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>
{
public:
  SimpleProperty
  ( VERIFIER           verifier = VERIFIER() ) ;
  SimpleProperty
  ( const TYPE&        value                 ,
    VERIFIER           verifier = VERIFIER() ) ;
  SimpleProperty
  ( const std::string& name                  ,
    const TYPE&        value                 ,
    VERIFIER           verifier = VERIFIER() ) ;
  template <class OTHER>
  SimpleProperty ( const PropertyWithValue<OTHER>& right ) ;
  SimpleProperty ( const SimpleProperty& right ) ;
  virtual ~SimpleProperty() ;
  virtual SimpleProperty* clone() const ;
  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>
( "" , new TYPE() , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const TYPE&        value    ,
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER>
( "" , new TYPE(value) , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const std::string& name     ,
  const TYPE&        value    ,
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER>
( name , new TYPE(value) , true , verifier )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
template <class OTHER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const PropertyWithValue<OTHER>& right )
  : PropertyWithVerifier<TYPE,VERIFIER>
( right.name() , new TYPE( right.value() ) , true , VERIFIER() )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::SimpleProperty
( const SimpleProperty& right )
  : PropertyWithVerifier<TYPE,VERIFIER>
( right.name() , new TYPE( right.value() ) , true , right.verifier() )
{}
// ============================================================================
// ============================================================================
template <class TYPE,class VERIFIER>
SimpleProperty<TYPE,VERIFIER>::~SimpleProperty(){}
// ============================================================================
// ============================================================================
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
  ( const std::string& name                  ,
    TYPE&              value                 ,  
    VERIFIER           verifier = VERIFIER() ) ;
  SimplePropertyRef ( const SimplePropertyRef& right ) ;
  virtual ~SimplePropertyRef() ;
  virtual SimplePropertyRef* clone() const ;
  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
( const std::string& name     ,
  TYPE&              value    ,  
  VERIFIER           verifier )
  : PropertyWithVerifier<TYPE,VERIFIER> ( 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>
SimplePropertyRef<TYPE,VERIFIER>::~SimplePropertyRef(){}
// ============================================================================
// ============================================================================
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 GaudiHandleProperty : public Property {
public:
   GaudiHandleProperty( const std::string& name, GaudiHandleBase& ref );

  GaudiHandleProperty& operator=( const GaudiHandleBase& value );

  virtual GaudiHandleProperty* clone() const;

  virtual bool load( Property& destination ) const;

  virtual bool assign( const Property& source );

  virtual std::string toString() const;

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

  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 GaudiHandleArrayProperty : public Property {
public:

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

  GaudiHandleArrayProperty& operator=( const GaudiHandleArrayBase& value );

  virtual GaudiHandleArrayProperty* clone() const;

  virtual bool load( Property& destination ) const;

  virtual bool assign( const Property& source );

  virtual std::string toString() const;

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

  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
  {
    // ========================================================================
    bool hasProperty ( const IProperty*   p , const std::string& name ) ;
    // ========================================================================
    bool hasProperty ( const IInterface*   p , const std::string& name ) ;
    // ========================================================================
    Property* getProperty
    ( const IProperty*   p , const std::string& name ) ;
    // ========================================================================
    Property* getProperty
    ( const IInterface*   p , const std::string& name ) ;
    // ========================================================================
    bool hasProperty
    ( const std::vector<const Property*>* p    ,
      const std::string&                  name ) ;
    // ========================================================================
    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() ) ; }
    // ========================================================================
    StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const std::string& value      ,
      const std::string& doc   = "" ) ;
    // ========================================================================
    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   = ""  )
    {
      if ( 0 == component                    ) { return StatusCode::FAILURE ; }
      const std::string val = std::string ( value , value + N ) ;
      return setProperty ( component , name , val , doc ) ;
    }
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IProperty*         component  ,
      const std::string& name       ,
      const TYPE&        value      ,
      const std::string& doc        )
    {
      if ( 0 == component ) { return StatusCode::FAILURE ; }   // RETURN
      if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
      const std::string val = Gaudi::Utils::toString ( value ) ;
      return Gaudi::Utils::setProperty ( component , name , val , doc ) ;
    }
    // ========================================================================
    StatusCode
    setProperty
    ( IProperty*         component ,
      const std::string& name      ,
      const Property*    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    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 = ""  )
    {
      const Property* property = &value ;
      return setProperty ( component , name , property , doc ) ;
    }
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const TYPE&        value     ,
      const std::string& doc = ""  )
    {
      if ( 0 == component ) { return StatusCode::FAILURE ; }
      SmartIF<IProperty> property ( component ) ;
      if ( !property      ) { return StatusCode::FAILURE ; }
      return setProperty ( property , name , value , doc ) ;
    }
    // ========================================================================
    StatusCode setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const std::string& value     ,
      const std::string& doc  = "" ) ;
    // ========================================================================
    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 ; }
      const std::string val = std::string ( value , value + N ) ;
      return setProperty ( component , name , val , doc ) ;
    }
    // ========================================================================
    StatusCode
    setProperty
    ( IInterface*        component ,
      const std::string& name      ,
      const Property*    property  ,
      const std::string& doc = ""  ) ;
    // ========================================================================
    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 = ""  )
    {
      const Property* property = &value ;
      return setProperty ( component , name , property , doc ) ;
    }
    // ========================================================================
  } // end of namespace Gaudi::Utils
} // end of namespace Gaudi


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

---