---

CdbBdbSPagedVarrayP.cc

Go to the documentation of this file.

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

/// The implementation file for the CdbBdbSPagedVarrayP class
/**
  * @see CdbBdbSPagedVarrayP
  */

#include "BaBar/BaBar.hh"

#if !defined(OO_DDL_TRANSLATION)
#include "CdbBdbShared/CdbBdbSPagedVarrayP.hh"
#endif // OO_DDL_TRANSLATION

#include "BdbApplication/BdbDomain.hh"

#include <assert.h>
using std::endl;
using std::ostream;

template< typename E >
CdbBdbSPagedVarrayP<E>::CdbBdbSPagedVarrayP( d_ULong theInitialSize,
                                             d_ULong theNumPerLeaf,
                                             d_ULong theNumPerDirectory ) :
    _numPerLeaf(theNumPerLeaf),
    _numPerDirectory(theNumPerDirectory),
    _numLevels(0),
    _size(theInitialSize),
    _leafNode(0),
    _directoryNode(0)
{
  // Set up default configuration parameters of the array
  // if the corresponding parameters were omitted.

    if( ! _numPerLeaf )      _numPerLeaf      = defaultNumPerLeaf( );
    if( ! _numPerDirectory ) _numPerDirectory = defaultNumPerDirectory( );

  // Allocate specified number of elements.

    _numLevels = calculateNumLevels( theInitialSize );
    if( _numLevels ) {
        _directoryNode = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( _numLevels );
        _directoryNode->resize( theInitialSize,
                                _numPerLeaf,
                                _numPerDirectory );
    } else {
        _leafNode = new( ooThis( )) CdbBdbSLeafNodeP<E>( theInitialSize );
    }
}

template< typename E >
CdbBdbSPagedVarrayP<E>::~CdbBdbSPagedVarrayP( ) 
{
  // Destroy all the nodes (recursive)

    if( ! BdbIsNull( _leafNode ))      BdbDelete( _leafNode );
    if( ! BdbIsNull( _directoryNode )) BdbDelete( _directoryNode );
}

template< typename E >
d_ULong
CdbBdbSPagedVarrayP<E>::size( ) const
{
    return _size;
}

template< typename E >
BdbStatus
CdbBdbSPagedVarrayP<E>::resize( d_ULong theNewSize )
{
    if( theNewSize == _size ) return BdbcSuccess;

    ooUpdate( );

    BdbStatus result = BdbcError;
    {
        d_ULong newNumLevels = calculateNumLevels( theNewSize );

        if( theNewSize < _size ) {
            if( _numLevels == 0 ) {
                result = _leafNode->resize( theNewSize,
                                            _numPerLeaf,
                                            _numPerDirectory );
            } else {
                result = _directoryNode->resize( theNewSize,
                                                 _numPerLeaf,
                                                 _numPerDirectory );
                if( BdbcSuccess == result ) {

                    if( newNumLevels == _numLevels ) {

                      // Nothing else to do. The previous call to resize to the initial
                      // directory node has done everything.

                        ;

                    } else {

                      // Find the "least sufficient" node in the tree of nodes.
                      // We're going to promote this node and reconnect it directly
                      // to the current node (either as a leaf or as a directory node).

                        BdbRef(CdbBdbSNodeP<E>) prevNode = _directoryNode;
                        BdbRef(CdbBdbSNodeP<E>) node     = ((const BdbRef(CdbBdbSDirectoryNodeP<E>)&) prevNode)->_nodes[0];

                        for( d_ULong i = 1; i < _numLevels - newNumLevels; ++i ) {
                            prevNode = node;
                            node     = ((const BdbRef(CdbBdbSDirectoryNodeP<E>)&) prevNode)->_nodes[0];
                        }

                      // Destroy the old tree of nodes except the found sub-branch
                      // (this is why we put 0 instead of its reference).

                        ((const BdbRef(CdbBdbSDirectoryNodeP<E>)&) prevNode)->_nodes[0] = 0;
                        BdbDelete( _directoryNode );
                        _directoryNode = 0;

                      // Connect the found node where it's appropriate

                        if( newNumLevels ) _directoryNode = (const BdbRef(CdbBdbSDirectoryNodeP<E>)&) node;
                        else               _leafNode      = (const BdbRef(CdbBdbSLeafNodeP<E>)&)      node;
                    }
                }
            }

        } else {

            if( newNumLevels == 0 ) {
                result = _leafNode->resize( theNewSize,
                                            _numPerLeaf,
                                            _numPerDirectory );
            } else {

                if( newNumLevels == _numLevels ) {
                    result = _directoryNode->resize( theNewSize,
                                                     _numPerLeaf,
                                                     _numPerDirectory );
                } else {

                  // Most complicated scenario - the current tree must grow
                  // in levels. We're going to reuse the current (either Leaf or Directory)
                  // node in the new tree.

                    BdbRef(CdbBdbSDirectoryNodeP<E>) newDirectoryNode = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( newNumLevels );
                    if( _numLevels ) {
                        result = newDirectoryNode->resize( theNewSize,
                                                           _numPerLeaf,
                                                           _numPerDirectory,
                                                           _directoryNode );
                        if( BdbcSuccess == result ) {
                            _directoryNode = newDirectoryNode;
                        }
                    } else {
                        result = newDirectoryNode->resize( theNewSize,
                                                           _numPerLeaf,
                                                           _numPerDirectory,
                                                           _leafNode );
                        if( BdbcSuccess == result ) {
                            _leafNode      = 0;
                            _directoryNode = newDirectoryNode;
                        }
                    }
                }
            }
        }
        if( BdbcSuccess == result ) {
            _numLevels = newNumLevels;
            _size      = theNewSize;
        }
    }
    return result;
}

/*
 * ATTENTION: Using virtual memory references is unsafe in persistent world
 *            since the (Objectivity) cache is out of our control.
 *            It's true for both read and write operations.
 *
 *            This is why we use two explicit (read/write) operations with values
 *            instead of this subscript operator. The only reason we still have
 *            this operator here is to attract attention to this problem.
 *
template< typename E >
E&
CdbBdbSPagedVarrayP<E>::operator[]( d_ULong theIndex )
{
    assert( theIndex < _size );

    if( ! _numLevels )
        return _leafNode->_data[theIndex];

    return _directoryNode->elementAt( theIndex,
                                      _numPerLeaf,
                                      _numPerDirectory );
}
*/

template< typename E >
void
CdbBdbSPagedVarrayP<E>::setElementAt( d_ULong  theIndex,
                                      const E& value )
{
    assert( theIndex < _size );

    BdbRef( CdbBdbSNodeP<E> ) nodeRef;
    if( _numLevels ) nodeRef = _directoryNode;
    else             nodeRef = _leafNode;

    nodeRef->setElementAt( theIndex,
                           value,
                           _numPerLeaf,
                           _numPerDirectory );
}

template< typename E >
E
CdbBdbSPagedVarrayP<E>::elementAt( d_ULong theIndex ) const
{
    assert( theIndex < _size );

    BdbRef( CdbBdbSNodeP<E> ) nodeRef;
    if( _numLevels ) nodeRef = _directoryNode;
    else             nodeRef = _leafNode;

    return nodeRef->elementAt( theIndex,
                               _numPerLeaf,
                               _numPerDirectory );
}

template< typename E >
void
CdbBdbSPagedVarrayP<E>::dump( ostream& o,
                              bool     dumpContentsFlag ) const
{
    o << ooThis( ).sprint( ) << " : <PAGED V-ARRAY>" << endl
      << "  numPerLeaf      = " << _numPerLeaf << endl
      << "  numPerDirectory = " << _numPerDirectory << endl
      << "  numLevels       = " << _numLevels << endl
      << "  size            = " << _size << endl
      << "  leafNode        = " << _leafNode.sprint( ) << endl
      << "  directoryNode   = " << _directoryNode.sprint( ) << endl
      << "    ";

    if( _numLevels ) _directoryNode->dump( 4, o, dumpContentsFlag );
    else             _leafNode->dump     ( 4, o, dumpContentsFlag );
}

template< typename E >
d_ULong
CdbBdbSPagedVarrayP<E>::calculateNumLevels( d_ULong theSize ) const
{
    if( theSize <= _numPerLeaf ) return 0;

    d_ULong result = 0;
    {
        d_ULong numPerNode = _numPerLeaf;
        do {
            ++result;
            numPerNode = numPerNode * _numPerDirectory;
        } while(( theSize - 1 ) / numPerNode ); // -1 is needed to avoid one extra step
    }
    return result;
}

template< typename E >
d_ULong
CdbBdbSPagedVarrayP<E>::defaultNumPerLeaf( ) const
{
    ooHandle(ooFDObj) fdH;
    fdH = BdbApplicationOrDomain::activeInstance()->fd( );

    assert( ! BdbIsNull( fdH ));

  // We're going to use the default constructor to measure the size
  // of type "E" to avoid a compilation problem with "typedef E" from
  // a template class.
  //
  // NOTE: This constructor must be valid and w/o side effects!!!

    E e;
    d_ULong eSize = sizeof( e );

  // We're assuming that ooVArray overhead does not exceed 256 bytes per page.

    return ( fdH.pageSize( ) - 256 ) / eSize;
}

template< typename E >
d_ULong
CdbBdbSPagedVarrayP<E>::defaultNumPerDirectory( ) const
{
    ooHandle(ooFDObj) fdH;
    fdH = BdbApplicationOrDomain::activeInstance()->fd( );

    assert( ! BdbIsNull( fdH ));

  // We're going to use the default constructor to measure the size
  // of type "ooRef(CdbBdbSNodeP<E>)" to avoid a compilation problem with
  // "typedef ooRef(CdbBdbSNodeP<E>)" from a template class.
  //
  // NOTE: This constructor must be valid and w/o side effects!!!

    ooRef(CdbBdbSNodeP<E>) nH;
    d_ULong nSize = sizeof( nH );

  // We're assuming that ooVArray overhead does not exceed 256 bytes per page.

    return ( fdH.pageSize( ) - 256 ) / nSize;
}

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

---