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

                 

---

/BdbTrees/BdbTreeNode.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: BdbTreeNode.cc,v 1.40 2002/04/25 02:00:52 patton Exp $
//
// Description:
//  Class BdbTreeNode implementation file. This class represents a node
//  in a tree. A node may have a parent, and multiple children, which
//  themselves may be tree nodes, or leaf objects. This is the transient
//  wrapper class that provides the user interface to the persistent
//  BdbTreeNodeP class.
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//  David R. Quarrie                Original Author
//
// Copyright Information:
//  Copyright (C) 1998              Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbTrees/BdbTreeNode.hh"

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

//---------------------------------
// Collaborating Class's Headers --
//---------------------------------
#include "ErrLogger/ErrLog.hh"
#include "BdbUtil/BdbPathName.hh"
#include "BdbAccess/BdbDbAccessMgr.hh"
#include "BdbAccess/BdbContAccessMgr.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbTrees/BdbMetaData.hh"
#include "BdbTrees/BdbTreesErrors.hh"
#include "BdbTrees/BdbTreeNodeCache.hh"
#include "BdbTrees/BdbTreeNodeLocking.hh"

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

static const char rcsid[] = "$Id: BdbTreeNode.cc,v 1.40 2002/04/25 02:00:52 patton Exp $";


BdbTreeNodeCache*   BdbTreeNode::_tnCache = new BdbTreeNodeCache();
BdbTreeNodeLocking* BdbTreeNode::_tnLock  = new BdbTreeNodeLocking();
const d_Boolean   BdbTreeNode::USE_CACHE  = (getenv("BDB_DO_NOT_USE_TREE_NODE_CACHE") == 0);


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

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

BdbTreeNode::BdbTreeNode( )
: BdbAbsWrapper( )
{
}

BdbTreeNode::BdbTreeNode( BdbTreeNode& theParent, 
                          const char* const theName,
                          BdbHandleAny& placement )
: BdbAbsWrapper( )
{
    BdbHandle(BdbTreeNodeP) theParentP = theParent.persistent( );
    BdbHandleAny usePlacement = placement;
    if ( BdbIsNull( usePlacement ) ) {
        usePlacement = theParentP;
    }
    BdbHandle(BdbTreeNodeP) theNodeP;
    theNodeP = new(usePlacement) BdbTreeNodeP( theParentP, theName );
    if ( ! BdbIsNull( theNodeP ) ) {
        setPersistent( theNodeP );
        theParentP->replace( theNodeP, theName );
    }
}

BdbTreeNode::BdbTreeNode( BdbHandle(BdbTreeNodeP)& theNode )
: BdbAbsWrapper( )
{
    setObject( theNode );
}

BdbTreeNode::BdbTreeNode( const BdbTreeNode& theNode )
: BdbAbsWrapper( )
{
    BdbHandleAny theObj = theNode.object( );
    setObject( theObj );
}

//--------------
// Destructor --
//--------------

BdbTreeNode::~BdbTreeNode( )
{
}

//-------------
// Selectors --
//-------------
    
d_ULong 
BdbTreeNode::count( ) const
{
    return persistent( )->count( );
}

const char*
BdbTreeNode::name( ) const
{
    return persistent( )->name( );
}

const char*
BdbTreeNode::fullName( ) const
{
    return persistent( )->fullName( );
}

const char*
BdbTreeNode::pathName( ) const
{
    return persistent( )->pathName( );
}

//--------------
// Operations --
//--------------
    
BdbStatus
BdbTreeNode::add( BdbTreeNode& aChild, const char* const theName )
{
    BdbHandle(BdbTreeNodeP) aChildP = aChild.persistent( );
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->add( aChildP, theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::add", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::add( BdbHandle(BdbPersObj)& aChild, const char* const theName ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->add( aChild, theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::add", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::child( BdbTreeNode& aChild, const char* const theName ) const
{
    BdbHandle(BdbPersObj) aChildP;
    BdbStatus result = BdbcError;
    
    if ( persistent( )->childIsTreeNode( theName ) ) {
        result = persistent( )->child( aChildP, theName );
    }
    aChild.setPersistent( (BdbHandle(BdbTreeNodeP)&)aChildP );
    return result;
}

BdbStatus
BdbTreeNode::child( BdbHandle(BdbPersObj)& aChild, const char* const theName ) const 
{
    BdbStatus result = persistent( )->child( aChild, theName );
    return result;
}

BdbStatus
BdbTreeNode::child( BdbHandle(BdbPersObj)& aChild, 
                    const char* const theName, 
                    ooTypeNumber theType ) const 
{
    BdbStatus result = persistent( )->child( aChild, theName, theType );
    return result;
}

BdbStatus
BdbTreeNode::child( BdbHandle(BdbPersObj)& aChild, 
                    const char* const theName, 
                    ooTypeNumber theTypes[], d_ULong numTypes ) const 
{
    BdbStatus result = persistent( )->child( aChild, theName, theTypes, numTypes );
    return result;
}

BdbStatus
BdbTreeNode::clear( ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->clear( );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::clear", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::clearAndDestroy( ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->clearAndDestroy( );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::remove", name( ) ); 
    }
    return result;
}

d_Boolean
BdbTreeNode::hasChild( const char* const theName ) const
{
    return persistent( )->hasChild( theName );
}

d_Boolean
BdbTreeNode::hasChild( BdbTreeNode& aChild, d_Boolean descend ) const
{
    BdbHandle(BdbTreeNodeP) aChildP = aChild.persistent( );
    return persistent( )->hasChild( aChildP, descend );
}

d_Boolean
BdbTreeNode::hasChild( BdbHandle(BdbPersObj)& aChild, d_Boolean descend ) const
{
    return persistent( )->hasChild( aChild, descend );
}

BdbStatus
BdbTreeNode::makeChild( BdbTreeNode& aNode, const char* const theName )
{
    BdbHandle(BdbTreeNodeP) theNodeP;
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->makeChild( theNodeP, theName );
        if ( BdbcSuccess == result ) {
            aNode.setPersistent( theNodeP );
        }
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::makeChild", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::parent( BdbTreeNode& theParent ) const
{
    BdbHandle(BdbTreeNodeP) theParentP;
    BdbStatus result = persistent( )->parent( theParentP );
    theParent.setPersistent( theParentP );
    return result;
}

BdbStatus
BdbTreeNode::remove( const char* const theName ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->remove( theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::remove", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::remove( BdbTreeNode& aChild ) 
{
    BdbHandle(BdbTreeNodeP) aChildP = aChild.persistent( );
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->remove( aChildP );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::remove", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::remove( BdbHandle(BdbPersObj)& aChild ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->remove( aChild );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::remove", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::removeAndDestroy( const char* const theName ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->removeAndDestroy( theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::removeAndDestroy", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::removeAndDestroy( BdbTreeNode& aChild ) 
{
    BdbHandle(BdbTreeNodeP) aChildP = aChild.persistent( );
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->removeAndDestroy( aChildP );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::removeAndDestroy", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::removeAndDestroy( BdbHandle(BdbPersObj)& aChild ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->removeAndDestroy( aChild );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::removeAndDestroy", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::replace( BdbTreeNode& aChild, const char* const theName )
{
    BdbHandle(BdbTreeNodeP) aChildP = aChild.persistent( );
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->replace( aChildP, theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::replace", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::replace( BdbHandle(BdbPersObj)& aChild, const char* const theName ) 
{
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->replace( aChild, theName );
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::replace", name( ) ); 
    }
    return result;
}

BdbStatus
BdbTreeNode::upgradeName( )
{
    return persistent( )->upgradeName( );
}

BdbStatus 
BdbTreeNode::moveTo( const char* const thePath )
// Move this transient tree node to reference the persistent tree node
// that corresponds to the specified path. This obeys Unix file syntax.
// An absolute path begins with the "/" character and must specify the
// authorization level and any relevant sublevels. A relative path omits
// the leading "/" character. Moving up the tree is denoted by "../".
{
    BdbTreeNode theNode;
    BdbHandle(BdbTreeNodeP) theNodeP;
    char        theFragment[256];
    const char* fragmentStart = thePath;
    const char* fragmentEnd   = thePath;
    size_t      fragmentLength;
    int         nodePathL = 0; // for cache
    BdbStatus   result = BdbcSuccess;

    if ( NULL != thePath ) {
        if ( ! isNull( ) ) {
            theNode = *this;
            setNull( );
        }
        result = BdbcError;
        if ( BdbPathName::separator() == *thePath ) {
            // it is important to use cache first, because theNode.fullName() touches "Root" container
            if ( USE_CACHE ) {
                // Try to move to the farthest cached tree-node (or Root)
                if ( BdbcSuccess == findBestCachedNode(thePath, theNode, fragmentStart) ) {
                    if ( 0 == fragmentStart ) { // exact match
                        result = BdbcSuccess;
                    }
                } else {
                    if ( BdbcSuccess != theNode.moveToRoot( ) ) {
                        return BdbSignal(BdbcUserError, BdbTreesErrFunctionFailed, 0,
                                         "BdbTreeNode::moveTo", "in moveToRoot 1") ;
                    }
                    fragmentStart++;
                }
                nodePathL = fragmentStart - thePath;
            } else {
                if ( ! theNode.isNull( ) && ( 0 == strcmp( thePath, theNode.fullName( ) ) ) ) {
                    // It's identical - no movement is necessary
                    COUT1 << "BdbTreeNode::moveTo: Cached path" << endl;
                    result = BdbcSuccess;
                } else {
                    // It's not identical - Move to the root tree-node.
                    if ( BdbcSuccess != theNode.moveToRoot( ) ) {
                        return BdbSignal(BdbcUserError, BdbTreesErrFunctionFailed, 0,
                                         "BdbTreeNode::moveTo", "in moveToRoot 2") ;
                    }
                    fragmentStart++;
                }
            }
        }
        if ( BdbcSuccess != result ) {

            // Traverse the path
            result = BdbcSuccess;
            while ( ( BdbcSuccess == result ) && 
                    ( NULL != ( fragmentEnd = strchr( fragmentStart, BdbPathName::separator() ) ) ) ) {
                fragmentLength = fragmentEnd - fragmentStart;
                if ( 0 < fragmentLength ) {
                    strncpy( theFragment, fragmentStart, fragmentLength );
                    theFragment[fragmentLength] = '\0';
                    result = theNode.moveOneLevel( theFragment, d_False );
                    if ( BdbcSuccess == result && USE_CACHE ) { // insert entry into the cache
                        char nodePath[256];
                        nodePathL += fragmentLength;
                        strncpy(nodePath, thePath, nodePathL);
                        nodePath[nodePathL] = '\0';
                        BdbRef(BdbObj) r = (BdbRef(BdbObj)) theNode.persistent();
                        //cout << "TNCACHE: inserting \"" << nodePath
                        //     << "\", oid = " << r.sprint() << endl;
                        _tnCache->insertEntry(nodePath, r);
                    }
               }
                fragmentStart = fragmentEnd + 1;
                nodePathL++;
            }
            if ( BdbcSuccess == result ) {
                // Deal with last fragment
                fragmentLength = strlen( fragmentStart );
                if ( 0 < fragmentLength ) {
                    result = theNode.moveOneLevel( fragmentStart, d_False );
                    if ( BdbcSuccess == result && USE_CACHE ) { // insert entry into the cache
                        char nodePath[256];
                        nodePathL += fragmentLength;
                        strncpy(nodePath, thePath, nodePathL);
                        nodePath[nodePathL] = '\0';
                        BdbRef(BdbObj) r = (BdbRef(BdbObj)) theNode.persistent();
                        //cout << "TNCACHE: inserting \"" << nodePath
                        //     << "\", oid = " << r.sprint() << endl;
                        _tnCache->insertEntry(nodePath, r);
                    }
                }
            }
        }
        if ( BdbcSuccess == result ) {
            *this = theNode;
        }
    }
    return result;
}


/**
 **  The function sets "theNode" to the farthest cached node.
 **  It also sets fragmentStart, to the first character after 
 **  the part of the path corresponding to cached node.
 **  If no cached node is found, the function returns an error, 
 **  and "theNode"/startAfterCached are not altered.
 **  Successful return and startAfterCached == 0 means
 **  that an exact match was found.
 **/
BdbStatus
BdbTreeNode::findBestCachedNode(const char* thePath, 
                                BdbTreeNode& theNode, 
                                const char*& startAfterCached)
{
    char theFragment[256];
    strcpy(theFragment, thePath);
    char* fragmentEnd   = theFragment;
    BdbRef(BdbObj) r;

    if ( BdbcSuccess == _tnCache->findEntry(thePath, r) ) {
        startAfterCached = 0;
        BdbRef(BdbTreeNodeP) tnR = (BdbRef(BdbTreeNodeP)) r;
        BdbHandle(BdbTreeNodeP) tnH = tnR;
        theNode.setPersistent(tnH);
        COUT2 << "Used cached intermediate node " << thePath << endl;
        return BdbcSuccess; // exact match
    }
    
    while ( NULL != ( fragmentEnd = strrchr(theFragment, BdbPathName::separator()) ) ) {
        *fragmentEnd = '\0';
        if ( 0 == strlen(theFragment) ) {
            break;
        }
        if ( BdbcSuccess == _tnCache->findEntry(theFragment, r) ) {
            startAfterCached = thePath + strlen(theFragment) +1;
            //cout << "found tn for " << theFragment 
            //     << ", startAfterCached = " << startAfterCached << endl;
            BdbRef(BdbTreeNodeP) tnR = (BdbRef(BdbTreeNodeP)) r;
            BdbHandle(BdbTreeNodeP) tnH = tnR;
            theNode.setPersistent(tnH);
            COUT2 << "Used cached intermediate node " << thePath << endl;
            return BdbcSuccess;
        }
    }

    return BdbcError;
}


BdbStatus 
BdbTreeNode::moveUp( )
// Move up to the parent node.
{
    BdbHandle(BdbTreeNodeP) theParentP;
    BdbStatus result = persistent( )->parent( theParentP );
    setPersistent( theParentP );
    return result;
}

BdbStatus 
BdbTreeNode::moveToRoot( const char* const theRootName )
// Move to the root node with the specified name. The default is "main".
{
    BdbHandle(BdbPersObj) theObj; 
    BdbHandle(BdbTreeNodeP) theRootP; 
    const char* theSysName = lowerRootName( theRootName );
    BdbStatus result = theObj.lookupObj( BdbApplicationOrDomain::activeInstance()->fd(), theSysName, BdbcRead );
    if ( BdbcSuccess == result ) {

        if ( ! BdbTreeNodeP::isTreeNode( theObj ) ) {
            BdbSignal( BdbcUserError, BdbTreesErrRootTreeNodeWrongType, 0, 
                       "BdbTreeNode::root", theRootName );
            result = BdbcError;
        } else {
            theRootP = (BdbHandle(BdbTreeNodeP)&)theObj;
        }
        setPersistent( theRootP );
    }
    return result;
}

BdbStatus
BdbTreeNode::moveToRootChild( const char* const theChildName, 
                              const char* const theRootName )
// Locate the tree node having the specified name as a child of the named root 
// tree node. This is a convenience function. The default root is "main".
{
    BdbStatus result = moveToRoot( theRootName);
    if ( BdbcSuccess == result ) {
        result = moveTo( theChildName );
    }
    return result;
}

BdbStatus 
BdbTreeNode::makeTo( const char* const thePath, d_Boolean createIntermediate )
// Move this transient tree node to reference the persistent tree node
// that corresponds to the specified path. This obeys Unix file syntax.
// An absolute path begins with the "/" character. A relative path omits
// the leading "/" character. Moving up the tree is denoted by "../".
// The "createIntermediate" flag determines whether any intermediate nodes
// are created if required, or only the final destination node.
{
    BdbTreeNode theNode;
    BdbHandle(BdbTreeNodeP) theNodeP;
    char        theFragment[256];
    const char* fragmentStart = thePath;
    const char* fragmentEnd   = thePath;
    size_t      fragmentLength;
    BdbStatus   result = BdbcSuccess;

    if ( NULL != thePath ) {
        if ( ! isNull( ) ) {
            theNode = *this;
            setNull( );
        }
        result = BdbcError;
        if ( BdbPathName::separator() == *thePath ) {

            // Absolute path - Look to see whether the new path is
            // identical to this one
            if ( ! theNode.isNull( ) && ( 0 == strcmp( thePath, theNode.fullName( ) ) ) ) {

                // It's identical - no movement or creation is necessary
                COUT1 << "BdbTreeNode::makeTo: Cached path" << endl;
                result = BdbcSuccess;
            } else {

                // It's not identical - Locate & create if necessary the
                // root tree-node.
                theNode.makeRoot( );
                fragmentStart++;
            }
        }
        if ( BdbcSuccess != result ) {

            // Traverse and create the path
            result = BdbcSuccess;
            while ( ( BdbcSuccess == result ) && 
                    ( NULL != ( fragmentEnd = strchr( fragmentStart, BdbPathName::separator() ) ) ) ) {
                fragmentLength = fragmentEnd - fragmentStart;
                if ( 0 < fragmentLength ) {
                    strncpy( theFragment, fragmentStart, fragmentLength );
                    theFragment[fragmentLength] = '\0';
                    result = theNode.moveOneLevel( theFragment, createIntermediate );
               }
                fragmentStart = fragmentEnd + 1;
            }
            if ( BdbcSuccess == result ) {

                // Deal with last fragment
                fragmentLength = strlen( fragmentStart );
                if ( 0 < fragmentLength ) {
                    result = theNode.moveOneLevel( fragmentStart, d_True );
                }
            }
        }
        if ( BdbcSuccess == result ) {
            *this = theNode;
        }
    }
    return result;
}

BdbStatus 
BdbTreeNode::makeRoot( const char* const theRootName, 
                       const char* const placementContName )
// Locate & create if necessary the root tree node with the specified
// name. The default is "main".
{
    BdbStatus result = BdbcSuccess;
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );

    result = moveToRoot( theRootName );
    if ( BdbcSuccess != result ) {

        // Root tree node doesn't already exist. Close the current transaction
        // and start a new one to try to get sole access to the root container.
        theApp->commit("makeRoot") ;
        theApp->startUpdate("makeRoot") ;

        BdbHandle(BdbDBObj) dbH;
        BdbDbAccessMgr dbAccessMgr;
        dbAccessMgr.openManagementDb( dbH, BdbcUpdate );

        BdbContAccessMgr contAccessMgr;
        BdbHandle(BdbContObj) contH;
        result = contAccessMgr.createContainer(dbH, contH, 
                                               placementContName, 1, 10, 10);
        if ( BdbcSuccess == result ) {

            // Now have guaranteed sole access to the root node container.
            // Check that the root node hasn't been created by someone else
            if ( BdbcSuccess != moveToRoot( theRootName ) ) {
                BdbHandle(BdbTreeNodeP) theRootP;
                theRootP = new(contH) BdbTreeNodeP( theRootName );
                if ( ! BdbIsNull( theRootP ) ) {
                    const char* theSysName = lowerRootName( theRootName );
                    BdbHandle(BdbFDObj) theFD = BdbApplicationOrDomain::activeInstance()->fd( );
                    result = theRootP.nameObj( theFD, theSysName );
                    if ( BdbcSuccess == result ) {
                        setPersistent( theRootP );
                    } else {
                        BdbSignal( BdbcUserError, BdbTreesErrUnableToNameRootTreeNode, 0, 
                                   "BdbTreeNode::makeRoot", theRootName );
                    }
                } else {
                    BdbSignal( BdbcUserError, BdbTreesErrUnableToCreateRootTreeNode, 0, 
                               "BdbTreeNode::makeRoot", theRootName );
                    result = BdbcError;
                }
            }
        }
        theApp->commit("makeRoot") ;
        theApp->startUpdate("makeRoot") ;
    }
    if ( BdbcSuccess != result ) {
        result = moveToRoot( theRootName );
    }
    return result;
}
    
BdbStatus
BdbTreeNode::makeRootChild( const char* const theChildName,
                            const char* const theRootName )
// Locate and create if necessary the tree node having the specified name as a
// child of the named root tree node. This is a convenience function. The
// default root is "main".
{
    BdbStatus result = makeRoot( theRootName);
    if ( BdbcSuccess == result ) {
        result = makeTo( theChildName );
    }
    return result;
}

BdbStatus
BdbTreeNode::makeRootChild( const char* const theName,
                           const char* const theRootName,
                           BdbHandleAny& placement )
{
    BdbStatus result = moveToRoot(theRootName) ;
    if ( result != BdbcSuccess ) {
        return BdbSignal(BdbcUserError, BdbTreesErrFunctionFailed, 0, "BdbTreeNode::makeRootChild", "in moveToRoot") ;
    }

    const char* useName = theName;

    // Deal with <user> as special (replaced by real user name
    if ( 0 == strcmp( useName, "<user>" ) ) {
         useName = BdbDomain::userName( );
    }
    BdbHandle(BdbTreeNodeP) theParentP = persistent( );
    result = child( *this, useName );
    if ( BdbcSuccess != result) {

        // Child doesn't exist - create it
        BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
        result = theApp->updateAndWait( placement, "BdbTreeNode" );
        if ( BdbcSuccess == result ) {
            BdbHandle(BdbTreeNodeP) theNodeP;
            theNodeP = new(placement) BdbTreeNodeP( theParentP, useName );
            if ( ! BdbIsNull( theNodeP ) ) {
                setPersistent( theNodeP );
                result = theParentP->replace( theNodeP, useName );
            }
        } else {
            BdbSignal( BdbcUserError, BdbTreesErrUpdateFailed, 0, 
                       "BdbTreeNode::makeRootChild" );
        }
    }
    return result;
}

BdbStatus 
BdbTreeNode::fetchMetaData( BdbMetaData& theData )
{
    BdbHandle(BdbMetaDataP) theDataP;
    BdbStatus result = updateAndWait( );
    if (BdbcSuccess == result ) {
        result = persistent( )->fetchMetaData( theDataP );
        if ( BdbcSuccess == result ) {
            theData.setPersistent( theDataP );
        }
    }
    return result;
}

BdbStatus 
BdbTreeNode::metaData( BdbMetaData& theData ) const
{
    BdbHandle(BdbMetaDataP) theDataP;
    BdbStatus result = persistent( )->metaData( theDataP );
    theData.setPersistent( theDataP );
    return result;
}

BdbHandle(BdbTreeNodeP) 
BdbTreeNode::persistent( ) const
{
    BdbHandle(BdbTreeNodeP) h = (BdbHandle(BdbTreeNodeP)&) object( );
    
    assert( ! BdbIsNull( h ) );

    if ( BdbcSuccess != h.open(oocRead) ) {
        BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance();
        d_Long oldWait = theApp->lockWait( );
        d_ULong lw = (oldWait<300 ? 300 : oldWait); // wait up to 5 min
        ErrMsg( warning ) << "Problems with opening " << h.sprint() 
                          << " for reading, retrying once"
                          << " (lockWait = " << lw << " sec)" << endmsg;
        theApp->setLockWait(lw);
        if ( BdbcSuccess != h.open(oocRead) ) {
            ErrMsg( fatal ) << "Unable to lock " << h.sprint() 
                            << " for reading, fd "
                            << theApp->fd().sprint() << endmsg;
        }
        theApp->setLockWait( oldWait );
    }
    ooRef(ooObj) r = h;
    _tnLock->add(r);

    return h;
}

//-------------
// Operators --
//-------------

BdbTreeNode& 
BdbTreeNode::operator=( const BdbTreeNode& theOther )
{
    BdbHandleAny theObj = theOther.object( );
    setObject( theObj );
    return *this;
}

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

const char* 
BdbTreeNode::lowerRootName( const char* const theRootName )
// Return the root name in lower case.
{
    static BdbTString theSysName;
    char lowerName[256];
    size_t len = strlen( theRootName );
    for ( size_t i = 0; i < len; i++ ) {
        lowerName[i] = tolower( theRootName[i] );
    }
    lowerName[len] = '\0';
    theSysName     = "BdbTreeNodeP::";
    theSysName    += lowerName;
    return theSysName.data( );
}

BdbStatus
BdbTreeNode::moveOneLevel( const char* const theName,
                           d_Boolean createIfNeeded )
{
    BdbTreeNode theNode;
    BdbStatus result = BdbcError;
    const char* useName = theName;

    if ( 0 == strcmp( useName, ".." ) ) {

        // Move up to parent
        result = parent( theNode );
    } else {

        // Deal with <user> as special (replaced by real user name)
         if ( 0 == strcmp( useName, "<user>" ) ) {
             useName = BdbDomain::userName( );
        }

        // Test whether the child node already exists
        result = child( theNode, useName );
        if ( ( BdbcSuccess != result ) && createIfNeeded ) {

            // The child node doesn't exist - Check whether the name is used
            if ( ! hasChild( useName ) ) {

                BdbHandleAny theHint = BdbTreeNodeP::clustering.updatedHint( );
                if( theHint.isNull() ) {
                   return( BdbcError );
                }
 
                // Make sure that we have update locks on both the
                // placement and parent node.
                BdbHandle(BdbTreeNodeP) parentHandle( persistent() );
                if ( BdbcSuccess != parentHandle.update() ) {
                   return( BdbcError );
                }

                if ( BdbcSuccess != theHint.update() ) {
                   return( BdbcError );
                }

                // Now that we have an update lock on the tree node,
                // check again that the requested child doesn't exist in
                // case someone else got there while we were waiting for
                // the lock.
                result = child( theNode, useName );
                if ( BdbcSuccess != result ) {

                   // Child still doesn't exist - create it and add it
                   // to the node
                   BdbHandle(BdbTreeNodeP) theNodeP;
                   theNodeP = new(theHint) BdbTreeNodeP( parentHandle,
                                                         useName );
                   if( theNodeP.isNull() ) {
                      return( BdbcError );
                   }

                   theNode.setPersistent( theNodeP );
                   result = parentHandle->replace( theNodeP, useName );
                }
            }
        }
    }
    if ( BdbcSuccess == result ) {
        *this = theNode;
    }
    return result;
}

void
BdbTreeNode::setPersistent( BdbHandle(BdbTreeNodeP)& aNode )
{
    setObject( aNode );
}

BdbStatus
BdbTreeNode::updateAndWait( )
// Lock the node for sole access. In order to avoid deadlocks
// do not wait indefinitely for the lock, but try for up to a default
// timeout period.
{
    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance( );
    BdbHandle(BdbTreeNodeP) theNodeP = persistent( );
    BdbStatus result = theApp->updateAndWait( theNodeP, "update" );
    if ( BdbcSuccess != result ) {
        BdbSignal( BdbcUserError, BdbTreesErrTreeUnableToUpdate, 0, 
                   "BdbTreeNode::updateAndWait", name( ) );
    }
    return result;
}


void 
BdbTreeNode::startRecordingRLocks()
{
    _tnLock->startRecording();
}


void
BdbTreeNode::dropRecordedRLocks()
{
    _tnLock->stopRecordingAndUnlock();
}

 

---

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

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