---

CdbBdbSDirectoryNodeP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSDirectoryNodeP.cc,v 1.5 2004/08/06 05:54:24 bartoldu Exp $

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

#include "BaBar/BaBar.hh"

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

#include "CdbBdbShared/CdbBdbSLeafNodeP.hh"

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

template< typename E >
CdbBdbSDirectoryNodeP<E>::CdbBdbSDirectoryNodeP( d_ULong theLevel,
                                                 d_ULong theSize ) :
    CdbBdbSNodeP<E>( theLevel ),
    _nodes(theSize)
{ }

template< typename E >
CdbBdbSDirectoryNodeP<E>::~CdbBdbSDirectoryNodeP( ) 
{

  // Destroy the nodes beneath (recursive)

    d_ULong theSize = _nodes.size( );
    for( d_ULong i = 0; i < theSize; ++i )
        if( ! BdbIsNull( _nodes[i] )) BdbDelete( _nodes[i] );
}

template< typename E >
BdbStatus
CdbBdbSDirectoryNodeP<E>::resize( d_ULong theNewSize,
                                  d_ULong theNumPerLeaf,
                                  d_ULong theNumPerDirectory )
{
    ooUpdate( );
    _nodes.update( );

    d_ULong numPerNode = theNumPerLeaf;
    for( d_ULong i = 1; i < _level; ++i ) numPerNode = numPerNode * theNumPerDirectory;

    d_ULong numFullNodes = theNewSize / numPerNode;

    d_ULong remainder = theNewSize;
    if( numFullNodes ) remainder = theNewSize % ( numPerNode * numFullNodes );

    d_ULong numNewNodes  = numFullNodes;
    if( remainder ) ++numNewNodes;

    d_ULong numOldNodes = _nodes.size( );

  // Expand or shrink?

    if( numNewNodes == numOldNodes ) {

      // Just adjust the size of the last used node.

        d_ULong numToSet = numPerNode;
        if( remainder ) numToSet = remainder;

        _nodes[numOldNodes-1]->resize( numToSet,
                                       theNumPerLeaf,
                                       theNumPerDirectory );

    } else if( numNewNodes < numOldNodes ) {

      // Shrink the subtree.

        for( d_ULong i = numNewNodes; i < numOldNodes; ++i ) {
            BdbDelete( _nodes[i] );
        }
        _nodes.resize( numNewNodes );
        if( remainder ) {
            _nodes[numNewNodes-1]->resize( remainder,
                                           theNumPerLeaf,
                                           theNumPerDirectory );
        }

    } else {

      // Expand the subtree.

        _nodes.resize( numNewNodes );

        if( numOldNodes ) {
            _nodes[numOldNodes-1]->resize( numPerNode,
                                           theNumPerLeaf,
                                           theNumPerDirectory );
        }
        for( d_ULong i = numOldNodes; i < numFullNodes; ++i ) {
            if( _level == 1 ) {
                _nodes[i] = new( ooThis( )) CdbBdbSLeafNodeP<E>( );
            } else {
                _nodes[i] = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( _level - 1 );
            }
            _nodes[i]->resize( numPerNode,
                               theNumPerLeaf,
                               theNumPerDirectory );
        }
        if( remainder ) {
            if( _level == 1 ) {
                _nodes[numFullNodes] = new( ooThis( )) CdbBdbSLeafNodeP<E>( );
            } else {
                _nodes[numFullNodes] = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( _level - 1 );
            }
            _nodes[numFullNodes]->resize( remainder,
                                          theNumPerLeaf,
                                          theNumPerDirectory );
        }
    }
    return BdbcSuccess;
}

template< typename E >
BdbStatus
CdbBdbSDirectoryNodeP<E>::resize( d_ULong                        theNewSize,
                                  d_ULong                        theNumPerLeaf,
                                  d_ULong                        theNumPerDirectory,
                                  const BdbRef(CdbBdbSNodeP<E>)& theNode )
{
    ooUpdate( );
    _nodes.update( );

    d_ULong numPerNode = theNumPerLeaf;
    for( d_ULong i = 1; i < _level; ++i ) numPerNode = numPerNode * theNumPerDirectory;

    d_ULong numFullNodes = theNewSize / numPerNode;

    d_ULong remainder = theNewSize;
    if( numFullNodes ) remainder = theNewSize % ( numPerNode * numFullNodes );

    d_ULong numNewNodes  = numFullNodes;
    if( remainder ) ++numNewNodes;

    d_ULong numOldNodes = _nodes.size( );

  // Create the tree from the scratch only.

    if( numOldNodes ) {
        assert( 0 );    // FATAL ERROR: incorrect use of the procedure.
    } else {

        _nodes.resize( numNewNodes );

        for( d_ULong i = 0; i < numFullNodes; ++i ) {
            if(( 0 == i ) && ( theNode->_level == ( _level - 1 ))) {
                _nodes[i] = theNode;
                _nodes[i]->resize( numPerNode,
                                   theNumPerLeaf,
                                   theNumPerDirectory );
            } else {
                if( _level == 1 ) {
                    _nodes[i] = new( ooThis( )) CdbBdbSLeafNodeP<E>( );
                    _nodes[i]->resize( numPerNode,
                                       theNumPerLeaf,
                                       theNumPerDirectory );
                } else {
                    _nodes[i] = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( _level - 1 );
                    if( 0 == i ) {
                        ((const BdbRef(CdbBdbSDirectoryNodeP<E>)&) _nodes[i])->resize( numPerNode,
                                                                                       theNumPerLeaf,
                                                                                       theNumPerDirectory,
                                                                                       theNode );
                    } else {
                        _nodes[i]->resize( numPerNode,
                                           theNumPerLeaf,
                                           theNumPerDirectory );
                    }
                }
            }
        }
        if( remainder ) {
            if(( 0 == numFullNodes ) && ( theNode->_level == ( _level - 1 ))) {
                _nodes[numFullNodes] = theNode;
                _nodes[numFullNodes]->resize( remainder,
                                              theNumPerLeaf,
                                              theNumPerDirectory );
            } else {
                if( _level == 1 ) {
                    _nodes[numFullNodes] = new( ooThis( )) CdbBdbSLeafNodeP<E>( );
                    _nodes[numFullNodes]->resize( remainder,
                                                  theNumPerLeaf,
                                                  theNumPerDirectory );
                } else {
                    _nodes[numFullNodes] = new( ooThis( )) CdbBdbSDirectoryNodeP<E>( _level - 1 );
                    if( 0 == numFullNodes ) {
                        ((const BdbRef(CdbBdbSDirectoryNodeP<E>)&) _nodes[numFullNodes])->resize( remainder,
                                                                                                  theNumPerLeaf,
                                                                                                  theNumPerDirectory,
                                                                                                  theNode );
                    } else {
                         _nodes[numFullNodes]->resize( remainder,
                                                       theNumPerLeaf,
                                                       theNumPerDirectory );
                    }
                }
            }
        }
    }
    return BdbcSuccess;
}

template< typename E >
void
CdbBdbSDirectoryNodeP<E>::setElementAt( d_ULong  theIndex,
                                        const E& value,
                                        d_ULong  theNumPerLeaf,
                                        d_ULong  theNumPerDirectory )
{
    d_ULong numPerNode = theNumPerLeaf;
    for( d_ULong i = 1; i < _level; ++i )
        numPerNode = numPerNode * theNumPerDirectory;

    _nodes[theIndex / numPerNode]->setElementAt( theIndex % numPerNode,
                                                 value,
                                                 theNumPerLeaf,
                                                 theNumPerDirectory );
}

template< typename E >
E
CdbBdbSDirectoryNodeP<E>::elementAt( d_ULong theIndex,
                                     d_ULong theNumPerLeaf,
                                     d_ULong theNumPerDirectory ) const
{
    d_ULong numPerNode = theNumPerLeaf;
    for( d_ULong i = 1; i < _level; ++i )
        numPerNode = numPerNode * theNumPerDirectory;

    return _nodes[theIndex / numPerNode]->elementAt( theIndex % numPerNode,
                                                     theNumPerLeaf,
                                                     theNumPerDirectory );
}

template< typename E >
void
CdbBdbSDirectoryNodeP<E>::dump( d_ULong  numSpaces,
                               ostream& o,
                               bool     dumpContentsFlag ) const
{
    o << ooThis( ).sprint( ) << " : <DIRECTORY> level = " << _level << ", size = " << _nodes.size( ) << endl;

    d_ULong num = _nodes.size( );
    for( d_ULong i = 0; i < num; ++i ) {
        for( d_ULong j = 0; j < numSpaces + 2; ++j ) o << ' ';
        _nodes[i]->dump( numSpaces + 4, o, dumpContentsFlag );
    }
}

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

---