CArrayAsProperty.h

Go to the documentation of this file.

#ifndef NO_C_ARRAY_AS_PROPERTY_WARNING
#warning deprecated header (will be removed in Gaudi v29r0), think about using std::array<T,N> instead of T[N]
#endif
#ifndef GAUDIKERNEL_CARRAYASPROPERTY_H
#define GAUDIKERNEL_CARRAYASPROPERTY_H
#include "GaudiKernel/Property.h"

namespace Gaudi
{
  template <class TYPE, size_t N, class VERIFIER, class HANDLERS>
  class Property<TYPE[N], VERIFIER, HANDLERS> : public Details::PropertyBase
  {
  public:
    // ==========================================================================
    using StorageType  = TYPE ( & )[N];
    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, typename std::remove_reference<T>::type>;
    template <class T>
    using not_copying = std::enable_if<!is_this_type<T>::value>;
  public:
    // ==========================================================================
    inline Property( std::string name, StorageType value, std::string doc = "" )
        : PropertyBase( typeid( ValueType ), std::move( name ), std::move( doc ) ), m_value( value )
    {
      m_verifier( m_value );
    }

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

    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(); }

    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;
    // }

    Property& operator=( const ValueType& v )
    {
      m_verifier( v );
      for ( size_t i = 0; i != N; ++i ) {
        m_value[i] = v[i];
      }
      m_handlers.useUpdateHandler( *this );
      return *this;
    }

    // Property(const Property& other):
    //   PropertyBase(other), value(other.m_value) {}

    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;
    }
    PropertyBase* clone() const override { return new Property( *this ); }

    inline size_t size() const { return N; }
    inline bool empty() const { return false; }
    template <class T = const ValueType>
    inline decltype( std::declval<T>()[typename T::key_type{}] ) operator[]( const typename T::key_type& key ) const
    {
      return value()[key];
    }
    template <class T = ValueType>
    inline decltype( std::declval<T>()[typename T::key_type{}] ) operator[]( const typename T::key_type& key )
    {
      return value()[key];
    }
    // ==========================================================================
  public:
    bool assign( const PropertyBase& source ) override
    {
      // Is the property of "the same" type?
      const Property* p = dynamic_cast<const Property*>( &source );
      if ( p ) {
        *this = p->value();
      } else {
        this->fromString( source.toString() ).ignore();
      }
      return true;
    }
    bool load( PropertyBase& dest ) const override
    {
      // delegate to the 'opposite' method
      return dest.assign( *this );
    }
    StatusCode fromString( const std::string& source ) override
    {
      ValueType tmp;
      if ( Parsers::parse( tmp, source ).isSuccess() ) {
        *this = tmp;
      } else {
        throw std::invalid_argument( "cannot parse '" + source + "' to " + this->type() );
      }
      return StatusCode::SUCCESS;
    }
    std::string toString() const override
    {
      m_handlers.useReadHandler( *this );
      return Utils::toString( m_value );
    }
    void toStream( std::ostream& out ) const override
    {
      m_handlers.useReadHandler( *this );
      Utils::toStream( m_value, out );
    }
  };
  template <class TYPE, size_t N, class VERIFIER, class HANDLERS>
  class Property<TYPE ( & )[N], VERIFIER, HANDLERS> : public Property<TYPE[N], VERIFIER, HANDLERS>
  {
  public:
    using Property<TYPE[N], VERIFIER, HANDLERS>::Property;
  };
}
#endif