SmartDataStorePtr.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/SmartDataObjectPtr.h>
 
template <class TYPE, class LOADER>
class SmartDataStorePtr : public SmartDataObjectPtr {
public:
  SmartDataStorePtr( IDataProviderSvc* pService, IRegistry* pRegistry, std::string path )
      : SmartDataObjectPtr( LOADER::access(), pService, pRegistry, std::move( path ) ), m_pObject( nullptr ) {}
  SmartDataStorePtr( const SmartDataObjectPtr& copy ) : SmartDataObjectPtr( copy ), m_pObject( nullptr ) {}
 
  virtual ~SmartDataStorePtr() = default;
 
  SmartDataStorePtr& operator=( DataObject* pObj ) {
    m_pObject = dynamic_cast<TYPE*>( pObj );
    return *this;
  }
 
  SmartDataStorePtr& operator=( const DataObject* pObj ) {
    m_pObject = dynamic_cast<TYPE*>( const_cast<DataObject*>( pObj ) );
    return *this;
  }
 
  SmartDataStorePtr& operator=( const SmartDataObjectPtr& copy ) override {
    this->m_pObject = dynamic_cast<TYPE*>( const_cast<SmartDataObjectPtr*>( &copy ) );
    return *this;
  }
 
  TYPE* ptr() { return accessTypeSafeData(); }
 
  TYPE* operator->() { return accessTypeSafeData(); }
 
  TYPE& operator*() {
    TYPE* result = accessTypeSafeData();
    return *result;
  }
 
  operator TYPE*() { return accessTypeSafeData(); }
 
  operator TYPE&() {
    TYPE* result = accessTypeSafeData();
    return *result;
  }
 
  operator int() { return 0 != accessTypeSafeData(); }
 
  bool operator!() { return 0 == accessTypeSafeData(); }
 
  TYPE* accessTypeSafeData() {
    if ( 0 == m_pObject ) { m_pObject = dynamic_cast<TYPE*>( accessData() ); }
    return m_pObject;
  }
 
protected:
  mutable TYPE* m_pObject;
};
 
template <class A, class LDA, class B, class LDB>
bool operator&&( SmartDataStorePtr<A, LDA>& object_1, SmartDataStorePtr<B, LDB>& object_2 ) {
  if ( 0 != object_1.accessTypeSafeData() ) {   // Test existence of the first object
    if ( 0 != object_2.accessTypeSafeData() ) { // Test existence of the second object
      return true;                              // Fine: Both objects exist
    }
  }
  return false; // Tough luck: One is missing.
}
 
template <class B, class LDB>
bool operator&&( bool test, SmartDataStorePtr<B, LDB>& object ) {
  if ( test ) {                               // Test existence of the first object
    if ( 0 != object.accessTypeSafeData() ) { // Test existence of the second object
      return true;                            // Fine: Both objects exist
    }
  }
  return false; // Tough luck: One is missing.
}
 
template <class B, class LDB>
bool operator&&( SmartDataStorePtr<B, LDB>& object, bool test ) {
  if ( test ) {                               // Test existence of the first object
    if ( 0 != object.accessTypeSafeData() ) { // Test existence of the second object
      return true;                            // Fine: Both objects exist
    }
  }
  return false; // Tough luck: One is missing.
}
 
template <class A, class LDA, class B, class LDB>
bool operator||( SmartDataStorePtr<A, LDA>& object_1, SmartDataStorePtr<B, LDB>& object_2 ) {
  if ( 0 != object_1.accessTypeSafeData() ) { // Test existence of the first object
    return true;
  }
  if ( 0 != object_2.accessTypeSafeData() ) { // Test existence of the second object
    return true;
  }
  return false; // Tough luck: Both are missing.
}
 
template <class B, class LDB>
bool operator||( bool test, SmartDataStorePtr<B, LDB>& object ) {
  if ( test ) { // Test existence of the first object
    return true;
  }
  if ( 0 != object.accessTypeSafeData() ) { // Test existence of the second object
    return true;                            // Fine: Both objects exist
  }
  return false; // Tough luck: One is missing.
}
 
template <class B, class LDB>
bool operator||( SmartDataStorePtr<B, LDB>& object, bool test ) {
  if ( test ) { // Test existence of the first object
    return true;
  }
  if ( 0 != object.accessTypeSafeData() ) { // Test existence of the second object
    return true;                            // Fine: Both objects exist
  }
  return false; // Tough luck: One is missing.
}