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 ) {
    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