Property.h

Go to the documentation of this file.

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

namespace Gaudi
{
  namespace Details
  {
    // ============================================================================
    class GAUDI_API PropertyBase
    {
    private:
      // the default constructor is disabled
      PropertyBase() = delete;

    public:
      const std::string name() const { return m_name.to_string(); }
      std::string documentation() const { return m_documentation.to_string(); }
      const std::type_info* type_info() const { return m_typeinfo; }
      std::string type() const { return m_typeinfo->name(); }
      virtual bool load( PropertyBase& dest ) const = 0;
      virtual bool assign( const PropertyBase& 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:
      virtual PropertyBase& declareReadHandler( std::function<void( PropertyBase& )> fun ) = 0;
      virtual PropertyBase& declareUpdateHandler( std::function<void( PropertyBase& )> fun ) = 0;

      virtual const std::function<void( PropertyBase& )> readCallBack() const = 0;
      virtual const std::function<void( PropertyBase& )> updateCallBack() const = 0;

      virtual bool useUpdateHandler() = 0;

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

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

    public:
      virtual ~PropertyBase() = default;
      void setName( std::string value ) { m_name = to_view( std::move( value ) ); }
      void setDocumentation( std::string value ) { m_documentation = to_view( std::move( value ) ); }
      virtual std::ostream& fillStream( std::ostream& ) const;
      virtual PropertyBase* clone() const = 0;

      void setOwnerType( const std::type_info& ownerType ) { m_ownerType = &ownerType; }

      template <class OWNER>
      void setOwnerType()
      {
        setOwnerType( typeid( OWNER ) );
      }

      const std::type_info* ownerType() const { return m_ownerType; }

      std::string ownerTypeName() const
      {
        return m_ownerType ? System::typeinfoName( *m_ownerType ) : std::string( "unknown owner type" );
      }

    protected:
      PropertyBase( const std::type_info& type, std::string name = "", std::string doc = "" )
          : m_name( to_view( std::move( name ) ) ), m_documentation( to_view( std::move( doc ) ) ), m_typeinfo( &type )
      {
      }
      PropertyBase( std::string name, const std::type_info& type )
          : m_name( to_view( std::move( name ) ) ), m_documentation( m_name ), m_typeinfo( &type )
      {
      }
      PropertyBase( const PropertyBase& ) = default;
      PropertyBase& operator=( const PropertyBase& ) = default;

    private:
      static boost::string_ref to_view( std::string str );
      boost::string_ref m_name;
      boost::string_ref m_documentation;
      const std::type_info* m_typeinfo;
      const std::type_info* m_ownerType = nullptr;
    };

    inline std::ostream& operator<<( std::ostream& stream, const PropertyBase& prop )
    {
      return prop.fillStream( stream );
    }

    namespace Property
    {
      // The following code is going to be a bit unpleasant, but as far as its
      // author can tell, it is as simple as the design constraints and C++'s
      // implementation constraints will allow. If you disagree, please submit
      // a patch which simplifies it. Here is the underlying design rationale:
      //
      // - For any given type T used in a Property, we want to have an
      //   associated StringConverter<T> struct which explains how to convert a
      //   value of that type into a string (toString) and parse that string
      //   back (fromString).
      // - There is a default implementation, called DefaultStringConverter<T>,
      //   which is based on the overloadable parse() and toStream() global
      //   methods of Gaudi. Its exact behaviour varies depending on whether T
      //   is default-constructible or only copy-constructible, which requires a
      //   layer of SFINAE indirection.
      // - Some people want to be able to specialize StringConverter as an
      //   alternative to defining parse/toStream overloads. This interferes
      //   with the SFINAE tricks used by DefaultStringConverter, so we cannot
      //   just call a DefaultStringConverter a StringConverter and must add one
      //   more layer to the StringConverter type hierarchy.

      // This class factors out commonalities between DefaultStringConverters
      template <class TYPE>
      struct DefaultStringConverterImpl {
      public:
        inline std::string toString( const TYPE& v )
        {
          using Gaudi::Utils::toString;
          return toString( v );
        }

        // Implementation of fromString depends on whether TYPE is default-
        // constructible (fastest, easiest) or only copy-constructible (still
        // doable as long as the caller can provide a valid value of TYPE)
        virtual TYPE fromString( const TYPE& ref_value, const std::string& s ) = 0;

      protected:
        inline void fromStringImpl( TYPE& buffer, const std::string& s )
        {
          using Gaudi::Parsers::parse;
          if ( !parse( buffer, s ).isSuccess() ) {
            throw std::invalid_argument( "cannot parse '" + s + "' to " + System::typeinfoName( typeid( TYPE ) ) );
          }
        }
      };
      // Specialization of toString for strings (identity function)
      template <>
      inline std::string DefaultStringConverterImpl<std::string>::toString( const std::string& v )
      {
        return v;
      }

      // This class provides a default implementation of StringConverter based
      // on the overloadable parse() and toStream() global Gaudi methods.
      //
      // It leverages the fact that TYPE is default-constructible if it can, and
      // falls back fo a requirement of copy-constructibility if it must. So
      // here is the "default" implementation for copy-constructible types...
      //
      template <typename TYPE, typename Enable = void>
      struct DefaultStringConverter : DefaultStringConverterImpl<TYPE> {
        inline TYPE fromString( const TYPE& ref_value, const std::string& s ) final override
        {
          TYPE buffer = ref_value;
          this->fromStringImpl( buffer, s );
          return buffer;
        }
      };
      // ...and here is the preferred impl for default-constructible types:
      template <class TYPE>
      struct DefaultStringConverter<TYPE, std::enable_if_t<std::is_default_constructible<TYPE>::value>>
          : DefaultStringConverterImpl<TYPE> {
        inline TYPE fromString( const TYPE& /* ref_value */, const std::string& s ) final override
        {
          TYPE buffer{};
          this->fromStringImpl( buffer, s );
          return buffer;
        }
      };

      // Specializable StringConverter struct with a default implementation
      template <typename TYPE>
      struct StringConverter : DefaultStringConverter<TYPE> {
      };

      struct NullVerifier {
        template <class TYPE>
        void operator()( const TYPE& ) const
        {
        }
      };
      template <class TYPE>
      struct BoundedVerifier {
        void operator()( const TYPE& value ) const
        {
          using Gaudi::Utils::toString;
          // throw the exception if the limit is defined and value is outside
          if ( ( m_hasLowerBound && ( value < m_lowerBound ) ) || ( m_hasUpperBound && ( m_upperBound < value ) ) )
            throw std::out_of_range( "value " + toString( value ) + " outside range" );
        }

        bool hasLower() const { return m_hasLowerBound; }
        bool hasUpper() const { return m_hasUpperBound; }
        const TYPE& lower() const { return m_lowerBound; }
        const TYPE& upper() const { return m_upperBound; }

        void setLower( const TYPE& value )
        {
          m_hasLowerBound = true;
          m_lowerBound    = value;
        }
        void setUpper( const TYPE& value )
        {
          m_hasUpperBound = true;
          m_upperBound    = value;
        }
        void clearLower()
        {
          m_hasLowerBound = false;
          m_lowerBound    = TYPE();
        }
        void clearUpper()
        {
          m_hasUpperBound = false;
          m_upperBound    = TYPE();
        }

        void setBounds( const TYPE& lower, const TYPE& upper )
        {
          setLower( lower );
          setUpper( upper );
        }

        void clearBounds()
        {
          clearLower();
          clearUpper();
        }

      private:
        bool m_hasLowerBound{false};
        bool m_hasUpperBound{false};
        TYPE m_lowerBound{};
        TYPE m_upperBound{};
      };

      struct SwapCall {
        using callback_t = std::function<void( PropertyBase& )>;
        callback_t tmp, &orig;
        SwapCall( callback_t& input ) : orig( input ) { tmp.swap( orig ); }
        ~SwapCall() { orig.swap( tmp ); }
        void operator()( PropertyBase& p ) const { tmp( p ); }
      };

      struct NoHandler {
        void useReadHandler( const PropertyBase& ) const {}
        void setReadHandler( std::function<void( PropertyBase& )> )
        {
          throw std::logic_error( "setReadHandler not implemented for this class" );
        }
        std::function<void( PropertyBase& )> getReadHandler() const { return nullptr; }
        void useUpdateHandler( const PropertyBase& ) const {}
        void setUpdateHandler( std::function<void( PropertyBase& )> )
        {
          throw std::logic_error( "setUpdateHandler not implemented for this class" );
        }
        std::function<void( PropertyBase& )> getUpdateHandler() const { return nullptr; }
      };
      struct ReadHandler : NoHandler {
        mutable std::function<void( PropertyBase& )> m_readCallBack;
        void useReadHandler( const PropertyBase& p ) const
        {
          if ( m_readCallBack ) {
            SwapCall{m_readCallBack}( const_cast<PropertyBase&>( p ) );
          }
        }
        void setReadHandler( std::function<void( PropertyBase& )> fun ) { m_readCallBack = std::move( fun ); }
        std::function<void( PropertyBase& )> getReadHandler() const { return m_readCallBack; }
      };
      struct UpdateHandler : NoHandler {
        std::function<void( PropertyBase& )> m_updateCallBack;
        void useUpdateHandler( PropertyBase& p )
        {
          if ( m_updateCallBack ) {
            try {
              SwapCall{m_updateCallBack}( p );
            } catch ( const std::exception& x ) {
              throw std::invalid_argument( "failure in update handler of '" + p.name() + "': " + x.what() );
            }
          }
        }
        void setUpdateHandler( std::function<void( PropertyBase& )> fun ) { m_updateCallBack = std::move( fun ); }
        std::function<void( PropertyBase& )> getUpdateHandler() const { return m_updateCallBack; }
      };
      struct ReadUpdateHandler : ReadHandler, UpdateHandler {
        using ReadHandler::useReadHandler;
        using ReadHandler::setReadHandler;
        using ReadHandler::getReadHandler;
        using UpdateHandler::useUpdateHandler;
        using UpdateHandler::setUpdateHandler;
        using UpdateHandler::getUpdateHandler;
      };
    }

  } // namespace Details

  // ============================================================================
  // ============================================================================
  template <class TYPE, class VERIFIER = Details::Property::NullVerifier,
            class HANDLERS = Details::Property::UpdateHandler>
  class Property : public Details::PropertyBase
  {
  public:
    // ==========================================================================
    using StorageType  = TYPE;
    using ValueType    = typename std::remove_reference<StorageType>::type;
    using VerifierType = VERIFIER;
    using HandlersType = HANDLERS;

  private:
    StorageType m_value;
    VerifierType m_verifier;
    HandlersType m_handlers;
    template <class T>
    using is_this_type = std::is_same<Property, std::remove_reference_t<T>>;
    template <class T>
    using not_copying = std::enable_if_t<!is_this_type<T>::value>;
  public:
    // ==========================================================================
    template <class T = StorageType>
    inline Property( std::string name, T&& value, std::string doc = "" )
        : Details::PropertyBase( typeid( ValueType ), std::move( name ), std::move( doc ) )
        , m_value( std::forward<T>( value ) )
    {
      m_verifier( m_value );
    }
    template <typename OWNER, typename T = ValueType,
              typename = std::enable_if_t<std::is_base_of<IProperty, OWNER>::value>,
              typename = std::enable_if_t<std::is_default_constructible<T>::value>>
    inline Property( OWNER* owner, std::string name ) : Property( std::move( name ), ValueType{}, "" )
    {
      owner->declareProperty( *this );
      setOwnerType<OWNER>();
    }

    template <class OWNER, class T = StorageType, typename = std::enable_if_t<std::is_base_of<IProperty, OWNER>::value>>
    inline Property( OWNER* owner, std::string name, T&& value, std::string doc = "" )
        : Property( std::move( name ), std::forward<T>( value ), std::move( doc ) )
    {
      owner->declareProperty( *this );
      setOwnerType<OWNER>();
    }

    template <typename T, typename = not_copying<T>>
    Property( T&& v ) : Details::PropertyBase( typeid( ValueType ), "", "" ), m_value( std::forward<T>( v ) )
    {
    }

    template <typename T = StorageType, typename = std::enable_if_t<!std::is_reference<T>::value>>
    Property() : Details::PropertyBase( typeid( ValueType ), "", "" ), m_value()
    {
    }

    using Details::PropertyBase::declareReadHandler;
    using Details::PropertyBase::declareUpdateHandler;

    Details::PropertyBase& declareReadHandler( std::function<void( Details::PropertyBase& )> fun ) override
    {
      m_handlers.setReadHandler( std::move( fun ) );
      return *this;
    }
    Details::PropertyBase& declareUpdateHandler( std::function<void( Details::PropertyBase& )> fun ) override
    {
      m_handlers.setUpdateHandler( std::move( fun ) );
      return *this;
    }

    const std::function<void( Details::PropertyBase& )> readCallBack() const override
    {
      return m_handlers.getReadHandler();
    }
    const std::function<void( Details::PropertyBase& )> updateCallBack() const override
    {
      return m_handlers.getUpdateHandler();
    }

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

    operator const ValueType&() const
    {
      m_handlers.useReadHandler( *this );
      return m_value;
    }
    // /// Automatic conversion to value (reference).
    // operator ValueType& () {
    //   useReadHandler();
    //   return m_value;
    // }

    template <class T>
    inline bool operator==( const T& other ) const
    {
      return m_value == other;
    }

    template <class T>
    inline bool operator!=( const T& other ) const
    {
      return m_value != other;
    }

    template <class T>
    inline bool operator<( const T& other ) const
    {
      return m_value < other;
    }

    template <class T>
    decltype( std::declval<ValueType>() + std::declval<T>() ) operator+( const T& other ) const
    {
      return m_value + other;
    }

    template <class T = ValueType>
    Property& operator=( T&& v )
    {
      m_verifier( v );
      m_value = std::forward<T>( v );
      m_handlers.useUpdateHandler( *this );
      return *this;
    }

    const VerifierType& verifier() const { return m_verifier; }
    VerifierType& verifier() { return m_verifier; }

    const ValueType& value() const { return *this; }
    ValueType& value() { return const_cast<ValueType&>( (const ValueType&)*this ); }
    bool setValue( const ValueType& v )
    {
      *this = v;
      return true;
    }
    bool set( const ValueType& v )
    {
      *this = v;
      return true;
    }
    Details::PropertyBase* clone() const override { return new Property( *this ); }

    template <class T = const ValueType>
    inline decltype( std::declval<T>().size() ) size() const
    {
      return value().size();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().length() ) length() const
    {
      return value().length();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().empty() ) empty() const
    {
      return value().empty();
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().clear() ) clear()
    {
      value().clear();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().begin() ) begin() const
    {
      return value().begin();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().end() ) end() const
    {
      return value().end();
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().begin() ) begin()
    {
      return value().begin();
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().end() ) end()
    {
      return value().end();
    }
    template <class ARG>
    inline decltype( auto ) operator[]( const ARG& arg ) const
    {
      return value()[arg];
    }
    template <class ARG>
    inline decltype( auto ) operator[]( const ARG& arg )
    {
      return value()[arg];
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().find( typename T::key_type{} ) ) find( const typename T::key_type& key ) const
    {
      return value().find( key );
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().find( typename T::key_type{} ) ) find( const typename T::key_type& key )
    {
      return value().find( key );
    }
    template <class ARG, class T = ValueType>
    inline decltype( std::declval<T>().erase( ARG{} ) ) erase( ARG arg )
    {
      return value().erase( arg );
    }
    template <class = ValueType>
    inline Property& operator++()
    {
      ++value();
      return *this;
    }
    template <class = ValueType>
    inline ValueType operator++( int )
    {
      return m_value++;
    }
    template <class = ValueType>
    inline Property& operator--()
    {
      --value();
      return *this;
    }
    template <class = ValueType>
    inline ValueType operator--( int )
    {
      return m_value--;
    }
    template <class T = ValueType>
    inline Property& operator+=( const T& other )
    {
      m_value += other;
      return *this;
    }
    template <class T = ValueType>
    inline Property& operator-=( const T& other )
    {
      m_value -= other;
      return *this;
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().key() ) key() const
    {
      return value().key();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().objKey() ) objKey() const
    {
      return value().objKey();
    }
    template <class T = const ValueType>
    inline decltype( std::declval<T>().fullKey() ) fullKey() const
    {
      return value().fullKey();
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().initialize() ) initialize()
    {
      return value().initialize();
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>().makeHandles() ) makeHandles() const
    {
      return value().makeHandles();
    }
    template <class ARG, class T = ValueType>
    inline decltype( std::declval<T>().makeHandles( std::declval<ARG>() ) ) makeHandles( const ARG& arg ) const
    {
      return value().makeHandles( arg );
    }
    // ==========================================================================
  public:
    bool assign( const Details::PropertyBase& source ) override
    {
      // Check if the property of is of "the same" type, except for strings
      const Property* p =
          ( std::is_same<ValueType, std::string>::value ) ? nullptr : dynamic_cast<const Property*>( &source );
      if ( p ) {
        *this = p->value();
      } else {
        this->fromString( source.toString() ).ignore();
      }
      return true;
    }
    bool load( Details::PropertyBase& dest ) const override
    {
      // delegate to the 'opposite' method
      return dest.assign( *this );
    }
    StatusCode fromString( const std::string& source ) override
    {
      using Converter = Details::Property::StringConverter<ValueType>;
      *this           = Converter().fromString( m_value, source );
      return StatusCode::SUCCESS;
    }
    std::string toString() const override
    {
      using Converter = Details::Property::StringConverter<ValueType>;
      return Converter().toString( *this );
    }
    void toStream( std::ostream& out ) const override
    {
      m_handlers.useReadHandler( *this );
      using Utils::toStream;
      toStream( m_value, out );
    }
  };

  template <class T, class TP, class V, class H>
  bool operator==( const T& v, const Property<TP, V, H>& p )
  {
    return p == v;
  }

  template <class T, class TP, class V, class H>
  bool operator!=( const T& v, const Property<TP, V, H>& p )
  {
    return p != v;
  }

  template <class T, class TP, class V, class H>
  decltype( std::declval<TP>() + std::declval<T>() ) operator+( const T& v, const Property<TP, V, H>& p )
  {
    return v + p.value();
  }

  template <class TYPE, class HANDLERS = Details::Property::UpdateHandler>
  using CheckedProperty = Property<TYPE, Details::Property::BoundedVerifier<TYPE>, HANDLERS>;

  template <class TYPE>
  using PropertyWithReadHandler =
      Property<TYPE, Details::Property::NullVerifier, Gaudi::Details::Property::ReadUpdateHandler>;

} // namespace Gaudi

template <class TYPE>
using SimpleProperty = Gaudi::Property<TYPE>;

template <class TYPE>
using SimplePropertyRef = Gaudi::Property<TYPE&>;

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

typedef Gaudi::Property<std::string> StringProperty;

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

typedef Gaudi::Property<std::string&> StringPropertyRef;

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

typedef Gaudi::Property<std::vector<std::string>> StringArrayProperty;

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

typedef Gaudi::Property<std::vector<std::string>&> StringArrayPropertyRef;

template <typename Handler = typename Gaudi::Details::Property::UpdateHandler>
class PropertyWithHandlers : public Gaudi::Details::PropertyBase
{
  Handler m_handlers;

public:
  using PropertyBase::PropertyBase;

  PropertyBase& declareReadHandler( std::function<void( PropertyBase& )> fun ) override
  {
    m_handlers.setReadHandler( std::move( fun ) );
    return *this;
  }
  PropertyBase& declareUpdateHandler( std::function<void( PropertyBase& )> fun ) override
  {
    m_handlers.setUpdateHandler( std::move( fun ) );
    return *this;
  }

  const std::function<void( PropertyBase& )> readCallBack() const override { return m_handlers.getReadHandler(); }
  const std::function<void( PropertyBase& )> updateCallBack() const override { return m_handlers.getUpdateHandler(); }

  void useReadHandler() const { m_handlers.useReadHandler( *this ); }

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

// forward-declaration is sufficient here
class GaudiHandleBase;

// 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
class GAUDI_API GaudiHandleProperty : public PropertyWithHandlers<>
{
public:
  GaudiHandleProperty( std::string name, GaudiHandleBase& ref );

  GaudiHandleProperty& operator=( const GaudiHandleBase& value )
  {
    setValue( value );
    return *this;
  }

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

  bool load( PropertyBase& destination ) const override { return destination.assign( *this ); }

  bool assign( const PropertyBase& source ) override { return fromString( source.toString() ).isSuccess(); }

  std::string toString() const override;

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

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

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

  bool setValue( const GaudiHandleBase& value );

private:
  GaudiHandleBase* m_pValue;
};

// forward-declaration is sufficient here
class GaudiHandleArrayBase;

class GAUDI_API GaudiHandleArrayProperty : public PropertyWithHandlers<>
{
public:
  GaudiHandleArrayProperty( std::string name, GaudiHandleArrayBase& ref );

  GaudiHandleArrayProperty& operator=( const GaudiHandleArrayBase& value )
  {
    setValue( value );
    return *this;
  }

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

  bool load( PropertyBase& destination ) const override { return destination.assign( *this ); }

  bool assign( const PropertyBase& source ) override { return fromString( source.toString() ).isSuccess(); }

  std::string toString() const override;

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

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

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

  bool setValue( const GaudiHandleArrayBase& value );

private:
  GaudiHandleArrayBase* 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 Gaudi::Details::PropertyBase* getProperty( const IProperty* p, const std::string& name );
    // ========================================================================
    GAUDI_API Gaudi::Details::PropertyBase* getProperty( const IInterface* p, const std::string& name );
    // ========================================================================
    GAUDI_API bool hasProperty( const std::vector<const Gaudi::Details::PropertyBase*>* p, const std::string& name );
    // ========================================================================
    GAUDI_API const Gaudi::Details::PropertyBase*
    getProperty( const std::vector<const Gaudi::Details::PropertyBase*>* 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 )
    {
      using Gaudi::Utils::toString;
      return component && hasProperty( component, name )
                 ? Gaudi::Utils::setProperty( component, name, toString( value ), doc )
                 : StatusCode::FAILURE;
    }
    // ========================================================================
    GAUDI_API StatusCode setProperty( IProperty* component, const std::string& name,
                                      const Gaudi::Details::PropertyBase* property, const std::string& doc = "" );
    // ========================================================================
    GAUDI_API StatusCode setProperty( IProperty* component, const std::string& name,
                                      const Gaudi::Details::PropertyBase& property, const std::string& doc = "" );
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty( IProperty* component, const std::string& name, const Gaudi::Property<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 Gaudi::Details::PropertyBase* property, const std::string& doc = "" );
    // ========================================================================
    GAUDI_API StatusCode setProperty( IInterface* component, const std::string& name,
                                      const Gaudi::Details::PropertyBase& property, const std::string& doc = "" );
    // ========================================================================
    template <class TYPE>
    StatusCode setProperty( IInterface* component, const std::string& name, const Gaudi::Property<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
// ============================================================================