GaudiHandle.cpp

Go to the documentation of this file.

#include "GaudiKernel/GaudiHandle.h"
#include <iostream>
#include <string>

//
// GaudiHandleBase implementation
//

void GaudiHandleBase::setTypeAndName( std::string myTypeAndName ) { m_typeAndName = std::move( myTypeAndName ); }

std::string GaudiHandleBase::type() const {
  std::string::size_type slash = m_typeAndName.find( '/' );
  if ( slash != std::string::npos ) {
    // return only part before /
    return m_typeAndName.substr( 0, slash );
  } else {
    // return full string
    return m_typeAndName;
  }
}

std::string GaudiHandleBase::name() const {
  auto slash = m_typeAndName.find( '/' );
  if ( slash == std::string::npos ) {
    // only type is given, or string is empty.
    // return default name (=type or empty, in this case full string)
    return m_typeAndName;
  } else if ( slash != m_typeAndName.length() - 1 ) {
    // an explicit name is given, so return it
    return m_typeAndName.substr( slash + 1 );
  } else {
    // ends with /, i.e. explicit empty name.
    // Should probably never happen.
    return "";
  }
}

void GaudiHandleBase::setName( const std::string& myName ) { m_typeAndName = type() + '/' + myName; }

std::string GaudiHandleBase::pythonPropertyClassName() const { return componentType() + "Handle"; }

std::string GaudiHandleBase::messageName() const {
  std::string propName = propertyName();
  if ( propName.empty() ) { propName = pythonPropertyClassName() + "('" + m_typeAndName + "')"; }
  return parentName() + "." + propName;
}

std::string GaudiHandleBase::pythonRepr() const { return pythonPropertyClassName() + "('" + m_typeAndName + "')"; }

//
// GaudiHandleArrayBase implementation
//
bool GaudiHandleArrayBase::setTypesAndNames( const std::vector<std::string>& myTypesAndNamesList ) {
  clear();
  for ( const auto& it : myTypesAndNamesList ) {
    if ( !push_back( it ) ) return false;
  }
  return true;
}

const std::vector<std::string> GaudiHandleArrayBase::getBaseInfos( std::string ( GaudiHandleBase::*pMemFunc )()
                                                                       const ) const {
  std::vector<std::string> theList;
  for ( const auto& it : getBaseArray() ) theList.push_back( ( it->*pMemFunc )() );
  return theList;
}

const std::vector<std::string> GaudiHandleArrayBase::typesAndNames() const {
  return getBaseInfos( &GaudiHandleBase::typeAndName );
}

const std::vector<std::string> GaudiHandleArrayBase::types() const { return getBaseInfos( &GaudiHandleBase::type ); }

const std::vector<std::string> GaudiHandleArrayBase::names() const { return getBaseInfos( &GaudiHandleBase::name ); }

std::string GaudiHandleArrayBase::pythonPropertyClassName() const { return componentType() + "HandleArray"; }

std::string GaudiHandleArrayBase::pythonRepr() const {
  std::string repr    = pythonPropertyClassName() + "([";
  auto        theList = typesAndNames();
  auto        first   = theList.begin();
  auto        last    = theList.end();
  if ( first != last ) {
    repr += "'" + *first + "'";
    ++first;
  }
  for ( ; first != last; ++first ) repr += ",'" + *first + "'";
  repr += "])";
  return repr;
}

//
// Public functions
//
std::ostream& operator<<( std::ostream& os, const GaudiHandleInfo& handle ) {
  std::string msg;
  const auto& propName = handle.propertyName();
  if ( !propName.empty() ) msg += propName + " = ";
  msg += handle.pythonRepr();
  os << msg;
  return os;
}