PropertyHolder.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Interfaces/IOptionsSvc.h>
#include <Gaudi/Property.h>
#include <GaudiKernel/Bootstrap.h>
#include <GaudiKernel/DataHandleProperty.h>
#include <GaudiKernel/INamedInterface.h>
#include <GaudiKernel/IProperty.h>
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/MsgStream.h>
#include <algorithm>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace Gaudi {
  namespace Details {
 
    template <typename T>
    constexpr bool is_gaudi_property_v = false;
 
    template <typename TYPE, typename VERIFIER, typename HANDLERS>
    constexpr bool is_gaudi_property_v<Gaudi::Property<TYPE, VERIFIER, HANDLERS>> = true;
 
  } // namespace Details
  namespace Utils {
    inline bool iequal( std::string_view v1, std::string_view v2 ) {
      return std::equal( begin( v1 ), end( v1 ), begin( v2 ), end( v2 ),
                         []( char c1, char c2 ) { return toupper( c1 ) == toupper( c2 ); } );
    }
  } // namespace Utils
} // namespace Gaudi
template <class BASE>
class GAUDI_API PropertyHolder : public BASE {
  static_assert( std::is_base_of_v<IProperty, BASE> && std::is_base_of_v<INamedInterface, BASE>,
                 "PropertyHolder template argument must inherit from IProperty and INamedInterface" );
 
public:
  using PropertyHolderImpl = PropertyHolder<BASE>;
 
  PropertyHolder() = 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 <typename TYPE>
    requires( !Gaudi::Details::is_gaudi_property_v<TYPE> )
  Gaudi::Details::PropertyBase* declareProperty( const std::string& name, TYPE& value,
                                                 const std::string& doc = "none" ) {
    auto make_property = [&]( const std::string& n, TYPE& v ) {
      if constexpr ( requires { typename TYPE::PropertyType; } ) {
        return std::make_unique<typename TYPE::PropertyType>( n, v );
      } else {
        return std::make_unique<Gaudi::Property<TYPE&>>( n, v );
      }
    };
    m_todelete.push_back( make_property( name, value ) );
    Gaudi::Details::PropertyBase* p = m_todelete.back().get();
 
    p->setDocumentation( doc );
    return &declareProperty( *p );
  }

  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" ) {
    Gaudi::Details::PropertyBase* p = &prop;
    p->setName( name );
 
    p->setDocumentation( doc );
    return &declareProperty( *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( RemProperty{ name, rsvc, nam } );
    return p;
  }

 
  // ==========================================================================
  // IProperty implementation
  // ==========================================================================
  using IProperty::setProperty;
  StatusCode setProperty( const std::string& name, const Gaudi::Details::PropertyBase& p ) override {
    Gaudi::Details::PropertyBase* pp = property( name );
    if ( pp && pp->assign( p ) ) return StatusCode::SUCCESS;
    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 setPropertyRepr( name, value );
  }

  StatusCode setPropertyRepr( const std::string& n, const std::string& r ) override {
    try {
      Gaudi::Details::PropertyBase* p = property( n );
      return ( p && p->fromString( r ) ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
    } catch ( const std::invalid_argument& err ) {
      throw GaudiException{ "error setting property " + n, this->name(), StatusCode::FAILURE, err };
    }
  }

  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( std::string_view name ) const override {
    const Gaudi::Details::PropertyBase* p = property( name );
    if ( !p ) throw std::out_of_range( "Property " + std::string{ name } + " not found." );
    return *p;
  }

  StatusCode getProperty( std::string_view 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( std::string_view 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 );
                   } ) ||
           any_of( begin( m_remoteProperties ), end( m_remoteProperties ),
                   [&name]( const auto& prop ) { return Gaudi::Utils::iequal( prop.name, name ); } );
  }

  // get local or remote property by name
  Gaudi::Details::PropertyBase* property( std::string_view 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.name, name ) ) continue;
      const IProperty* p = it.owner;
      if ( !p ) continue;
      return property( it.remName, p->getProperties() );
    }
    return nullptr;
  }
 
  void bindPropertiesTo( Gaudi::Interfaces::IOptionsSvc& optsSvc ) {
    auto set_prop = [&optsSvc, this]( auto prop ) { optsSvc.bind( this->name(), prop ); };
    std::for_each( begin( m_properties ), end( m_properties ), set_prop );
    std::for_each( begin( m_remoteProperties ), end( m_remoteProperties ), [&set_prop, this]( auto& rem ) {
      if ( rem.owner ) set_prop( this->property( rem.remName, rem.owner->getProperties() ) );
    } );
  }
 
private:
  Gaudi::Details::PropertyBase* property( std::string_view                                  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;
  }

  void assertUniqueName( std::string_view name ) const {
    if ( 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;
  struct RemProperty {
    std::string name;
    IProperty*  owner = nullptr;
    std::string remName;
  };
  typedef std::vector<RemProperty> RemoteProperties;

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