DataObjectHandleBase Class Reference

DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h. More...

#include <GaudiKernel/DataObjectHandleBase.h>

Inheritance diagram for DataObjectHandleBase:

Collaboration diagram for DataObjectHandleBase:

Public Types
using	PropertyType = DataObjectHandleProperty
Public Types inherited from Gaudi::DataHandle
enum	Mode { Reader = 1 << 2, Writer = 1 << 4, Updater = Reader | Writer }

Public Member Functions
	DataObjectHandleBase (const DataObjID &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
	DataObjectHandleBase (const std::string &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
virtual	~DataObjectHandleBase ()
	DataObjectHandleBase (const DataObjectHandleBase &)=delete
	DataObjectHandleBase (DataObjectHandleBase &&)
DataObjectHandleBase &	operator= (const DataObjectHandleBase &)
template<class OWNER , class K , typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
	DataObjectHandleBase (OWNER *owner, Gaudi::DataHandle::Mode m, std::string name, const K &key={}, std::string doc="")
	Autodeclaring constructor with property name, mode, key and documentation. More...
std::string	toString () const
std::string	pythonRepr () const override
void	fromString (const std::string &s)
bool	isOptional () const
	Check if the data object declared is optional for the algorithm. More...
void	setOptional (bool optional=true)
bool	initialized () const
bool	wasRead () const
bool	wasWritten () const
bool	isValid () const
Public Member Functions inherited from Gaudi::DataHandle
	DataHandle (const DataObjID &k, Mode a=Reader, IDataHandleHolder *owner=nullptr)
	DataHandle (const DataObjID &k, const bool &isCond, Mode a=Reader, IDataHandleHolder *owner=nullptr)
virtual	~DataHandle ()=default
virtual void	setOwner (IDataHandleHolder *o)
virtual IDataHandleHolder *	owner () const
virtual Mode	mode () const
virtual void	setKey (DataObjID key) const
virtual void	updateKey (std::string key) const
virtual const std::string &	objKey () const
virtual const DataObjID &	fullKey () const
virtual void	reset (bool)
virtual bool	isCondition () const

Protected Member Functions
void	setRead (bool wasRead=true)
void	setWritten (bool wasWritten=true)
bool	init () override
DataObject *	fetch () const

Protected Attributes
SmartIF< IDataProviderSvc >	m_EDS
SmartIF< IMessageSvc >	m_MS
bool	m_init = false
bool	m_optional = false
bool	m_wasRead = false
bool	m_wasWritten = false
bool	m_searchDone = false
	Whether the search part of the fetch method (so dealing with alt names was already executed or not. More...
std::mutex	m_searchMutex
	A Mutex protecting the calls to the search part of the fetch method, so that we are sure that we only call it once. More...
Protected Attributes inherited from Gaudi::DataHandle
DataObjID	m_key = {"NONE"}
	The key of the object behind this DataHandle Although it may look strange to have it mutable, this can actually change in case the object had alternative names, and it should not be visible to the end user, for which the Handle is still the same. More...
IDataHandleHolder *	m_owner = nullptr

Static Protected Attributes
static const std::string	default_type = "unknown_t"

Friends
std::ostream &	operator<< (std::ostream &str, const DataObjectHandleBase &d)

Detailed Description

DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.

Base class for handles to Data Objects in the Event Store, to simplify access via Properties.

Author

Charles Leggett

Date

2015-09-01

Definition at line 36 of file DataObjectHandleBase.h.

Member Typedef Documentation

PropertyType

using DataObjectHandleBase::PropertyType = DataObjectHandleProperty

Definition at line 63 of file DataObjectHandleBase.h.

Constructor & Destructor Documentation

DataObjectHandleBase() [1/5]

DataObjectHandleBase::DataObjectHandleBase	(	const DataObjID &	k,
		Gaudi::DataHandle::Mode	a,
		IDataHandleHolder *	owner
	)

Definition at line 57 of file DataObjectHandleBase.cpp.

    : Gaudi::DataHandle( k, a, owner ) {
  m_owner->declare( *this );
}

DataObjectHandleBase() [2/5]

DataObjectHandleBase::DataObjectHandleBase	(	const std::string &	k,
		Gaudi::DataHandle::Mode	a,
		IDataHandleHolder *	owner
	)

Definition at line 64 of file DataObjectHandleBase.cpp.

    : DataObjectHandleBase( DataObjID( k ), a, owner ) {}

~DataObjectHandleBase()

DataObjectHandleBase::~DataObjectHandleBase ( )

virtual

Definition at line 68 of file DataObjectHandleBase.cpp.

{ owner()->renounce( *this ); }

DataObjectHandleBase() [3/5]

DataObjectHandleBase::DataObjectHandleBase ( const DataObjectHandleBase &  )

delete

DataObjectHandleBase() [4/5]

DataObjectHandleBase::DataObjectHandleBase

(

DataObjectHandleBase &&

other

)

Definition at line 28 of file DataObjectHandleBase.cpp.

    : Gaudi::DataHandle( other )
    , m_EDS( std::move( other.m_EDS ) )
    , m_MS( std::move( other.m_MS ) )
    , m_init( other.m_init )
    , m_optional( other.m_optional )
    , m_wasRead( other.m_wasRead )
    , m_wasWritten( other.m_wasWritten )
    , m_searchDone( other.m_searchDone ) {
  m_owner->declare( *this );
}

DataObjectHandleBase() [5/5]

template<class OWNER , class K , typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

DataObjectHandleBase::DataObjectHandleBase ( OWNER *  owner, Gaudi::DataHandle::Mode  m, std::string  name, const K &  key = {}, std::string  doc = ""  )

inline

Autodeclaring constructor with property name, mode, key and documentation.

Note

the use std::enable_if is required to avoid ambiguities

Definition at line 50 of file DataObjectHandleBase.h.

                                                                                                   {},
                               std::string doc = "" )
      : DataObjectHandleBase( key, m, owner ) {
    auto p = owner->declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }

Member Function Documentation

fetch()

DataObject * DataObjectHandleBase::fetch ( ) const

protected

Definition at line 71 of file DataObjectHandleBase.cpp.

                                              {
  DataObject* p = nullptr;
  if ( LIKELY( m_searchDone ) ) { // fast path: searchDone, objKey is in its final state
    m_EDS->retrieveObject( objKey(), p ).ignore();
    return p;
  }

  // slow path -- move into seperate function to improve code generation?

  // convenience towards users -- remind them to register
  // but as m_MS is not yet set, we cannot use a MsgStream...
  if ( !m_init ) {
    std::cerr << ( owner() ? owner()->name() : "<UNKNOWN>:" ) << "DataObjectHandle: uninitialized data handle"
              << std::endl;
  }

  // as m_searchDone is not true yet, objKey may change... so in this
  // branch we _first_ grab the mutex, to avoid objKey changing while we use it

  // take a lock to be sure we only execute this once at a time
  auto guard = std::scoped_lock{m_searchMutex};

  StatusCode sc = m_EDS->retrieveObject( objKey(), p );
  if ( m_searchDone ) { // another thread has done the search while we were blocked
                        // on the mutex. As a result, nothing left to do but return...
    sc.ignore();
    return p;
  }

  if ( !sc.isSuccess() ) {
    auto tokens = boost::tokenizer<boost::char_separator<char>>{objKey(), boost::char_separator<char>{":"}};
    // let's try our alternatives (if any)
    auto alt = std::find_if( tokens.begin(), tokens.end(),
                             [&]( const std::string& n ) { return m_EDS->retrieveObject( n, p ).isSuccess(); } );
    if ( alt != tokens.end() ) {
      MsgStream log( m_MS, owner()->name() + ":DataObjectHandle" );
      log << MSG::DEBUG << ": could not find \"" << objKey() << "\" -- using alternative source: \"" << *alt
          << "\" instead" << endmsg;
      // found something -- set it as default; this is not atomic, but
      // at least in `fetch` there is no use of `objKey` that races with
      // this assignment... (but there may be others!)
      setKey( *alt );
    }
  }
  m_searchDone = true;
  return p;
}

fromString()

void DataObjectHandleBase::fromString

(

const std::string &

s

)

Definition at line 141 of file DataObjectHandleBase.cpp.

{ Gaudi::Parsers::parse( *this, s ).ignore(); }

init()

bool DataObjectHandleBase::init ( )

overrideprotectedvirtual

Reimplemented from Gaudi::DataHandle.

Definition at line 145 of file DataObjectHandleBase.cpp.

                                {

  assert( !m_init );

  if ( !owner() ) return false;

  setRead( false );
  setWritten( false );

  Gaudi::Algorithm* algorithm = dynamic_cast<Gaudi::Algorithm*>( owner() );
  if ( algorithm ) {
    // Fetch the event Data Service from the algorithm
    m_EDS = algorithm->evtSvc();
    m_MS  = algorithm->msgSvc();
  } else {
    AlgTool* tool = dynamic_cast<AlgTool*>( owner() );
    if ( tool ) {
      m_EDS = tool->evtSvc();
      m_MS  = tool->msgSvc();
    } else {
      throw GaudiException( "owner is neither AlgTool nor Gaudi::Algorithm", "Invalid Cast", StatusCode::FAILURE );
    }
  }
  m_init = true;
  return true;
}

initialized()

bool DataObjectHandleBase::initialized ( ) const

inline

Definition at line 69 of file DataObjectHandleBase.h.

{ return m_init; }

isOptional()

bool DataObjectHandleBase::isOptional ( ) const

inline

Check if the data object declared is optional for the algorithm.

Definition at line 66 of file DataObjectHandleBase.h.

{ return m_optional; }

isValid()

bool DataObjectHandleBase::isValid

(

)

const

Definition at line 174 of file DataObjectHandleBase.cpp.

{ return fullKey() != INVALID_DATAOBJID; }

operator=()

DataObjectHandleBase & DataObjectHandleBase::operator=

(

const DataObjectHandleBase &

other

)

Definition at line 41 of file DataObjectHandleBase.cpp.

                                                                                         {
  // avoid modification of searchDone in other while we are copying
  auto guard = std::scoped_lock{other.m_searchMutex};
  // FIXME: operator= should not change our owner, only our 'value'
  Gaudi::DataHandle::operator=( other );
  m_EDS                      = other.m_EDS;
  m_MS                       = other.m_MS;
  m_init                     = other.m_init;
  m_optional                 = other.m_optional;
  m_wasRead                  = other.m_wasRead;
  m_wasWritten               = other.m_wasWritten;
  m_searchDone               = other.m_searchDone;
  return *this;
}

pythonRepr()

std::string DataObjectHandleBase::pythonRepr ( ) const

overridevirtual

Reimplemented from Gaudi::DataHandle.

Reimplemented in DataObjectHandle<::details::Payload_t< T > >, and DataObjectHandle< DataObject >.

Definition at line 124 of file DataObjectHandleBase.cpp.

                                                 {
  std::string m;
  switch ( mode() ) {
  case Gaudi::DataHandle::Mode::Reader:
    m = "R";
    break;
  case Gaudi::DataHandle::Mode::Writer:
    m = "W";
    break;
  default:
    m = "UNKNOWN";
    break;
  }
  return "DataObjectHandleBase('" + toString() + "', '" + m + "', '" + default_type + "')";
}

setOptional()

void DataObjectHandleBase::setOptional ( bool  optional = true )

inline

Definition at line 67 of file DataObjectHandleBase.h.

{ m_optional = optional; }

setRead()

void DataObjectHandleBase::setRead ( bool  wasRead = true )

inlineprotected

Definition at line 76 of file DataObjectHandleBase.h.

{ m_wasRead = wasRead; }

setWritten()

void DataObjectHandleBase::setWritten ( bool  wasWritten = true )

inlineprotected

Definition at line 77 of file DataObjectHandleBase.h.

{ m_wasWritten = wasWritten; }

toString()

std::string DataObjectHandleBase::toString

(

)

const

Definition at line 121 of file DataObjectHandleBase.cpp.

{ return objKey(); }

wasRead()

bool DataObjectHandleBase::wasRead ( ) const

inline

Definition at line 70 of file DataObjectHandleBase.h.

{ return m_wasRead; }

wasWritten()

bool DataObjectHandleBase::wasWritten ( ) const

inline

Definition at line 71 of file DataObjectHandleBase.h.

{ return m_wasWritten; }

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  str, const DataObjectHandleBase &  d  )

friend

Definition at line 178 of file DataObjectHandleBase.cpp.

                                                                         {

  str << d.fullKey() << "  m: " << d.mode();
  if ( d.owner() ) str << "  o: " << d.owner()->name();
  str << "  opt: " << d.isOptional();
  return str;
}

Member Data Documentation

default_type

std::string const DataObjectHandleBase::default_type = "unknown_t"

staticprotected

Definition at line 105 of file DataObjectHandleBase.h.

m_EDS

SmartIF<IDataProviderSvc> DataObjectHandleBase::m_EDS

protected

Definition at line 84 of file DataObjectHandleBase.h.

m_init

bool DataObjectHandleBase::m_init = false

protected

Definition at line 87 of file DataObjectHandleBase.h.

m_MS

SmartIF<IMessageSvc> DataObjectHandleBase::m_MS

protected

Definition at line 85 of file DataObjectHandleBase.h.

m_optional

bool DataObjectHandleBase::m_optional = false

protected

Definition at line 88 of file DataObjectHandleBase.h.

m_searchDone

bool DataObjectHandleBase::m_searchDone = false

mutableprotected

Whether the search part of the fetch method (so dealing with alt names was already executed or not.

On subsequent calls (when this is true), it will be skipped.

Definition at line 97 of file DataObjectHandleBase.h.

m_searchMutex

std::mutex DataObjectHandleBase::m_searchMutex

mutableprotected

A Mutex protecting the calls to the search part of the fetch method, so that we are sure that we only call it once.

Definition at line 103 of file DataObjectHandleBase.h.

m_wasRead

bool DataObjectHandleBase::m_wasRead = false

protected

Definition at line 89 of file DataObjectHandleBase.h.

m_wasWritten

bool DataObjectHandleBase::m_wasWritten = false

protected

Definition at line 90 of file DataObjectHandleBase.h.

---

The documentation for this class was generated from the following files:

• GaudiKernel/GaudiKernel/DataObjectHandleBase.h
• GaudiKernel/src/Lib/DataObjectHandleBase.cpp