PropertyMgr.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_PROPERTYMGR_H
#define GAUDIKERNEL_PROPERTYMGR_H
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <iostream>
#include <vector>
#include <utility>
#include <stdexcept>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Property.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/DataObjectHandleProperty.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;

class GAUDI_API PropertyMgr : public implements<IProperty>
{
public:
  PropertyMgr ( IInterface* iface = nullptr );
  // copy constructor
  PropertyMgr ( const PropertyMgr& )  = delete;
  // assignment operator
  PropertyMgr& operator=( const PropertyMgr& ) = delete;
  ~PropertyMgr() override = default;
public:
  template<class TYPE>
  Property* declareProperty
  ( const std::string&       name  ,
    TYPE&                    value,
    const std::string&       doc = "none" ) ;
  template <class TYPE>
  Property* declareProperty
  ( const std::string&       name  ,
    SimpleProperty<TYPE>&    prop,
    const std::string&       doc = "none") ;
  template <class TYPE>
  Property* declareProperty
  ( const std::string&       name  ,
    SimplePropertyRef<TYPE>& prop,
    const std::string&       doc = "none") ;
  // partial specializations for various GaudiHandles
  template<class TYPE>
  Property* declareProperty
  ( const std::string& name,
    ToolHandle<TYPE>& ref,
    const std::string& doc = "none" ) ;
  template<class TYPE>
  Property* declareProperty
  ( const std::string& name,
    ServiceHandle<TYPE>& ref,
    const std::string& doc = "none" ) ;
  template<class TYPE>
  Property* declareProperty
  ( const std::string& name,
    ToolHandleArray<TYPE>& ref,
    const std::string& doc = "none" ) ;
  template<class TYPE>
  Property* declareProperty
  ( const std::string& name,
    ServiceHandleArray<TYPE>& ref,
    const std::string& doc = "none" ) ;
   template<class TYPE>
  Property* declareProperty
  ( const std::string& name,
     DataObjectHandle<TYPE>& ref, 
    const std::string& doc = "none" ) ;
  Property* declareRemoteProperty
  ( const std::string& name       ,
    IProperty*         rsvc       ,
    const std::string& rname = "" ) ;
  // ==========================================================================
  // IProperty implementation
  // ==========================================================================
  StatusCode setProperty(const Property& p) override;
  // ==========================================================================
  StatusCode setProperty( const std::string& s ) override;
  // ==========================================================================
  StatusCode setProperty( const std::string& n, const std::string& v) override;
  // ==========================================================================
  StatusCode getProperty(Property* p) const override;
  // ==========================================================================
  const Property& getProperty( const std::string& name) const override;
  // ==========================================================================
  StatusCode getProperty( const std::string& n, std::string& v ) const override;
  // ==========================================================================
  const std::vector<Property*>& getProperties( ) const override;
  // ==========================================================================
  bool hasProperty(const std::string& name) const override;
  // ==========================================================================
  // IInterface implementation
  StatusCode queryInterface(const InterfaceID& iid, void** pinterface) override;
  // ==========================================================================
protected:

  // get local or remote property by name
  Property* property       ( const std::string& name  ) const ;

private:

  Property* property
  ( const std::string&             name  ,
    const std::vector<Property*>&  props ) const ;

  void assertUniqueName(const std::string& name) const;

  // Some typedef to simply typing
  typedef std::vector<Property*>   Properties       ;
  typedef std::pair<std::string,
                    std::pair<IProperty*, std::string> > RemProperty;
  typedef std::vector<RemProperty> RemoteProperties ;

  Properties             m_properties      ;  // local  properties
  RemoteProperties       m_remoteProperties;  // Remote properties
  std::vector<std::unique_ptr<Property>> m_todelete ;  // properties to be deleted
  IInterface*            m_pOuter  ;  // Interface hub reference
};
// ============================================================================
// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name  ,
  TYPE&              value,
  const std::string& doc )
{
  assertUniqueName(name);
  m_todelete.emplace_back( new SimplePropertyRef<TYPE> ( name , value ) );
  Property* p = m_todelete.back().get();
  //
  p->setDocumentation( doc );
  m_properties .push_back( p ) ;
  //
  return p ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string&       name ,
  SimpleProperty<TYPE>&    prop,
  const std::string&       doc )
{
  assertUniqueName(name);
  Property* p = &prop ;
  //
  p -> setName           ( name  ) ;
  p -> setDocumentation  ( doc   ) ;
  m_properties.push_back ( p     ) ;
  //
  return p ;
}
// ============================================================================
// ============================================================================
template <class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string&       name ,
  SimplePropertyRef<TYPE>& prop,
  const std::string&       doc )
{
  assertUniqueName(name);
  Property* p = &prop ;
  //
  p -> setName             ( name  ) ;
  p -> setDocumentation    ( doc   ) ;
  m_properties.push_back   ( p     ) ;
  //
  return p ;
}
// ============================================================================
// Declare a property (templated)
// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name,
  ToolHandle<TYPE>& 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 ;
}
// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name,
  ServiceHandle<TYPE>& 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 ;
}
// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name,
  ToolHandleArray<TYPE>& 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 ;
}
// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name,
  ServiceHandleArray<TYPE>& 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 ;
}

// ============================================================================
template<class TYPE>
inline Property*
PropertyMgr::declareProperty
( const std::string& name,
  DataObjectHandle<TYPE>& ref, 
  const std::string& doc )
{
  assertUniqueName(name);
  Property* p = new DataObjectHandleProperty( name, ref );
  //
  p -> setDocumentation    ( doc ) ;
  m_properties . push_back ( p   ) ;
  //
  return p ;
}

// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_PROPERTYMGR_H
// ============================================================================