GaudiHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_GAUDIHANDLE_H
#define GAUDIKERNEL_GAUDIHANDLE_H

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

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

namespace details {
  template <class T>
  std::remove_const_t<T>* nonConst( T* p ) {
    return const_cast<std::remove_const_t<T>*>( p );
  }
} // namespace details

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

  std::string messageName() const;

  std::string pythonRepr() const override;

  using PropertyType = GaudiHandleProperty;

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:
  template <typename CT = T, typename NCT = typename std::remove_const<T>::type>
  GaudiHandle( const GaudiHandle<NCT>& other,
               typename std::enable_if<std::is_const<CT>::value && !std::is_same<CT, NCT>::value>::type* = nullptr )
      : GaudiHandleBase( other ) {
    m_pObject = other.get();
    if ( m_pObject ) ::details::nonConst( m_pObject )->addRef();
  }

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

  template <typename CT = T, typename NCT = typename std::remove_const<T>::type>
  typename std::enable_if<std::is_const<CT>::value && !std::is_same<CT, NCT>::value, GaudiHandle&>::type
  operator=( const GaudiHandle<NCT>& other ) {
    GaudiHandleBase::operator=( other );
    // release any current tool
    release().ignore();
    m_pObject = other.get();
    // update ref-counting
    if ( m_pObject ) ::details::nonConst( m_pObject )->addRef();
    return *this;
  }

  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 ) ::details::nonConst( m_pObject )->addRef();
    return *this;
  }

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

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

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

  typename std::add_const<T>::type* get() const { return m_pObject; }

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

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

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

  typename std::add_const<T>::type& operator*() const {
    // not really const, because it may update m_pObject
    assertObject();
    return *m_pObject;
  }

  typename std::add_const<T>::type* 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() {
    const auto defName = GaudiHandleBase::type();
    return ( defName.empty() ? getDefaultType() : 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
    // const cast to support T being a const type
    ::details::nonConst( 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 ( UNLIKELY( !isValid() ) ) {
      throw GaudiException( "Failed to retrieve " + componentType() + ": " + typeAndName(),
                            componentType() + " retrieve", StatusCode::FAILURE );
    }
  }

private:
  //
  // 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:
  using PropertyType = GaudiHandleArrayProperty;
  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() {
    StatusCode sc = StatusCode::SUCCESS;
    for ( auto& i : *this ) {
      // stop at first failure
      if ( i.retrieve().isFailure() ) {
        sc = StatusCode::FAILURE;
        break;
      }
    }
    if ( sc ) { m_retrieved = true; }
    return sc;
  }

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

  virtual bool retrieved() const override { 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