PropertyHolder.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_PROPERTYHOLDER_H
#define GAUDIKERNEL_PROPERTYHOLDER_H
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <algorithm>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/DataObjectHandleProperty.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Property.h"

// ============================================================================

// pre-declaration of GaudiHandles is sufficient
template <class T>
class ToolHandle;
template <class T>
class ServiceHandle;
template <class T>
class ToolHandleArray;
template <class T>
class ServiceHandleArray;
template <class T>
class DataObjectHandle;

namespace Gaudi
{
  namespace Utils
  {
    inline bool iequal( const std::string& v1, const std::string& v2 )
    {
      return v1.size() == v2.size() && std::equal( std::begin( v1 ), std::end( v1 ), std::begin( v2 ),
                                                   []( char c1, char c2 ) { return toupper( c1 ) == toupper( c2 ); } );
    }
  }
}
template <class BASE>
class GAUDI_API PropertyHolder : public BASE
{
  static_assert( std::is_base_of<IProperty, BASE>::value && std::is_base_of<INamedInterface, BASE>::value,
                 "PropertyHolder template argument must inherit from IProperty and INamedInterface" );

public:
  using PropertyHolderImpl = PropertyHolder<BASE>;

  PropertyHolder()           = default;
  ~PropertyHolder() override = default;

  PropertyHolder( const PropertyHolder& ) = delete;
  PropertyHolder& operator=( const PropertyHolder& ) = delete;

public:
  inline Gaudi::Details::PropertyBase& declareProperty( Gaudi::Details::PropertyBase& prop )
  {
    assertUniqueName( prop.name() );
    m_properties.push_back( &prop );
    return prop;
  }

  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, TYPE& value, const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new Gaudi::Property<TYPE&>( name, value ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();
    p->setDocumentation( doc );
    m_properties.push_back( p );
    return p;
  }

  template <class TYPE>
  [[deprecated(
      "Kept for backward compatibility, use the non-const version instead, will be removed in v28r1" )]] Gaudi::
      Details::PropertyBase*
      declareProperty( const std::string& name, TYPE& value, const std::string& doc = "none" ) const
  {
    return const_cast<PropertyHolder*>( this )->declareProperty<TYPE>( name, value, doc );
  }

  template <class TYPE, class VERIFIER, class HANDLERS>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name,
                                                 Gaudi::Property<TYPE, VERIFIER, HANDLERS>& prop,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    Gaudi::Details::PropertyBase* p = &prop;
    p->setName( name );
    p->setDocumentation( doc );
    m_properties.push_back( p );
    return p;
  }

  Gaudi::Details::PropertyBase* declareRemoteProperty( const std::string& name, IProperty* rsvc,
                                                       const std::string& rname = "" )
  {
    if ( !rsvc ) {
      return nullptr;
    }
    const std::string& nam          = rname.empty() ? name : rname;
    Gaudi::Details::PropertyBase* p = property( nam, rsvc->getProperties() );
    m_remoteProperties.emplace_back( name, std::make_pair( rsvc, nam ) );
    return p;
  }

  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandle<TYPE>& ref,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new GaudiHandleProperty( name, ref ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();

    p->setDocumentation( doc );
    m_properties.push_back( p );

    return p;
  }
  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ServiceHandle<TYPE>& ref,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new GaudiHandleProperty( name, ref ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();

    p->setDocumentation( doc );
    m_properties.push_back( p );

    return p;
  }
  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ToolHandleArray<TYPE>& ref,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new GaudiHandleArrayProperty( name, ref ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();

    p->setDocumentation( doc );
    m_properties.push_back( p );

    return p;
  }
  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, ServiceHandleArray<TYPE>& ref,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new GaudiHandleArrayProperty( name, ref ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();

    p->setDocumentation( doc );
    m_properties.push_back( p );

    return p;
  }
  template <class TYPE>
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, DataObjectHandle<TYPE>& ref,
                                                 const std::string& doc = "none" )
  {
    assertUniqueName( name );
    m_todelete.emplace_back( new DataObjectHandleProperty( name, ref ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();

    p->setDocumentation( doc );
    m_properties.push_back( p );

    return p;
  }

  // ==========================================================================
  // IProperty implementation
  // ==========================================================================
  StatusCode setProperty( const Gaudi::Details::PropertyBase& p ) override
  {
    Gaudi::Details::PropertyBase* pp = property( p.name() );
    try {
      if ( pp && pp->assign( p ) ) {
        return StatusCode::SUCCESS;
      }
    } catch ( ... ) {
    }
    return StatusCode::FAILURE;
  }
  // ==========================================================================
  StatusCode setProperty( const std::string& s ) override
  {
    std::string name;
    std::string value;
    StatusCode sc = Gaudi::Parsers::parse( name, value, s );
    if ( sc.isFailure() ) {
      return sc;
    }
    return setProperty( name, value );
  }
  // ==========================================================================
  StatusCode setProperty( const std::string& n, const std::string& v ) override
  {
    Gaudi::Details::PropertyBase* p = property( n );
    return ( p && p->fromString( v ) ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
  template <class TYPE>
  StatusCode setProperty( const std::string& name, const TYPE& value )
  {
    return Gaudi::Utils::setProperty( this, name, value );
  }
  // ==========================================================================
  StatusCode getProperty( Gaudi::Details::PropertyBase* p ) const override
  {
    try {
      const Gaudi::Details::PropertyBase* pp = property( p->name() );
      if ( pp && pp->load( *p ) ) return StatusCode::SUCCESS;
    } catch ( ... ) {
    }
    return StatusCode::FAILURE;
  }
  // ==========================================================================
  const Gaudi::Details::PropertyBase& getProperty( const std::string& name ) const override
  {
    const Gaudi::Details::PropertyBase* p = property( name );
    if ( !p ) throw std::out_of_range( "Property " + name + " not found." );
    return *p;
  }
  // ==========================================================================
  StatusCode getProperty( const std::string& n, std::string& v ) const override
  {
    // get the property
    const Gaudi::Details::PropertyBase* p = property( n );
    if ( !p ) {
      return StatusCode::FAILURE;
    }
    // convert the value into the string
    v = p->toString();
    return StatusCode::SUCCESS;
  }
  // ==========================================================================
  const std::vector<Gaudi::Details::PropertyBase*>& getProperties() const override { return m_properties; }
  // ==========================================================================
  bool hasProperty( const std::string& name ) const override
  {
    return any_of( begin( m_properties ), end( m_properties ), [&name]( const Gaudi::Details::PropertyBase* prop ) {
      return Gaudi::Utils::iequal( prop->name(), name );
    } );
  }
  // ==========================================================================
protected:
  // get local or remote property by name
  Gaudi::Details::PropertyBase* property( const std::string& name ) const
  {
    // local property ?
    Gaudi::Details::PropertyBase* lp = property( name, m_properties );
    if ( lp ) {
      return lp;
    }
    // look for remote property
    for ( const auto& it : m_remoteProperties ) {
      if ( !Gaudi::Utils::iequal( it.first, name ) ) {
        continue;
      }
      const IProperty* p = it.second.first;
      if ( !p ) {
        continue;
      }
      return property( it.second.second, p->getProperties() );
    }
    return nullptr; // RETURN
  }

private:
  Gaudi::Details::PropertyBase* property( const std::string& name,
                                          const std::vector<Gaudi::Details::PropertyBase*>& props ) const
  {
    auto it = std::find_if( props.begin(), props.end(), [&name]( Gaudi::Details::PropertyBase* p ) {
      return p && Gaudi::Utils::iequal( p->name(), name );
    } );
    return ( it != props.end() ) ? *it : nullptr; // RETURN
  }

  void assertUniqueName( const std::string& name ) const
  {
    if ( UNLIKELY( hasProperty( name ) ) ) {
      auto msgSvc = Gaudi::svcLocator()->service<IMessageSvc>( "MessageSvc" );
      if ( !msgSvc ) {
        std::cerr << "error: cannot get MessageSvc!" << std::endl;
      }
      MsgStream log( msgSvc, this->name() );
      log << MSG::WARNING << "duplicated property name '" << name << "', see https://its.cern.ch/jira/browse/GAUDI-1023"
          << endmsg;
    }
  }

  typedef std::vector<Gaudi::Details::PropertyBase*> Properties;
  typedef std::pair<std::string, std::pair<IProperty*, std::string>> RemProperty;
  typedef std::vector<RemProperty> RemoteProperties;

  Properties m_properties;
  RemoteProperties m_remoteProperties;
  std::vector<std::unique_ptr<Gaudi::Details::PropertyBase>> m_todelete;
};
#endif