Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbEventStore/BdbAbsCollectionT.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbAbsCollectionT.cc,v 1.5 2002/06/18 05:34:52 becla Exp $
//
// Description:
//      Class BdbAbsCollectionT interface (.cc) file. This file declares the 
//      abstract templated collection class.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      David R. Quarrie        Original Author (source in BdbAbsCollection)
//      Jacek Becla             Modified to break dependency between Event Store
//                              and BdbEvent
//
// Copyright Information:
//      Copyright (C) 2002      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------

extern "C" {
#include <assert.h>
}

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbEventStore/BdbEventStoreErrors.hh"
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbTrees/BdbGenericHdr.hh"
#include "BdbTrees/BdbTreeNode.hh"
#include "BdbTrees/BdbMetaData.hh"


//              ----------------------------------------
//              -- Public Function Member Definitions --
//              ----------------------------------------

//------------------
// Constructor(s) --
//------------------

template < class T > 
BdbAbsCollectionT<T>::BdbAbsCollectionT( )
: BdbAbsWrapper ( ),
  _descrOverride( 0 )
{
}

template < class T > 
BdbAbsCollectionT<T>::BdbAbsCollectionT( const BdbAbsCollectionT<T>& theOther )
: BdbAbsWrapper( ),
  _descrOverride( 0 )
{
    BdbHandle(BdbCollectionP) self = theOther.persistent( );
    setPersistent   ( self );
    setDescrOverride( theOther.descrOverride( ) );
}

//--------------
// Destructor --
//--------------

template < class T > 
BdbAbsCollectionT<T>::~BdbAbsCollectionT( )
{
   delete _descrOverride;
}

//-------------
// Selectors --
//-------------
    
template < class T > 
const char*
BdbAbsCollectionT<T>::name( ) const
{
    return persistent( )->name( );
}

template < class T > 
const char*
BdbAbsCollectionT<T>::pathName( ) const
{
    return persistent( )->pathName( );
}

template < class T > 
d_ULong
BdbAbsCollectionT<T>::collections( ) const
{
    return persistent( )->collections( );
}

template < class T >
d_ULong
BdbAbsCollectionT<T>::size( ) const
{
    return persistent( )->size( );
}

template < class T >
d_ULong
BdbAbsCollectionT<T>::ownedSize( ) const
{
    return persistent( )->ownedSize( );
}

//--------------
// Operations --
//--------------
    
template < class T > 
BdbStatus
BdbAbsCollectionT<T>::upgradeName( )
{
    return persistent( )->upgradeName( );
}

template < class T > 
BdbStatus 
BdbAbsCollectionT<T>::add( T& anItem ) 
{
    BdbEventStore* theEvs = BdbEventStore::instance( );
    BdbHandle(BdbCollectionP) self = persistent( );
    BdbHandle(BdbCollectionP) comp = component( );
    BdbStatus result;

    // Lock the collection for sole access. Note that we 
    // need to lock a component collection rather than the
    // collection itself if the concrete representation is
    // as a TreeCollection. Hence the use of the component( )
    // rather than persistent( ).
    result = theEvs->updateAndWait( comp, 
        BdbDomain::DomainNames[BdbDomain::Events] );
    if ( BdbcSuccess == result ) {
        BdbRefAny aRef = anItem.getPersistent();
        BdbHandleAny aH = aRef;
        result = self->add( aH );
    } else {
        BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                   "BdbAbsCollectionT<T>::add", name( ) ); 
    }
    if ( (anItem.getPersistent())->ooIsKindOf( ooTypeN( BdbGenericHdr ) ) ) {
        BdbRef(BdbGenericHdr) theHdrRef = (BdbRef(BdbGenericHdr)&) anItem.getPersistent();
        BdbHandle(BdbGenericHdr) theHdr = theHdrRef;
        BdbHandleAny oldOwner;
        result = theHdr->owner( oldOwner );
        if ( BdbIsNull( oldOwner ) ) {
            result = theEvs->updateAndWait( theHdr, 
                BdbDomain::DomainNames[BdbDomain::Events] );
            if ( BdbcSuccess == result ) {
                theHdr->setOwner( self );
            } else {
                BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                           "BdbAbsCollectionT<T>::add", name( ) ); 
            }
        }
    }
    return result;
}

template < class T > 
BdbStatus 
BdbAbsCollectionT<T>::clear( ) 
{
    BdbEventStore* theEvs = BdbEventStore::instance( );
    BdbHandle(BdbCollectionP) self = persistent( );
    BdbStatus result;

    // Lock the collection for sole access. 
    result = theEvs->updateAndWait( self, 
        BdbDomain::DomainNames[BdbDomain::Events] );
    if ( BdbcSuccess == result ) {
        result = self->clear( );
    } else {
        BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                   "BdbAbsCollectionT<T>::clear", name( ) ); 
    }
    return result;
}

template < class T > 
d_Boolean 
BdbAbsCollectionT<T>::contains( T& anItem ) const
{
    BdbRefAny aRef = anItem.getPersistent();
    BdbHandleAny aH = aRef;
    return persistent( )->contains( aH );
}

template < class T > 
d_Boolean 
BdbAbsCollectionT<T>::containsCollection( BdbAbsCollectionT<T>& theOther,
                                         d_Boolean descend ) const
{
    BdbHandle(BdbCollectionP) theObj = theOther.persistent( );
    return persistent( )->containsCollection( theObj, descend );
}

template < class T > 
BdbStatus
BdbAbsCollectionT<T>::item( T& anItem, d_ULong index ) const
{
    BdbHandle(HepExplorableDescr) theDesc;
    BdbRefAny aRef = anItem.getPersistent();
    BdbHandleAny aH = aRef;
    BdbStatus result = persistent( )->item( aH , 
                                            theDesc, index );
    BdbAbsCollectionT<T>* self = (BdbAbsCollectionT<T>*) this;
    self->setDescrOverride( theDesc );
    return result;
}

template < class T > 
BdbStatus 
BdbAbsCollectionT<T>::remove( T& anItem ) 
{
    BdbEventStore* theEvs = BdbEventStore::instance( );
    BdbHandle(BdbCollectionP) self = persistent( );
    BdbStatus result;

    // Lock the collection for sole access. 
    result = theEvs->updateAndWait( self, 
        BdbDomain::DomainNames[BdbDomain::Events] );
    if ( BdbcSuccess == result ) {
        BdbRefAny aRef = anItem.getPersistent();
        BdbHandleAny aH = aRef;
        result = self->remove( aH );
    } else {
        BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                   "BdbAbsCollectionT<T>::remove", name( ) ); 
    }
    return result;
}

template < class T > 
d_Boolean 
BdbAbsCollectionT<T>::isCompatible( BdbAbsCollectionT<T>& theOther ) const
{
    d_Boolean result = d_True;
    BdbHandle(BdbCollectionP) theOtherP = theOther.persistent( );
    if ( ! isNull( ) && ! theOther.isNull( ) ) {
        result = persistent( )->isCompatible( theOtherP );
    }
    return result;
}

template < class T > 
BdbHandle(BdbCollectionP) 
BdbAbsCollectionT<T>::persistent( ) const
{
    assert( ! BdbIsNull( object( ) ) );

    // gg did this on 14/10/98 for HP/aCC.
    BdbHandleAny objectGG = object( );
    BdbHandle(BdbCollectionP) objectGH;
    objectGH = (BdbHandle(BdbCollectionP)&) objectGG;
    //    return (BdbHandle(BdbCollectionP)&) object( ) ;
    return objectGH;

}

template < class T >
void
BdbAbsCollectionT<T>::setPersistent( BdbHandle(BdbCollectionP)& aCollection )
{
    setObject( aCollection );
}

template < class T >
BdbStatus
BdbAbsCollectionT<T>::createDescription( const char* const theName )
{
    BdbHandle(HepExplorableDescr) nullDesc( 0 );
    BdbStatus result = persistent( )->createDescription( theName );
    setDescrOverride( nullDesc );
    return result;
}

template < class T >
d_Boolean
BdbAbsCollectionT<T>::hasDescription( ) const
{
    return persistent( )->hasDescription( );
}

template < class T >
BdbStatus
BdbAbsCollectionT<T>::setDescription( BdbHandle(HepExplorableDescr)& theDesc )
{
    BdbHandle(HepExplorableDescr) nullDesc( 0 );
    BdbStatus result = persistent( )->setDescription( theDesc );
    setDescrOverride( nullDesc );
    return result;
}

template < class T >
BdbStatus
BdbAbsCollectionT<T>::description( BdbHandle(HepExplorableDescr)& theDesc ) const
{
    BdbStatus result = BdbcSuccess;
    BdbHandle(HepExplorableDescr) theUseDesc = descrOverride( );
    if ( BdbIsNull(theUseDesc) ) {
        result = persistent( )->description( theUseDesc );
    }
    theDesc = theUseDesc;
    return result;
}

template < class T > 
BdbHandle(HepExplorableDescr)
BdbAbsCollectionT<T>::descrOverride( ) const
{
    if( 0 == _descrOverride ) {
        return 0 ;
    }
    return *_descrOverride;
}

template < class T > 
void 
BdbAbsCollectionT<T>::setDescrOverride( const BdbHandle(HepExplorableDescr)& theOverride )
{
    delete _descrOverride ;
    _descrOverride = new BdbHandle(HepExplorableDescr)( theOverride ) ;
}

template < class T >
void 
BdbAbsCollectionT<T>::useTag( BdbHandle(BdbEventTag)& theTag )
{
    persistent( )->useTag( theTag );
}

template < class T >
void 
BdbAbsCollectionT<T>::useAndResizeTag( BdbHandle(BdbEventTag)& theTag )
{
    BdbHandle(BdbEventTag) theTagH = theTag;
    persistent( )->useAndResizeTag( theTagH );
}

template < class T >
void 
BdbAbsCollectionT<T>::fillTag( BdbHandle(BdbEventTag)& theTag, AbsEventTag* theTrans )
{
    BdbAbsCollectionT<T>* override = descrOverride( );
    override->persistent( )->fillTag( theTag, theTrans );
}

template < class T >
BdbStatus 
BdbAbsCollectionT<T>::treeNode( BdbTreeNode& theNode ) const
{
    BdbHandle(BdbTreeNodeP) theNodeP;
    BdbStatus result = persistent( )->treeNode( theNodeP );
    if ( BdbcSuccess == result ) {
        theNode.setPersistent( theNodeP );
    }
    return result;
}

template < class T >
BdbStatus 
BdbAbsCollectionT<T>::fetchMetaData( BdbMetaData& theData )
{
    BdbHandle(BdbMetaDataP) theDataP;
    BdbEventStore* theEvs = BdbEventStore::instance( );
    BdbHandle(BdbCollectionP) self = persistent( );
    BdbStatus result;

    // Lock the collection for sole access. 
    result = theEvs->updateAndWait( self, 
        BdbDomain::DomainNames[BdbDomain::Events] );
    if ( BdbcSuccess == result ) {
        result = self->fetchMetaData( theDataP );
        theData.setPersistent( theDataP );
    } else {
        BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                   "BdbAbsCollectionT<T>::fetchMetaData", name( ) ); 
    }
    return result;
}

template < class T >
BdbStatus 
BdbAbsCollectionT<T>::metaData( BdbMetaData& theData ) const
{
    BdbHandle(BdbMetaDataP) theDataP;
    BdbStatus result = persistent( )->metaData( theDataP );
    theData.setPersistent( theDataP );
    return result;
}

template < class T >
d_Boolean
BdbAbsCollectionT<T>::isDeleted( ) const
{
    d_Boolean result = persistent( )->isDeleted( );
    return result;
}

template < class T >
void
BdbAbsCollectionT<T>::setDeleted( )
{
    persistent( )->setDeleted( );
}

template < class T >
void
BdbAbsCollectionT<T>::invalidateCachedHandle() const
{
   BdbAbsWrapper::invalidateCachedHandle();
}

//              -------------------------------------------
//              -- Protected Function Member Definitions --
//              -------------------------------------------

//----------------
// Constructors --
//----------------

template < class T > 
BdbAbsCollectionT<T>::BdbAbsCollectionT( BdbHandle(BdbCollectionP)& theColl )
   : BdbAbsWrapper( theColl ) ,
     _descrOverride(0)
{
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002