---

CdbBdbSBtreeP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSBtreeP.cc,v 1.5 2004/06/20 23:23:09 gapon Exp $

/// Implementation file for the CdbBdbSBtreeP class
/**
  * @see CdbBdbSBtreeP
  */

#include "BaBar/BaBar.hh"

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

template< class K,
          class FCP,
          class ORDER >
CdbBdbSBtreeP<K,FCP,ORDER>::CdbBdbSBtreeP( )
{
    _bufRef = new( ooThis( )) PagedVarrayOfNodeP( 2 );

  // Initialize the root node.

    _root = 1;

    init_node( _root, 0 );

  // Initialize a list of free elements as the empty one.
  // The elements will be added as required.

    _free = 0;
}

template< class K,
          class FCP,
          class ORDER >
CdbBdbSBtreeP<K,FCP,ORDER>::~CdbBdbSBtreeP( ) 
{
    BdbDelete( _bufRef );
}

template< class K,
          class FCP,
          class ORDER >
d_ULong
CdbBdbSBtreeP<K,FCP,ORDER>::allocate( d_ULong parent )
{
    ooUpdate( );
    if( _free == 0 ) extend_free_list( );

    d_ULong result = _free;
    {
        _free = readNode( result ).child[0];

        init_node( result, parent );
    }
    return result;
}

template< class K,
          class FCP,
          class ORDER >
void
CdbBdbSBtreeP<K,FCP,ORDER>::release( d_ULong node )
{
    ooUpdate( );
    if( node ) {

        CdbBdbSBtreeNode<K,ORDER> nodeValue = readNode( node );
        { nodeValue.child[0] = _free; }
        updateNode( node, nodeValue );

        _free = node;
    }
}

template< class K,
          class FCP,
          class ORDER >
d_ULong
CdbBdbSBtreeP<K,FCP,ORDER>::root( ) const
{
    return _root;
}

template< class K,
          class FCP,
          class ORDER >
void
CdbBdbSBtreeP<K,FCP,ORDER>::set_root( d_ULong node )
{
    ooUpdate( );
    _root = node;
}

template< class K,
          class FCP,
          class ORDER >
CdbBdbSBtreeNode<K,ORDER>
CdbBdbSBtreeP<K,FCP,ORDER>::readNode( d_ULong node ) const
{
    return _bufRef->elementAt( node );
}

template< class K,
          class FCP,
          class ORDER >
void
CdbBdbSBtreeP<K,FCP,ORDER>::updateNode( d_ULong                          node,
                                        const CdbBdbSBtreeNode<K,ORDER>& value )
{
    _bufRef->setElementAt( node,
                           value );
}

template< class K,
          class FCP,
          class ORDER >
void
CdbBdbSBtreeP<K,FCP,ORDER>::init_node( d_ULong node,
                                       d_ULong parent )
{
    CdbBdbSBtreeNode<K,ORDER> nodeValue = readNode( node );
    {
        nodeValue.isLeaf = d_True;
        nodeValue.n      = 0;
        nodeValue.parent = parent;
    }
    updateNode( node, nodeValue );
}

template< class K,
          class FCP,
          class ORDER >
void
CdbBdbSBtreeP<K,FCP,ORDER>::extend_free_list( )
{
    if( _free == 0 ) {

        _free = _bufRef->size( );

      // Double the number of elements before the number of elements reaches 1000. Then plainly
      // add a fixed number of elements.
      //
      // NOTES: (1) This policy may change in the future
      //        (2) The policy allows to avoid inefficient use of the persistent space for small B-trees.

        d_ULong sizeIncrement = 1000;
        if(( 0 < _free ) && ( _free < sizeIncrement )) sizeIncrement = _free;

        _bufRef->resize( _free + sizeIncrement );

        for( d_ULong node = _free + 1; node < _free + sizeIncrement; ++node ) {

          // End Of the List

            CdbBdbSBtreeNode<K,ORDER> nodeValue = readNode( node );
            { nodeValue.child[0] = 0; }
            updateNode( node, nodeValue );

          // Previous node points to the current one

            CdbBdbSBtreeNode<K,ORDER> previousNodeValue = readNode( node-1 );
            { previousNodeValue.child[0] = node; }
            updateNode( node-1, previousNodeValue );
        }
    }
}

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

---