---

CdbCPtr.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbCPtr.cc,v 1.6 2004/08/06 05:54:14 bartoldu Exp $

/// The implementation of the parametrized counted pointer class CdbCPtr.
/**
  * @see CdbCPtr
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbCPtr.hh"

#include <assert.h>
#include <string.h>
#include <iostream>

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>::CdbCPtr( P* ptr ) :
    _myCounter(0)
{
    if( ptr ) _myCounter = new Counter( ptr );
}

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>::~CdbCPtr( )
{
    release( );
}

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>::CdbCPtr( const CdbCPtr<P,CLOSE_POLICY>& thePtr )
{
    acquire( thePtr._myCounter );
}

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>&
CdbCPtr<P,CLOSE_POLICY>::operator=( const CdbCPtr<P,CLOSE_POLICY>& thePtr )
{
    if( this != &thePtr ) {
        release( );
        acquire( thePtr._myCounter );
    }
    return *this;
}

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>&
CdbCPtr<P,CLOSE_POLICY>::operator=( P* ptr )
{
    release( );
    if( ptr ) _myCounter = new Counter( ptr );
    return *this;
}

template < class P, class CLOSE_POLICY >
P&
CdbCPtr<P,CLOSE_POLICY>::operator*( ) const
{
    return *_myCounter->_ptr;
}

template < class P, class CLOSE_POLICY >
P*
CdbCPtr<P,CLOSE_POLICY>::operator->( ) const
{
    return _myCounter->_ptr;
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::operator==( const CdbCPtr& thePtr ) const
{
    return (        _myCounter ?        _myCounter->_ptr : 0 ) ==
           ( thePtr._myCounter ? thePtr._myCounter->_ptr : 0 );
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::operator!=( const CdbCPtr& thePtr ) const
{
    return ! operator==( thePtr );
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::operator==( const P* ptr ) const
{
    return ( _myCounter ? _myCounter->_ptr : 0 ) == ptr;
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::operator!=( const P* ptr ) const
{
    return ! operator==( ptr );
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::isNull( ) const
{
    return operator==((const P*) 0 );
}

template < class P, class CLOSE_POLICY >
P*
CdbCPtr<P,CLOSE_POLICY>::get( ) const
{
    return _myCounter ? _myCounter->_ptr : 0;
}

template < class P, class CLOSE_POLICY >
bool
CdbCPtr<P,CLOSE_POLICY>::unique( ) const
{
    return _myCounter ? 1 == _myCounter->_count : true;
}

template < class P, class CLOSE_POLICY >
void
CdbCPtr<P,CLOSE_POLICY>::acquire( CdbCPtr<P,CLOSE_POLICY>::Counter* theCounter )
{
    _myCounter = theCounter;
    if( 0 != _myCounter ) ++(_myCounter->_count);
}

template < class P, class CLOSE_POLICY >
void
CdbCPtr<P,CLOSE_POLICY>::release( )
{
    if( _myCounter ) {

        --(_myCounter->_count);
        if( 0 == _myCounter->_count ) {

          // Make sure the pointed object is "closed" whatever it means
          // for the specific CLOSE_POLICY cnd P classes.

            CLOSE_POLICY::close( _myCounter->_ptr );

            deleteObject( _myCounter->_ptr );
            delete _myCounter;
        }
        _myCounter = 0;
    }
}

template < class P, class CLOSE_POLICY >
CdbCPtr<P,CLOSE_POLICY>::Counter::Counter( P* ptr, unsigned count ) :
    _ptr(ptr),
    _count(count)
{
}

/////////////////
// End Of File //
/////////////////

---