---

CdbBdbSRallocatorP.cc

Go to the documentation of this file.

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

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

#include "BaBar/BaBar.hh"

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

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

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::CdbBdbSRallocatorP( )
{
    _allocatedRef = new( ooThis( )) CdbBdbSBtreeP< RT >( );
    _freeRef      = new( ooThis( )) CdbBdbSBtreeP< RT >( );

  // We need to generate at least one resource to set up the value
  // of this data member.

    _recent = RT_OPERATIONS_POLICY::min( );
    _freeRef->insert( _recent );
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::~CdbBdbSRallocatorP( ) 
{
    BdbDelete( _allocatedRef );
    BdbDelete( _freeRef );
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbStatus
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::isAllocated( const RT& theResource ) const
{
    if( ! RT_OPERATIONS_POLICY::valid( theResource ))
        return CdbStatus::Error;

    return ( _allocatedRef->search( theResource ) ? CdbStatus::Success : CdbStatus::NotFound );
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbStatus
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::allocate( RT& theResource )
{
    ooUpdate( );

  // Try the index of free elements first

    CdbItr<RT> itr = _freeRef->iterator( );
    if( itr.next( )) {

        theResource = itr.value( );

        _freeRef->remove( theResource );
        _allocatedRef->insert( theResource );

        return CdbStatus::Success;
    }

  // Try to generate new resource using the recently generated value
  //
  // NOTE: The generation process will skip values, which are already
  //       found in the index of allocated ones. These values may get into
  //       the index through the "back door" registration procedure provided
  //       by the "force" method.

    do {
        _recent = RT_OPERATIONS_POLICY::next( _recent );
        if( ! _allocatedRef->search( _recent )) {

            theResource = _recent;
            _allocatedRef->insert( theResource );

            return CdbStatus::Success;
        }

    } while( _recent != RT_OPERATIONS_POLICY::min( ));

    return CdbStatus::NotFound;
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbStatus
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::force( const RT& theResource )
{
    ooUpdate( );

    CdbStatus result = isAllocated( theResource ); 

  // At this point we're happy with both "Success" (which means: "Yes, it's already
  // alocated!") or "Error" (means: "The invalid value of the resource!").
  //
  // Therefore, all we need to check is if the specified resource was not allocated.

    if( CdbStatus::NotFound == result ) {

      // Make sure there is no such resource in the index of free elements.

        if( _freeRef->search( theResource )) {
            _freeRef->remove( theResource );
        }

      // Force the insertion.
      //
      // NOTE: This operation may slightly disturb the generator
      //       of resources based on incrementing the most recently generated
      //       value of the resource.

        _allocatedRef->insert( theResource );

        return CdbStatus::Success;
    }
    return result;
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbStatus
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::release( const RT& theResource )
{
    ooUpdate( );

    CdbStatus result = isAllocated( theResource ); 
    if( CdbStatus::Success == result ) {
        _allocatedRef->remove( theResource );
        _freeRef->insert( theResource );
    }
    return result;
}

template< class RT,
          class RT_OPERATIONS_POLICY >
CdbItr<RT>
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::iterator( ) const
{
    return _allocatedRef->iterator( );
}

template< class RT,
          class RT_OPERATIONS_POLICY >
void
CdbBdbSRallocatorP<RT,RT_OPERATIONS_POLICY>::dump( ostream& o ) const
{
    o << "=========================" << endl
      << "== Resources Aloocator ==" << endl
      << "=========================" << endl
      << endl
      << "Minimum available:  " << RT_OPERATIONS_POLICY::min( ) << endl
      << "Recently generated: " << _recent << endl
      << endl
      << "List of allocated resources:" << endl
      << endl;

    d_ULong num = 0;

    CdbItr<RT> itr = _allocatedRef->iterator( );
    while( itr.next( )) {
        o << itr.value( ) << endl;
    }

    o << endl
      << "Total of " << num << " resources were found." << endl;
}

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

---