SmartDataStorePtr.h

Go to the documentation of this file.

//  ====================================================================
//  SmartDataStorePtr.h
//  --------------------------------------------------------------------
//
//  Package    : GaudiKernel ( The LHCb Offline System)
//
//  Description: Implementation of a smart pointer class to access
//               easily (and efficiently) data stores.
//
//  Author     : M.Frank
//  ====================================================================
#ifndef GAUDIKERNEL_SMARTDATASTOREPTR_H
#define GAUDIKERNEL_SMARTDATASTOREPTR_H 1

// Framework include files
#include "GaudiKernel/SmartDataObjectPtr.h"

template <class TYPE, class LOADER>
class SmartDataStorePtr : public SmartDataObjectPtr
{
public:
  SmartDataStorePtr( IDataProviderSvc* pService, IRegistry* pRegistry, const std::string& path )
      : SmartDataObjectPtr( LOADER::access(), pService, pRegistry, path ), m_pObject( 0 )
  {
  }
  SmartDataStorePtr( const SmartDataObjectPtr& copy ) : SmartDataObjectPtr( copy ), m_pObject( 0 ) {}

  virtual ~SmartDataStorePtr() {}

  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.
}
#endif // GAUDIKERNEL_SMARTDATASTOREPTR_H