PropertyMgr.cpp

Go to the documentation of this file.

// hide deprecation warnings here... the whole file is deprecated
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
// ============================================================================
// Include files
// ============================================================================
// STD& STL
// ============================================================================
#include <algorithm>
#include <functional>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/PropertyMgr.h"
// ============================================================================

using Gaudi::Details::PropertyBase;

namespace
{
  // ==========================================================================
  constexpr struct NoCaseCmp_t {
    inline bool operator()( const std::string& v1, const std::string& v2 ) const
    {
      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 ); } );
    }
  } noCaseCmp{};
  // ==========================================================================
  struct PropByName {
    std::string m_name;

    inline bool operator()( const PropertyBase* p ) const { return p && noCaseCmp( p->name(), m_name ); }
  };
  // ==========================================================================
}
// ====================================================================
// constructor from the interface
// ====================================================================
PropertyMgr::PropertyMgr( IInterface* iface ) : m_pOuter( iface )
{
  addRef(); // initial reference count set to 1
}
// ====================================================================
// Declare a remote property
// ====================================================================
PropertyBase* PropertyMgr::declareRemoteProperty( const std::string& name, IProperty* rsvc, const std::string& rname )
{
  if ( !rsvc ) {
    return nullptr;
  }
  const std::string& nam = rname.empty() ? name : rname;
  PropertyBase* p        = property( nam, rsvc->getProperties() );
  m_remoteProperties.emplace_back( name, std::make_pair( rsvc, nam ) );
  return p;
}
// ============================================================================
// Declare a property
// ============================================================================
PropertyBase* PropertyMgr::declareProperty( const std::string& name, GaudiHandleBase& ref, const std::string& doc )
{
  assertUniqueName( name );
  m_todelete.emplace_back( new GaudiHandleProperty( name, ref ) );
  Property* p = m_todelete.back().get();
  //
  p->setDocumentation( doc );
  m_properties.push_back( p );
  //
  return p;
}
// ============================================================================
PropertyBase* PropertyMgr::declareProperty( const std::string& name, GaudiHandleArrayBase& ref, const std::string& doc )
{
  assertUniqueName( name );
  m_todelete.emplace_back( new GaudiHandleArrayProperty( name, ref ) );
  Property* p = m_todelete.back().get();
  //
  p->setDocumentation( doc );
  m_properties.push_back( p );
  //
  return p;
}

// ============================================================================
PropertyBase* PropertyMgr::declareProperty( const std::string& name, DataObjectHandleBase& ref, const std::string& doc )
{
  assertUniqueName( name );
  m_todelete.emplace_back( new DataObjectHandleProperty( name, ref ) );
  Property* p = m_todelete.back().get();
  //
  p->setDocumentation( doc );
  m_properties.push_back( p );
  //
  return p;
}
// ====================================================================
// get the property by name form the proposed list
// ====================================================================
PropertyBase* PropertyMgr::property( const std::string& name, const std::vector<PropertyBase*>& props ) const
{
  auto it = std::find_if( props.begin(), props.end(), PropByName{name} );
  return ( it != props.end() ) ? *it : nullptr; // RETURN
}
// ====================================================================
// retrieve the property by name
// ====================================================================
PropertyBase* PropertyMgr::property( const std::string& name ) const
{
  // local property ?
  PropertyBase* lp = property( name, m_properties );
  if ( lp ) {
    return lp;
  } // RETURN
  // look for remote property
  for ( const auto& it : m_remoteProperties ) {
    if ( !noCaseCmp( it.first, name ) ) {
      continue;
    } // CONTINUE
    const IProperty* p = it.second.first;
    if ( !p ) {
      continue;
    }                                                        // CONTINUE
    return property( it.second.second, p->getProperties() ); // RETURN
  }
  return nullptr; // RETURN
}
// ====================================================================
/* set a property from another property
 *  Implementation of IProperty::setProperty
 */
// =====================================================================
StatusCode PropertyMgr::setProperty( const PropertyBase& p )
{
  PropertyBase* pp = property( p.name() );
  try {
    if ( pp && pp->assign( p ) ) {
      return StatusCode::SUCCESS;
    }
  } // RETURN
  catch ( ... ) {
  }
  //
  return StatusCode::FAILURE;
}
// ====================================================================
/* set a property from the stream
 *  Implementation of IProperty::setProperty
 */
// =====================================================================
StatusCode PropertyMgr::setProperty( const std::string& i )
{
  std::string name;
  std::string value;
  StatusCode sc = Gaudi::Parsers::parse( name, value, i );
  if ( sc.isFailure() ) {
    return sc;
  }
  return setProperty( name, value );
}
// =====================================================================
/* set a property from the string
 *  Implementation of IProperty::setProperty
 */
// =====================================================================
StatusCode PropertyMgr::setProperty( const std::string& n, const std::string& v )
{
  PropertyBase* p = property( n );
  return ( p && p->fromString( v ) ) ? StatusCode::SUCCESS : StatusCode::FAILURE;
}
// =====================================================================
/* Retrieve the value of a property
 *  Implementation of IProperty::getProperty
 */
// =====================================================================
StatusCode PropertyMgr::getProperty( PropertyBase* p ) const
{
  try {
    const PropertyBase* pp = property( p->name() );
    if ( pp && pp->load( *p ) ) return StatusCode::SUCCESS; // RETURN
  } catch ( ... ) {
  }
  return StatusCode::FAILURE; // RETURN
}
// =====================================================================
/* Get the property by name
 *  Implementation of IProperty::getProperty
 */
// =====================================================================
const PropertyBase& PropertyMgr::getProperty( const std::string& name ) const
{
  const PropertyBase* p = property( name );
  if ( !p ) throw std::out_of_range( "Property " + name + " not found." ); // Not found
  return *p;                                                               // RETURN
}
// =====================================================================
/* Get the property by name
 *  Implementation of IProperty::getProperty
 */
// =====================================================================
StatusCode PropertyMgr::getProperty( const std::string& n, std::string& v ) const
{
  // get the property
  const PropertyBase* p = property( n );
  if ( !p ) {
    return StatusCode::FAILURE;
  }
  // convert the value into the string
  v = p->toString();
  //
  return StatusCode::SUCCESS;
}
// =====================================================================
// Implementation of IProperty::getProperties
// =====================================================================
const std::vector<PropertyBase*>& PropertyMgr::getProperties() const { return m_properties; }
// =====================================================================
// Implementation of IInterface::queryInterface
// =====================================================================
StatusCode PropertyMgr::queryInterface( const InterfaceID& iid, void** pinterface )
{
  // try local interfaces
  StatusCode sc = base_class::queryInterface( iid, pinterface );
  if ( sc.isSuccess() ) return sc;
  // fall back on the owner
  return m_pOuter ? m_pOuter->queryInterface( iid, pinterface ) : sc; // FAILURE
}
// =====================================================================
// Implementation of IProperty::hasProperty
// =====================================================================
bool PropertyMgr::hasProperty( const std::string& name ) const
{
  return any_of( begin( m_properties ), end( m_properties ),
                 [&name]( const PropertyBase* prop ) { return noCaseCmp( prop->name(), name ); } );
}
void PropertyMgr::assertUniqueName( const std::string& name ) const
{
  if ( UNLIKELY( hasProperty( name ) ) ) {
    auto owner  = SmartIF<INamedInterface>( m_pOuter );
    auto msgSvc = Gaudi::svcLocator()->service<IMessageSvc>( "MessageSvc" );
    if ( !msgSvc ) {
      std::cerr << "error: cannot get MessageSvc!" << std::endl;
    }
    MsgStream log( msgSvc, owner ? owner->name() : "PropertyMgr" );
    log << MSG::WARNING << "duplicated property name '" << name << "', see https://its.cern.ch/jira/browse/GAUDI-1023"
        << endmsg;
  }
}
// =====================================================================
// The END
// =====================================================================