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 <vector>
#include <stdexcept>
#include <iostream>

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

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

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

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

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

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

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 GaudiHandleBase : public GaudiHandleInfo {
  //
  // Ctors etc
  //
protected:
  GaudiHandleBase( const std::string& myTypeAndName, const std::string& myComponentType,
                   const std::string& myParentName )
    : GaudiHandleInfo(myComponentType,myParentName)
  {
    setTypeAndName(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( const std::string& myTypeAndName );

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

  const std::string messageName() const;

  virtual const std::string pythonRepr() const;

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


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

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;
  }

  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 = 0;
      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 = 0;
      return sc;
    }
    return StatusCode::SUCCESS;
  }

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

  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() ); 
  }

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

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


class GaudiHandleArrayBase : public GaudiHandleInfo {
protected:
  GaudiHandleArrayBase( const std::string& myComponentType, const std::string& myParentName )
    : GaudiHandleInfo(myComponentType,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;

  virtual const std::string pythonPropertyClassName() const;

  virtual const std::string pythonRepr() const;

  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;
};


template <class T>
class 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, 
                    const std::string& myComponentType, const std::string& myParentName  )
    : GaudiHandleArrayBase(myComponentType,myParentName)
  {
    GaudiHandleArray::setTypesAndNames( myTypesAndNamesList );
  }

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

public:
  virtual ~GaudiHandleArray() {};

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

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

  virtual GaudiHandleArrayBase::ConstBaseHandleArray getBaseArray() const {
    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(); 
  }
  
  virtual void clear() {
    m_handleArray.clear(); 
  }
  
  virtual bool empty() const {
    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 ) {
    iterator it = begin(), itEnd = end();
    for ( ; it != itEnd; ++it ) {
      if ( it->name() == name ) return &*it;
    }
    // not found
    return 0;
  }
  
  const T* operator[]( const std::string& name ) const {
    const_iterator it = begin(), itEnd = end();
    for ( ; it != itEnd; ++it ) {
      if ( it->name() == name ) return &*it;
    }
    // not found
    return 0;
  }

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

  StatusCode retrieve() {
    iterator it = begin(), itEnd = end();
    for ( ; it != itEnd; ++it ) {
      if ( it->retrieve().isFailure() ) {
        // stop at first failure
        return StatusCode::FAILURE;
      }
    }
    return StatusCode::SUCCESS;
  }

  StatusCode release() {
    StatusCode sc = StatusCode::SUCCESS;
    iterator it = begin(), itEnd = end();
    for ( ; it != itEnd; ++it ) {
      if ( it->release().isFailure() ) {
        // continue trying to release other tools
        sc = StatusCode::FAILURE;
      }
    }
    return sc;
  }
  
private:
  //
  // Private data members
  //
  HandleVector m_handleArray;
};

// 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