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

                 

---

/BdbEvent/BdbGenericHdrP.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: BdbGenericHdrP.cc,v 1.1 1999/04/17 15:08:05 quarrie Exp $
//
// Description:
//  Class BdbGenericHdrP. Implementation file for generic header class.
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//  David R. Quarrie            Original Author
//
// Copyright Information:
//  Copyright (C) 1994, 1995    Lawrence Berkeley Laboratory
//
// History:
//      Ray F. Cowan 971217    Added binary search on ooTypeNumber and 
//                             linear search for secondary key.  
//      Ray F. Cowan 980114    Use BdbPString objects for secondary key;
//                             no longer add ooTypeN at front of key string.
//      Ray F. Cowan 980202    Fixed use of BdbPString in replace(); treat
//                             secondary key null pointers as null strings.
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbEvent/BdbGenericHdrP.hh"

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

//---------------
// C++ Headers --
//---------------
#include <iostream.h>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbEvent/BdbEventErrors.hh"
#include "BdbUtil/BdbPString.hh"

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

static const char rcsid[] = "$Id: BdbGenericHdrP.cc,v 1.1 1999/04/17 15:08:05 quarrie Exp $";

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

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

BdbGenericHdrP::BdbGenericHdrP( BdbHandle(BdbGenericHdrP)& theHeader )
{
    _name = theHeader->name( );
     size_t size = theHeader->_data.size( );
    _data.resize( size );
    _keys.resize( size );
    for ( size_t i = 0; i < size; i++ ) {
        _data[i] = theHeader->_data[i];
        _keys[i] = theHeader->_keys[i];
    }
}

//---------------
// Destructors --
//---------------

BdbGenericHdrP::~BdbGenericHdrP( )
{
    clear( );
}

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

const char*
BdbGenericHdrP::name( ) const
{
    return (const char*)_name;
}

d_ULong
BdbGenericHdrP::size( ) const
{
    return _data.size( );
}

d_Boolean
BdbGenericHdrP::isOwner( BdbHandle(BdbPersObj)& theOwner ) const
{
    d_Boolean result = false;
    if ( theOwner == _owner( ) ) {
        result = true;
    }
    return result;
}

BdbStatus
BdbGenericHdrP::owner( BdbHandle(BdbPersObj)& theOwner ) const
{
    BdbStatus result = BdbcError;
    theOwner = 0;
    if ( ! BdbIsNull( _owner( ) ) ) {
        theOwner = _owner( );
        result   = BdbcSuccess;
    }
    return result;
}

BdbStatus
BdbGenericHdrP::setOwner( BdbHandle(BdbPersObj)& theOwner )
{
    BdbStatus result = update( "BdbGenericHdrP::setOwner" );
    set__owner( theOwner ); 
    return result;
}

//--------------
// Operations --
//--------------

BdbStatus
BdbGenericHdrP::add( const BdbRef(BdbPersObj)& theObj, d_ULong theIndex,
                     const char* const theKeyString )
{
    // Starting at the rear, bump objects down one, then insert new object
    // at the indexed position.

    BdbRef(BdbPersObj) item;
    BdbHandle(BdbPString) theKeyH = 0; // These will stay null unless the key
    BdbRef(BdbPString) theKey = 0;     // is a non-null string to save time.
    BdbRef(BdbPString) itemKey;
    BdbRefAny theHint;

    BdbStatus status = _data.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::add", "_data.update( )" );
    }
    assert( status );
    status = _keys.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::add", "_keys.update( )" );
    }
    assert( status );

    int theSize = _data.size();

    // Create a new BdbPString object in same container as this tree header,
    // but only if the incoming char* string is not a null pointer (equal
    // to 0) and is not a null string (a non-null pointer pointing to a
    // zero-length char* string).

    if( theKeyString != 0 ) {          // Detect zero pointer.
      if( *theKeyString != '\0' ) {    // Detect zero-length char* string.
        theHint = ooThis();
        theKeyH = new( theHint ) BdbPString( theKeyString );
        theKey  = theKeyH;
      }
    }

    // Now we have either a zero ooRefHandle or a non-zero one accessing a
    // non-zero length BdbPString.

    if( theSize == 0 || theIndex == theSize ) {
      _data.extend( theObj );
      _keys.extend( theKey );
    } else {

      int i = 0;
      int last = theSize - 1;

      item     = _data[last];
      itemKey  = _keys[last];
      _data.extend( item    );
      _keys.extend( itemKey );

      // cast from d_ULong to int is necessary when i < 0 (eg., "-1 > 0"
      // is treated as "4294967295 >= 0" and returns true.
      if( theSize > 1 ) for( i = last - 1; i >= (int) theIndex; i-- ) {
        item     = _data[i];
        itemKey  = _keys[i];
        _data.set( i + 1, item    );
        _keys.set( i + 1, itemKey );
      }

      // Place the new item in the index'ed slot, along with its key.
      _data.set( theIndex, theObj );
      _keys.set( theIndex, theKey );
    }

    return BdbcSuccess;
}

BdbStatus
BdbGenericHdrP::addItemKey( const BdbRef(BdbPersObj)& theObj, d_ULong theIndex,
                            BdbRef(BdbPString)& theKey )
{
    // Starting at the rear, bump objects down one, then insert new object
    // at the indexed position.

    BdbRef(BdbPersObj) item;
    BdbRef(BdbPString) itemKey;
    BdbRefAny theHint;

    BdbStatus status = _data.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::addItemKey", "_data.update( )" );
    }
    assert( status );
    status = _keys.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::addItemKey", "_keys.update( )" );
    }
    assert( status );

    int theSize = _data.size();

    if( theSize == 0 || theIndex == theSize ) {
      _data.extend( theObj );
      _keys.extend( theKey );
    } else {

      int i = 0;
      int last = theSize - 1;

      item     = _data[last];
      itemKey  = _keys[last];
      _data.extend( item    );
      _keys.extend( itemKey );

      // cast from d_ULong to int is necessary when i < 0 (eg., "-1 > 0"
      // is treated as "4294967295 >= 0" and returns true.
      if( theSize > 1 ) for( i = last - 1; i >= (int) theIndex; i-- ) {
        item     = _data[i];
        itemKey  = _keys[i];
        _data.set( i + 1, item    );
        _keys.set( i + 1, itemKey );
      }

      // Place the new item in the index'ed slot, along with its key.
      _data.set( theIndex, theObj );
      _keys.set( theIndex, theKey );
    }

    return BdbcSuccess;
}

BdbStatus
BdbGenericHdrP::get( BdbRef(BdbPersObj)& theItem,
                     ooTypeNumber theType,
                     const char* const theKeyString ) const
{
    BdbRef(BdbPersObj) anItem;
    BdbRef(BdbPString) aKey;
    BdbHandle(BdbPString) aKeyH;
    BdbStatus result = BdbcError;

    int i = 0;
    int theSize = size();
    if( theSize == 0 ) return result;

    // Implement binary search followed by secondary key string match.
    int low  = 0;
    int high = theSize - 1;

    i = ( low + high ) / 2;      // initial midpoint

    for(;;) {
      item( anItem, i );
      if( anItem.typeN() == theType ) {
        result = BdbcSuccess;
        break;
      }

      if( i == high ) {
        return result;
      }

      if( anItem.typeN() > theType ) { // back up halfway
        high = i;
      } else { // go forward halfway
        low = i;
      }

      // reset index and test again
      if( ( i == low ) && ( high - low == 1 ) ) {
        i = high;
      } else {
        i = ( low + high ) / 2;
      }

    }  // End of for(;;) loop

    // At this point a true result means we have matched the TypeN but
    // not necessarily the secondary key.  Now do a linear search from
    // the current position back and forward of matching TypeN's.

    // Store the key string as an BdbTString.  This will create a BdbTString
    // object representing a zero-length string if either theKeyString is a
    // zero pointer, or if it is a valid pointer to a zero-length string.
    // Otherwise it creates a non-null BdbTString object.
    BdbTString theName = theKeyString;

    // Reset success flag
    result = BdbcError;
    int start = i;

    // Handle required for scoping object
    BdbHandle(BdbGenericHdrP) thisH;
    thisH = ooThis();
    getKey( aKeyH, start ); // Use handle to allow * operation

    // min and max ooVArray limits
    const int bottom = 0;
    const int top = theSize - 1;

    // Search backward
    while( ( i >= bottom ) && ( anItem.typeN() == theType ) ) {
      if( aKeyH != 0 ) {  // valid handle, can perform comparison
        if( theName == *aKeyH ) {
          theItem = anItem;
          result = BdbcSuccess;
          break;
        }
      } else {  // zero handle implies null string
        if( theName == "" ) {  // check for null only
          theItem = anItem;
          result = BdbcSuccess;
          break;
        }
      }
      i--;
      if( i < bottom ) break;
      item  ( anItem, i );
      getKey( aKeyH,  i ); // Use handle to allow * operation
    }

    i = ++start;
    if( i <= top ) {
      item  ( anItem, i );
      getKey( aKeyH,  i ); // Use handle to allow * operation
    }

    // Search forward
    if( !result ) while( ( i <= top ) && ( anItem.typeN() == theType ) ) {
      if( aKeyH != 0 ) {  // valid handle, can perform comparison
        if( theName == *aKeyH ) {
          theItem = anItem;
          result = BdbcSuccess;
          break;
        }
      } else {  // zero handle implies null string
        if( theName == "" ) {  // check for null only
          theItem = anItem;
          result = BdbcSuccess;
          break;
        }
      }
      i++;
      if( i > top ) break;
      item  ( anItem, i );
      getKey( aKeyH,  i ); // Use handle to allow * operation
    }

    return result;
}

BdbStatus
BdbGenericHdrP::getItem( BdbRef(BdbPersObj)& theItem,
                         d_ULong index ) const
{
    BdbStatus result = BdbcError;

    int theSize = size();
    if( theSize == 0 ) return result;
    if( index > theSize - 1 ) return result;

    result = item( theItem, index );
    return result;
}

BdbStatus
BdbGenericHdrP::getKey( BdbHandle(BdbPString)& theKey, d_ULong theIndex ) const
{
    d_Boolean result = BdbcSuccess;
    theKey = _keys[theIndex];
    return result;
}

BdbStatus
BdbGenericHdrP::getKey( BdbRef(BdbPString)& theKey, d_ULong theIndex ) const
{
    d_Boolean result = BdbcSuccess;
    theKey = _keys[theIndex];
    return result;
}

BdbStatus
BdbGenericHdrP::item( BdbRef(BdbPersObj)& theItem, d_ULong theIndex ) const
{
    BdbStatus result = BdbcSuccess;
    theItem = _data[theIndex];
    return result;
}

BdbStatus
BdbGenericHdrP::put( BdbRef(BdbPersObj)& theObj, const char* const theKeyString )
{
    ooTypeNumber theType = theObj.typeN();
    BdbRef(BdbPersObj) anItem( 0 );
    BdbRef(BdbPString) aKey;
    BdbHandle(BdbPString) aKeyH;
    BdbRef(BdbPersObj) highItem( 0 );

    BdbStatus status = _data.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::put", "_data.update( )" );
    }
    assert( status );
    status = _keys.update( );
    if ( ! status ) {
        BdbSignal( BdbcFatalError, BdbEventErrUpdateFailed, 0,
           "BdbGenericHdrP::put", "_keys.update( )" );
    }
    assert( status );

    int i = 0;
    int theSize = size( );

    // Perform binary sort on insertion
    int low = 0;
    int high = theSize - 1;
    i = ( low + high ) / 2;

    // min and max ooVArray limits
    const int bottom = 0;
    const int top = theSize - 1;

    // Store the key string as an BdbTString.  This will create a BdbTString
    // object representing a zero-length string if either theKeyString is a
    // zero pointer, or if it is a valid pointer to a zero-length string.
    // Otherwise it creates a non-null BdbTString object.
    BdbTString theName = theKeyString;

    if( theSize > 0 ) {
      for(;;) {
        item( anItem, i );

        if( anItem.typeN() == theType ) {

          // Now search back/forward for key match, if any.  If no match is
          // found, we add it; if a match is found, we assert an error.

          int j = i;
          int start = j; // record start position for later upward search

          getKey( aKeyH, j ); // Use handle to allow * operation

          // Search backward
          while( ( j >= bottom ) && ( anItem.typeN() == theType ) ) {
            if( aKeyH != 0 ) {  // valid handle, can perform comparison
              status = ( theName != *aKeyH );
            } else {  // zero handle implies null string
              status = ( theName != "" );
            }
            if ( !status ) {
              BdbSignal( BdbcFatalError, BdbEventErrObjectCollision, 0,
                         "BdbGenericHdrP::put", theObj.typeName(),
                         theName.data(), name() );
            }
            assert( status );
            j--;
            if( j < bottom ) break;
            item  ( anItem, j );
            getKey( aKeyH, j ); // Use handle to allow * operation
          }

          j = ++start;
          if( j <= top ) {
            item  ( anItem, j );
            getKey( aKeyH, j ); // Use handle to allow * operation
          }

          // Search forward
          while( ( j <= top ) && ( anItem.typeN() == theType ) ) {
            if( aKeyH != 0 ) {  // valid handle, can perform comparison
              status = ( theName != *aKeyH );
            } else {  // zero handle implies null string
              status = ( theName != "" );
            }
            if ( !status ) {
              BdbSignal( BdbcFatalError, BdbEventErrObjectCollision, 0,
                         "BdbGenericHdrP::put", theObj.typeName(),
                         theName.data(), name() );
            }
            assert( status );
            j++;
            if( j > top ) break;
            item  ( anItem, j );
            getKey( aKeyH, j ); // Use handle to allow * operation
          }

          // Item not in array: type number matched, but not secondary key,
          // so add it here
          add( theObj, i, theName );
          break;
        }

        if( i == high ) {
          // Item not in array: no type number match, so add it here
          if( anItem.typeN() > theType ) {
            add( theObj, i, theName );
          } else {
            add( theObj, i+1, theName );
          }
          break;
        }

        if( anItem.typeN() > theType ) {
          // back up halfway
          high = i;
        } else {
          // advance halfway
          low = i;
        }

        // reset index and test again
        if( ( i == low ) && ( high - low == 1 ) ) {
          i = high;
        } else {
          i = ( low + high ) / 2;
        }

      } //  end of for{;;}
    } // end of if( theSize > 0 )
    else { // No elements yet: theSize is zero
      add( theObj, 0, theName );
    }
    return BdbcSuccess;
}

void
BdbGenericHdrP::clear( d_Boolean destroyItems )
{
    BdbHandleAny theItem;
    BdbHandle(BdbPString) theKey;
    BdbStatus status = update( "BdbGenericHdrP:clear" );
    d_ULong nKeys = _keys.size( );
    d_ULong iKey;
    for ( iKey = 0; iKey < nKeys; iKey++ ) {
        theKey = _keys[iKey];
        if ( ! BdbIsNull( theKey ) ) {
            BdbDelete( theKey );
            _keys[iKey] = 0;
            if ( destroyItems ) {
                theItem = _data[iKey];
                BdbDelete( theItem );
            }
            _data[iKey] = 0;
        }
    }
    _keys.resize( 0 );
    _data.resize( 0 );
}

void
BdbGenericHdrP::clearAndDestroy( )
{
    clear( d_True );
}

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

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

BdbGenericHdrP::BdbGenericHdrP( const char* const theName )
{
    _name = theName;
}

BdbGenericHdrP::BdbGenericHdrP( BdbHandle(BdbPersObj)& theOwner, 
                                const char* const theName )
{
    _name = theName;
    set__owner( theOwner ); 
}

//--------------
// Operations --
//--------------

BdbStatus
BdbGenericHdrP::update( const char* const location )
{
    BdbStatus result = ooUpdate( );
    if ( ! result ) {
        BdbSignal( BdbcFatalError, BdbEventErrObjUpdateFailed, 0, 
           "BdbGenericHdrP::update", location );
    }
    return result;
}

 

---

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

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