GaudiHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_GAUDIHANDLE_H
#define GAUDIKERNEL_GAUDIHANDLE_H

//Includes
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/GaudiException.h"

#include <string>
#include <algorithm>
#include <vector>
#include <stdexcept>
#include <iostream>

class GAUDI_API GaudiHandleInfo {
protected:
  GaudiHandleInfo( std::string myComponentType, std::string myParentName )
    : m_componentType(std::move(myComponentType)), m_parentName(std::move(myParentName))
  {}
public:
  virtual ~GaudiHandleInfo() = default;
  //
  // Public member functions
  //
  const std::string& componentType() const {
     return m_componentType;
  }

  const std::string& propertyName() const {
     return m_propertyName;
  }

  void setPropertyName( std::string propName ) {
    m_propertyName = std::move(propName);
  }

  const std::string& parentName() const {
    return m_parentName;
  }

  virtual std::string pythonPropertyClassName() const = 0;

  virtual std::string pythonRepr() const = 0;

protected:

    void setComponentType(const std::string& componentType) {
        m_componentType = componentType;
    }

    void setParentName(const std::string& parent) {
        m_parentName = parent;
    }

private:
  //
  // Data members
  //
  std::string m_componentType; // e.g.: "PublicTool","PrivateTool","Service"
  std::string m_propertyName;  // name as used in declareProperty(name,gaudiHandle)
  std::string m_parentName;    // name of the parent having this handle as a member
};


class GAUDI_API GaudiHandleBase : public GaudiHandleInfo {
  //
  // Ctors etc
  //
protected:
  GaudiHandleBase( std::string myTypeAndName, std::string myComponentType,
                   std::string myParentName )
    : GaudiHandleInfo(std::move(myComponentType),std::move(myParentName))
  {
    setTypeAndName(std::move(myTypeAndName));
  }
public:
  //
  // Public member functions
  //
  std::string typeAndName() const {
     return m_typeAndName;
  }

  std::string type() const;

  std::string name() const;

  bool empty() const {
    return m_typeAndName.empty();
  }

  void setTypeAndName( std::string myTypeAndName );

  void setName( const std::string& myName );

  std::string pythonPropertyClassName() const;

  std::string messageName() const;

  virtual std::string pythonRepr() const;

private:
  //
  // Data member
  //
  std::string m_typeAndName;   // the full type and name: "type/name"
};


template< class T >
class GAUDI_API GaudiHandle: public GaudiHandleBase {
  //
  // Constructors etc.
  //
protected:
  GaudiHandle( std::string myTypeAndName, std::string myComponentType,
               std::string myParentName )
    : GaudiHandleBase(std::move(myTypeAndName), std::move(myComponentType), std::move(myParentName))
  {}

public:
  GaudiHandle( const GaudiHandle& other )
    : GaudiHandleBase( other ) {
    m_pObject = other.m_pObject;
    if ( m_pObject ) m_pObject->addRef();
  }

  GaudiHandle& operator=( const GaudiHandle& other ) {
    GaudiHandleBase::operator=( other );
    // release any current tool
    release().ignore();
    m_pObject = other.m_pObject;
    // update ref-counting
    if ( m_pObject ) m_pObject->addRef();
    return *this;
  }

  ~GaudiHandle(){
      //release();
  }

  StatusCode retrieve() const { // not really const, because it updates m_pObject
    if ( m_pObject && release().isFailure() ) return StatusCode::FAILURE;
    if ( retrieve( m_pObject ).isFailure() ) {
      m_pObject = nullptr;
      return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
  }

  StatusCode release() const { // not really const, because it updates m_pObject
    if ( m_pObject ) {
      StatusCode sc = release( m_pObject );
      m_pObject = nullptr;
      return sc;
    }
    return StatusCode::SUCCESS;
  }

  bool isValid() const { // not really const, because it may update m_pObject
    return m_pObject || retrieve().isSuccess();
  }

  operator bool() const { // not really const, because it may update m_pObject
    return isValid();
  }

  T* get() const {
    return m_pObject;
  }

  bool isSet() const {
    return get();
  }

  T& operator*() {
    assertObject();
    return *m_pObject;
  }

  T* operator->() {
    assertObject();
    return m_pObject;
  }

  T& operator*() const { // not really const, because it may update m_pObject
    assertObject();
    return *m_pObject;
  }

  T* operator->() const { // not really const, because it may update m_pObject
    assertObject();
    return m_pObject;
  }

  std::string getDefaultType() {
    return System::typeinfoName( typeid(T) );
  }

  std::string getDefaultName() {
    std::string defName = GaudiHandleBase::type();
    if ( defName.empty() ) defName = getDefaultType();
    return defName;
  }

protected:
  virtual StatusCode retrieve( T*& ) const = 0; // not really const, because it updates m_pObject

  virtual StatusCode release( T* comp ) const { // not really const, because it updates m_pObject
    comp->release();
    return StatusCode::SUCCESS;
  }

private:
  void setDefaultTypeAndName() {
    const std::string& myType = getDefaultType();
    GaudiHandleBase::setTypeAndName(myType+'/'+myType);
  }

  void setDefaultType() {
    GaudiHandleBase::setTypeAndName( getDefaultType() );
  }

  void assertObject() const { // not really const, because it may update m_pObject
    if ( !isValid() ) {
      throw GaudiException("Failed to retrieve " + componentType() + ": " + typeAndName(),
               componentType() + " retrieve", StatusCode::FAILURE);
    }
  }
  //
  // Data members
  //
  mutable T* m_pObject = nullptr;
};


class GAUDI_API GaudiHandleArrayBase: public GaudiHandleInfo {
protected:
  GaudiHandleArrayBase( std::string myComponentType, std::string myParentName )
    : GaudiHandleInfo(std::move(myComponentType),std::move(myParentName))
  {}
public:
  typedef std::vector< GaudiHandleBase* > BaseHandleArray;
  typedef std::vector< const GaudiHandleBase* > ConstBaseHandleArray;

  bool setTypesAndNames( const std::vector< std::string >& myTypesAndNamesList );

  const std::vector< std::string > typesAndNames() const;

  const std::vector< std::string > types() const;

  const std::vector< std::string > names() const;

  const std::vector< std::string > getBaseInfos( std::string (GaudiHandleBase::*pMemFunc)() const ) const;

  std::string pythonPropertyClassName() const override;

  std::string pythonRepr() const override;

  virtual bool push_back( const std::string& myHandleTypeAndName ) = 0;

  virtual void clear() = 0;

  virtual bool empty() const = 0;

  virtual ConstBaseHandleArray getBaseArray() const = 0;

  virtual BaseHandleArray getBaseArray() = 0;

  virtual bool retrieved() const = 0;

};


template <class T>
class GAUDI_API GaudiHandleArray: public GaudiHandleArrayBase {
public:
  //
  // public nested types
  //
  typedef std::vector< T > HandleVector;
  typedef typename HandleVector::value_type value_type;
  typedef typename HandleVector::size_type size_type;
  typedef typename HandleVector::reference reference;
  typedef typename HandleVector::const_reference const_reference;
  typedef typename HandleVector::iterator iterator;
  typedef typename HandleVector::const_iterator const_iterator;
  typedef typename HandleVector::reverse_iterator reverse_iterator;
  typedef typename HandleVector::const_reverse_iterator const_reverse_iterator;

protected:
  //
  // Constructors
  //
  GaudiHandleArray( const std::vector< std::string >& myTypesAndNamesList,
                    std::string myComponentType, std::string myParentName  )
    : GaudiHandleArrayBase(std::move(myComponentType),std::move(myParentName))
  {
    setTypesAndNames( myTypesAndNamesList );
  }

  GaudiHandleArray( const std::string& myComponentType, const std::string& myParentName  )
    : GaudiHandleArrayBase(myComponentType,myParentName)
  {}

public:
  virtual ~GaudiHandleArray() = default;

  GaudiHandleArray& operator=( const std::vector< std::string >& myTypesAndNamesList ) {
    setTypesAndNames( myTypesAndNamesList );
    return *this;
  }

  GaudiHandleArrayBase::BaseHandleArray getBaseArray() override {
    GaudiHandleArrayBase::BaseHandleArray baseArray;
    iterator it = begin(), itEnd = end();
    for (  ; it != itEnd; ++it ) baseArray.push_back( &*it );
    return baseArray;
  }

  GaudiHandleArrayBase::ConstBaseHandleArray getBaseArray() const override {
    GaudiHandleArrayBase::ConstBaseHandleArray baseArray;
    const_iterator it = begin(), itEnd = end();
    for (  ; it != itEnd; ++it ) baseArray.push_back( &*it );
    return baseArray;
  }

  //
  // Simulate (part of) an std::vector
  //
  iterator begin() {
    return m_handleArray.begin();
  }

  iterator end() {
    return m_handleArray.end();
  }

  const_iterator begin() const {
    return m_handleArray.begin();
  }

  const_iterator end() const {
    return m_handleArray.end();
  }

  const_iterator rbegin() const {
    return m_handleArray.rbegin();
  }

  const_iterator rend() const {
    return m_handleArray.rend();
  }

  size_type size() const {
    return m_handleArray.size();
  }

  void clear() override {
    m_handleArray.clear();
  }

  bool empty() const override {
    return m_handleArray.empty();
  }

  T& operator[]( int index ) {
    return m_handleArray[index];
  }

  const T& operator[]( int index ) const {
    return m_handleArray[index];
  }

  T* operator[]( const std::string& name ) {
    auto it = std::find_if(begin(),end(),[&](const_reference r) {
            return r.name() == name;
            } );
    return it != end() ? &*it : nullptr;
  }

  const T* operator[]( const std::string& name ) const {
    auto it = std::find_if(begin(),end(),[&](const_reference r) {
            return r.name() == name;
            } );
    return it != end() ? &*it : nullptr;
  }

  using GaudiHandleArrayBase::push_back; // avoid compiler warning
  virtual bool push_back( const T& myHandle ) {
    m_handleArray.push_back( myHandle );
    return true;
  }

  StatusCode retrieve() {
    for (auto& i : *this) { 
      // stop at first failure
      if ( i.retrieve().isFailure() ) return StatusCode::FAILURE;
    }
    m_retrieved = true;
    return StatusCode::SUCCESS;
  }

  StatusCode release() {
    StatusCode sc = StatusCode::SUCCESS;
    for (auto& i : *this ) { 
      // continue trying to release other tools even if we fail...
      if ( i.release().isFailure() ) sc = StatusCode::FAILURE;
    }
    return sc;
  }

  bool retrieved() const { return m_retrieved; }

private:
  //
  // Private data members
  //
  HandleVector m_handleArray;
  bool m_retrieved { false };
};

// Easy printing out of Handles and HandleArrays
// It prints <propertyName> = <HandleType>( <HandleType(s)AndName(s)> )
std::ostream& operator<<( std::ostream& os, const GaudiHandleInfo& handle );

#endif // ! GAUDIKERNEL_GAUDIHANDLE_H