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

                 

---

/BdbTrees/BdbGenericHdrT.cc

Go to the documentation of this file.

#if !defined(BDBGENERICHDRT_CC)
#define BDBGENERICHDRT_CC
//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbGenericHdrT.cc,v 1.12 2002/06/10 23:29:32 becla Exp $
//
// Description:
//      Class BdbGenericHdrT
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Simon Patton            Originator
//
// Copyright Information:
//      Copyright (C) 1999      LBNL
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbTrees/BdbGenericHdrT.hh"

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

//---------------
// C++ Headers --
//---------------

//----------------
// BaBar Header --
//----------------
#include "BaBar/BaBar.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbTrees/BdbTypeAndString.hh"
#include "BdbTrees/BdbGenericHdr.hh"
#include "BdbTrees/BdbGenericMutualHdr.hh"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

//              -----------------------------------------------
//              -- Static Data & Function Member Definitions --
//              -----------------------------------------------

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

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

BdbGenericHdrT::BdbGenericHdrT( BdbRef( BdbGenericHdr )& header )
   : _bdbRef( header )
{
}

BdbGenericHdrT::BdbGenericHdrT( BdbHandle( BdbGenericHdr )& header )
   : _bdbRef( header )
{
}

BdbGenericHdrT::BdbGenericHdrT( const BdbGenericHdrT& aRhs )
   : _bdbRef( aRhs._bdbRef )
{
}

// BdbGenericHdrT::BdbGenericHdrT( const BdbGenericHdrT& aRhs )
// {
// }

const BdbGenericHdrT& 
BdbGenericHdrT::operator=( const BdbRef( BdbGenericHdr )& p )
{
    _bdbRef = p;
    return *this;
}

const BdbGenericHdrT& 
BdbGenericHdrT::operator=( const BdbHandle( BdbGenericHdr )& p )
{
    _bdbRef = p;
    return *this;
}

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

BdbGenericHdrT::~BdbGenericHdrT()
{
}


//-------------
// Operators --
//-------------
    
// const BdbGenericHdrT& BdbGenericHdrT::operator=( const BdbGenericHdrT& aRhs )
// {
// }

//-------------
// Selectors --
//-------------

d_Boolean
BdbGenericHdrT::isNull() const
{
   return( _bdbRef.isNull() ) ;
}

const BdbRefAny&
BdbGenericHdrT::getPersistent() const
{
   assert( ! isNull() ) ;
   return( _bdbRef ) ;
}

const BdbHandle( BdbGenericHdr )
BdbGenericHdrT::getHandle() const
{
   return( (BdbRef( BdbGenericHdr ))(getPersistent()) ) ;
}

size_t
BdbGenericHdrT::getPersObjs( BdbRefAny*& list ) const
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->getPersObjs( list ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader
   return( getHandle()->getPersObjs( list ) ) ;
}

size_t
BdbGenericHdrT::getKeys( const char**& resultantKeys ) const
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->getKeys( resultantKeys ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader
   return( getHandle()->getKeys( resultantKeys ) ) ;
}

size_t
BdbGenericHdrT::getTypeAndStrings( const BdbTypeAndString*& typeAndStrings) const
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->getTypeAndStrings( typeAndStrings ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader
   return( getHandle()->getTypeAndStrings( typeAndStrings ) ) ;
}

bool
BdbGenericHdrT::ownedBy( const BdbRefAny& owner ) const
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->ownedBy( owner ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader
   BdbHandle( BdbPersObj ) ownerH( owner ) ;
   return( getHandle()->isOwner( ownerH ) ) ;
}

BdbStatus
BdbGenericHdrT::get( BdbRefAny& object , 
                     ooTypeNumber typeNum, 
                     const char* const key ) const
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->get( object ,
                                                                      typeNum ,
                                                                      key ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader
   return( getHandle()->get( object ,
                             typeNum ,
                             key ) ) ;
}

bool
BdbGenericHdrT::canBeGenericHdrT( ooTypeNumber typeN ) const
{
   // Until we are able to use dynamic schema access this routine is
   //   ugly as the type number are hardwired. The reason for this is
   //   that we do not want to use the object and 'ooIsKindOf' as that
   //   requires access to the object which may not be available.
   switch( typeN ) {
      case( 1000024 ) : // BdbGenericHdr
      case( 1000025 ) : // BdbTreeHdr
      case( 1000026 ) : // BdbMetaDataP
      case( 1000036 ) : // BdbEvent
      case( 1000645 ) : // BdbEvent_001
      case( 1000854 ) : // BdbGenericMutualHdr
      case( 1000855 ) : // BdbTreeMutualHdr
      {
         return( !false ) ;
         break ;
      }
      default :
      {
         return( false ) ;
         break ;
      }
   }

   return( false ) ;
}

//-------------
// Modifiers --
//-------------

void 
BdbGenericHdrT::reset( )
{
    BdbRefAny nullRef;
    _bdbRef = nullRef;
}

void
BdbGenericHdrT::borrowAsNecessary( const BdbGenericHdrT& original )
{
   const BdbTypeAndString* typeAndStrings ( 0 ) ;
   size_t numberTypeAndStrings( original.getTypeAndStrings( typeAndStrings ) ) ;
   for( size_t index( 0 ) ;
        numberTypeAndStrings != index ;
        index++ ) {
      BdbRefAny dataObject ;

      // If object not in this header, 'borrow' referencec.
      if( BdbcError == get( dataObject ,
                            typeAndStrings[ index ].getType() ,
                            typeAndStrings[ index ].getString() ) ) {
         original.get( dataObject ,
                       typeAndStrings[ index ].getType() ,
                       typeAndStrings[ index ].getString() ) ;
         borrow( dataObject ,
                 typeAndStrings[ index ].getType() ,
                 typeAndStrings[ index ].getString() ) ;
      }

      // If object is in this header and is a header itself, be recursive
      else {
         if( canBeGenericHdrT( typeAndStrings[ index ].getType() ) ) {
            BdbGenericHdrT leaf( (BdbRef( BdbGenericHdr ))dataObject ) ;
            BdbRefAny( origObject ) ;
            original.get( origObject ,
                          typeAndStrings[ index ].getType() ,
                          typeAndStrings[ index ].getString() ) ;
            leaf.borrowAsNecessary( BdbGenericHdrT( (BdbRef( BdbGenericHdr ))origObject ) ) ;
         }
      }
   }
   if( 0 != numberTypeAndStrings ) {

      // cast away const to allow deletion
      delete [] const_cast< BdbTypeAndString* >( typeAndStrings ) ;
   }
}

BdbHandle( BdbGenericHdr )
BdbGenericHdrT::getHandle()
{
   return( (BdbRef( BdbGenericHdr ))(getPersistent()) ) ;
}

BdbStatus
BdbGenericHdrT::put( const BdbRefAny& object , 
                     const ooTypeNumber typeNumber ,
                     const char* const key )
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->put( object ,
                                                                      typeNumber ,
                                                                      key ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader.
   // cast away "const" to be compatible with old interface.
   return( getHandle()->put( (BdbRefAny&)object ,
                             typeNumber ,
                             key ) ) ;
}

BdbStatus
BdbGenericHdrT::put( BdbRefAny& object , 
                     const char* const key )
{
   return( put( object ,
                object.typeN() ,
                key ) ) ;
}

BdbStatus
BdbGenericHdrT::borrow( const BdbRefAny& object , 
                        const ooTypeNumber typeNumber ,
                        const char* const key )
{
   // If new style BdbGenericMutualHdr then run recast and use
   //   correct access
   if( getHandle()->ooIsKindOf( ooTypeN( BdbGenericMutualHdr ) ) ) {
      return( ((BdbRef( BdbGenericMutualHdr )&)getPersistent())->borrow( object ,
                                                                         typeNumber ,
                                                                         key ) ) ;
   }
   
   // Otherwise assume old style BdbGenericHeader.
   // cast away "const" to be compatible with old interface.
   return( getHandle()->borrow( (BdbRefAny&)object ,
                                typeNumber ,
                                key ) ) ;
}

#endif // BDBGENERICHDRT_CC

 

---

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

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