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

                 

---

/BdbTrees/BdbTreeNodeP.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: BdbTreeNodeP.cc,v 1.32 2000/12/03 21:18:10 patton Exp $
//
// Description:
//  Class BdbTreeNodeP 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.
//
// 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/BdbTreeNodeP.hh"

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

//---------------
// C++ Headers --
//---------------
#include <iostream.h>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbTrees/BdbTreesErrors.hh"
#include "BdbTrees/BdbTreeNodeItemP.hh"
#include "BdbTrees/BdbMetaData.hh"
#include "BdbUtil/BdbTString.hh"

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

static const char rcsid[] = "$Id: BdbTreeNodeP.cc,v 1.32 2000/12/03 21:18:10 patton Exp $";

// Note that returnedName is file static since it has ownership of the
// returned character string for the name( ) and pathName( ) function members. 
// In principle it also should have function scope, but for some reason
// this causes problems with the Solaris optimizer, hence the use of
// file scope. Clients should be aware of this ownership
// since the return value might change between the call to this
// function and the usage of the return string if calls to 
// functions from other classes are made, where these operate on
// other BdbCollectionP instances. Not ideal...
static BdbTString returnedName;

//      -----------------------------------------------
//      -- Static Data & Function Member Definitions --
//      -----------------------------------------------

BdbHintInit(BdbTreeNodeP);

d_Boolean
BdbTreeNodeP::isTreeNode( BdbHandle(BdbPersObj)& theItem )
{
    d_Boolean result = d_False;
    ooId theID = theItem;
    if ( 0 != theID.get_OC( ) ) {
        ooTypeNumber theType = ooTypeN( BdbTreeNodeP );
        if ( ( theItem.typeN( ) == theType ) || theItem->ooIsKindOf( theType ) ) {
            result = d_True;
        }
    }
    return result;
}

d_Boolean
BdbTreeNodeP::isTreeNode( BdbRef(BdbPersObj)& theItem )
{
    d_Boolean result = d_False;
    if ( 0 != theItem.get_OC( ) ) {
        ooTypeNumber theType = ooTypeN( BdbTreeNodeP );
        if ( ( theItem.typeN( ) == theType ) || theItem->ooIsKindOf( theType ) ) {
            result = d_True;
        }
    }
    return result;
}

d_Boolean
BdbTreeNodeP::isValid( const char* const theName )
{
    d_Boolean result = d_False;
    if ( 0 != theName ) {
        const char* slash = strchr( theName, '/' );
        if ( 0 == slash ) {
            result = d_True;
        }
    }
    return result;
}

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

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

BdbTreeNodeP::~BdbTreeNodeP( )
{
    if ( ! BdbIsNull( _children ) ) {
        clear( );
        BdbDelete( _children );
    }
    if ( ! BdbIsNull( _metadata ) ) {
        BdbDelete( _metadata );
    }
}

//-------------
// Selectors --
//-------------
 
d_ULong 
BdbTreeNodeP::count( ) const
{
    return (d_ULong)_children->nElement( );
}

const char*
BdbTreeNodeP::pathName( ) const
{
    // Determine the format of the name. If it contains 
    // embedded "/" characters then it is the full name,
    // and can be directly returned. This is the new 
    // implementation. If it doesn't contain any "/" 
    // characters it is assumed to be the old implementation 
    // and the full name is optained by walking up the node
    // tree, prefixing their names to what is returned. This
    // old implementation has the bad side effect of putting
    // read locks on those nodes.
    const char* result = (const char*)_name;
    const char* theFragment = strrchr( result, '/' );
    if ( 0 == theFragment ) {

        // Old implementation
        BdbHandle(BdbTreeNodeP) theNode = ooThis( );
        BdbTString aFragment; 
        BdbTString theName = "/";
        while ( ! BdbIsNull( theNode ) ) {
            BdbHandle(BdbTreeNodeP) theParent;
            BdbStatus status = theNode->parent( theParent );
            if ( ! BdbIsNull( theParent ) ) {
                aFragment  = "/";
                aFragment += theNode->name( );
                aFragment += theName;
                theName    = aFragment;
             }
            theNode = theParent;
        }
        returnedName = theName;
    } else {

        // New implementation
        returnedName  = result;
        returnedName += "/";
    }
    result = returnedName.chars( );
    return result;
}

const char*
BdbTreeNodeP::fullName( ) const
{
    // Determine the format of the name. If it contains 
    // embedded "/" characters then it is the full name,
    // and can be directly returned. This is the new 
    // implementation. If it doesn't contain any "/" 
    // characters it is assumed to be the old implementation 
    // and the full name is optained by walking up the node
    // tree, prefixing their names to what is returned. This
    // old implementation has the bad side effect of putting
    // read locks on those nodes.
    const char* result = (const char*)_name;
    const char* theFragment = strrchr( result, '/' );
    if ( 0 == theFragment ) {

        // Old implementation
        BdbHandle(BdbTreeNodeP) theNode = ooThis( );
        BdbTString aFragment; 
        BdbTString theName = "";
        while ( ! BdbIsNull( theNode ) ) {
            BdbHandle(BdbTreeNodeP) theParent;
            BdbStatus status = theNode->parent( theParent );
            if ( ! BdbIsNull( theParent ) ) {
                aFragment  = "/";
                aFragment += theNode->name( );
                aFragment += theName;
                theName    = aFragment;
             }
            theNode = theParent;
        }
        returnedName = theName;
    } else {

        // New implementation
        returnedName = result;
    }
    result = returnedName.chars( );
    return result;
}

const char*
BdbTreeNodeP::name( ) const
{
    // Determine the format of the name. If it contains 
    // embedded "/" characters then it is the full name,
    // and only the last fragment should be returned as 
    // the node name. This is the new implementation. 
    // If it doesn't contain any "/" characters it is 
    // assumed to be the old implementation and is returned 
    // directly. The new implementation avoids walking up 
    // the node tree in fullName( ) and pathName( ), since this 
    // puts unnecessary read locks on those.
    const char* result = (const char*)_name;
    if ( 0 != result ) {
        const char* theFragment = strrchr( result, '/' );
        if ( 0 == theFragment ) {

            // Old implementation
            returnedName = result;
        } else {

            // New implementation - return the last fragment, but
            // ignoring the final trailing "/" character.
            theFragment++;
            returnedName = theFragment;
        }
        result = returnedName.chars( );
    }
    return result;
}

//-------------
// Modifiers --
//-------------

//--------------
// Operations --
//--------------
    
BdbStatus
BdbTreeNodeP::add( BdbHandle(BdbPersObj)& aChild, const char* const theName ) 
{
    BdbStatus result = BdbcError;

    if ( isValid( theName ) ) {
        if (! _children->isMember( theName ) ) {
            BdbHandle(BdbTreeNodeItemP) anItem;
            anItem = new ( ooThis( ) ) BdbTreeNodeItemP( aChild );
            result = _children->add( theName, anItem );
        }
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrNodeNameNotValid, 0, 
                   "BdbTreeNodeP::add", theName ); 
    }
    return result;
}

BdbStatus
BdbTreeNodeP::child( BdbHandle(BdbPersObj)& aChild, 
                     const char* const theName ) const
{
    BdbStatus result = BdbcError;
    ooTypeNumber theType;
    BdbHandle(BdbTreeNodeItemP) theItem;
    aChild = 0;
    if ( 0 != theName ) {
        _children->lookup( theName, theItem, BdbcRead );
        if ( ! BdbIsNull( theItem ) ) {
            result = theItem->item( aChild, theType );
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::child( BdbHandle(BdbPersObj)& aChild, 
                     const char* const theName,
                     ooTypeNumber theType ) const
{
    BdbStatus result = BdbcError;
    ooTypeNumber itemType;
    BdbHandle(BdbTreeNodeItemP) theItem;
    aChild = 0;
    if ( 0 != theName ) {
        _children->lookup( theName, theItem, BdbcRead );
        if ( ! BdbIsNull( theItem ) ) {
            result = theItem->item( aChild, itemType );
            if ( itemType != theType ) {
                aChild = 0;
                result = BdbcError;
            }
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::child( BdbHandle(BdbPersObj)& aChild, 
                     const char* const theName,
                    ooTypeNumber theTypes[], d_ULong numTypes ) const 
{
    BdbStatus result = BdbcError;
    ooTypeNumber itemType;
    BdbHandle(BdbTreeNodeItemP) theItem;
    BdbHandle(BdbPersObj) theChild;
    aChild = 0;
    if ( 0 != theName ) {
        _children->lookup( theName, theItem, BdbcRead );
        if ( ! BdbIsNull( theItem ) ) {
            theItem->item( theChild, itemType );
            d_ULong i = 0;
            while ( result != BdbcSuccess && i < numTypes ) {
                if ( itemType == theTypes[i] ) {
                    aChild = theChild;
                    result = BdbcSuccess;
                }
                i++;
            }
        }
    }
    return result;
}

d_Boolean
BdbTreeNodeP::childIsTreeNode( const char* const theName ) const
{
    d_Boolean result = d_False;
    BdbHandle(BdbTreeNodeItemP) theItem;
    if ( 0 != theName ) {
        _children->lookup( theName, theItem, BdbcRead );
        if ( ! BdbIsNull( theItem ) ) {
            result = theItem->isTreeNode( );
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::clear( )
{
    BdbStatus status;
    BdbRef(BdbTreeNodeItemP) theItem;
    ooHandle(BdbMap) theMap = _children;
    BdbStatus result = BdbcSuccess;

    while ( theMap->nElement( ) > 0 ) {
        ooMapItr childIter( theMap );
        status = childIter.next( );
        if ( BdbcSuccess == status ) {
            theItem  = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
            BdbDelete( theItem );
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::clearAndDestroy( )
{
    BdbStatus status;
    BdbRef(BdbTreeNodeItemP) theItem;
    BdbHandle(BdbPersObj) theChild;
    BdbHandle(BdbTreeNodeP) theNodeP;
    ooHandle(BdbMap) theMap = _children;
    BdbStatus result = BdbcSuccess;

    while ( theMap->nElement( ) > 0 ) {
        ooMapItr childIter( theMap );
        status = childIter.next( );
        if ( BdbcSuccess == status ) {
            theItem  = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
            theChild = theItem->item( );
            if ( theItem->isTreeNode( ) ) {
                theNodeP = (BdbHandle(BdbTreeNodeP)&)theChild;
                theNodeP->clearAndDestroy( );
            }
            BdbDelete( theItem  );
            BdbDelete( theChild );
        }
    }
    return result;
}

d_Boolean
BdbTreeNodeP::hasChild( const char* const theName ) const
{
    d_Boolean result = d_False;
    if ( 0 != theName ) {
        result = _children->isMember( theName );
    }
    return result;
}

d_Boolean
BdbTreeNodeP::hasChild( BdbHandle(BdbPersObj)& aChild, d_Boolean descend ) const 
{
    assert( ! BdbIsNull( aChild ) );
    BdbStatus result = BdbcError;
    BdbRef(BdbTreeNodeItemP) theItem;
    BdbHandle(BdbPersObj) theChild;
    BdbHandle(BdbTreeNodeP) theNode;
    BdbRef(ooMap) theMap = _children;

    ooMapItr childIter( theMap );
    while ( ( BdbcSuccess != result ) && childIter.next( ) ) {
        theItem = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
        theChild = theItem->item( );
        if ( theChild == aChild ) {
            result = BdbcSuccess;
        }
    }
    if ( ( BdbcSuccess != result ) && descend ) {
        ooMapItr nodeIter( theMap );
        while ( ( BdbcSuccess != result ) && nodeIter.next( ) ) {
            theItem = (const BdbRef(BdbTreeNodeItemP)&) nodeIter->oid( );
            if ( theItem->isTreeNode( ) ) {
                theChild = theItem->item( );
                theNode  = (BdbHandle(BdbTreeNodeP)&) theChild;
                result   = theNode->hasChild( aChild, descend );
            }
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::makeChild( BdbHandle(BdbTreeNodeP)& aNode, 
                         const char* const theName )
{
    BdbHandle(BdbTreeNodeItemP) anItem;
    BdbStatus result = item( anItem, theName );
    if ( BdbcSuccess == result ) {
        if ( anItem->isTreeNode( ) ) {
            aNode = (const BdbHandle(BdbTreeNodeP)&) anItem->item( );
        } else {
            aNode  = 0;
            result = BdbcError;
        }
    } else {
        BdbHandle(BdbTreeNodeP) self = ooThis( );
        BdbHandle(BdbTreeNodeP) aNodeP;
        BdbHandleAny theHint = BdbTreeNodeP::clustering.updatedHint( );
           aNodeP = new( theHint ) BdbTreeNodeP( self, theName );
        if ( ! BdbIsNull( aNodeP ) ) {
            result = add( aNodeP, theName );
        }
        aNode = aNodeP;
    }
    return result;
}

BdbStatus 
BdbTreeNodeP::parent( BdbHandle(BdbTreeNodeP)& theParent ) const
{
    BdbStatus result = BdbcSuccess;
    BdbRef(BdbTreeNodeP) aParent;
    aParent   = _parent;
    theParent = aParent;
    if ( BdbIsNull( aParent ) ) {
        result = BdbcError;
    }
    return result;
}

BdbStatus
BdbTreeNodeP::remove( const char* const theName ) 
{
    BdbHandle(BdbTreeNodeItemP) anItem;
    BdbStatus result = item( anItem, theName );
    if ( BdbcSuccess == result ) {
        BdbDelete( anItem );
    }
    return result;
}

BdbStatus
BdbTreeNodeP::remove( BdbHandle(BdbPersObj)& aChild ) 
{
    BdbStatus result = BdbcError;
    BdbStatus status = BdbcSuccess;
    BdbRef(BdbTreeNodeItemP) theItem;
    BdbHandle(BdbPersObj) theChild;

    ooMapItr childIter( _children );
    while ( BdbcSuccess == status ) {
        status = childIter.next( );
        if ( BdbcSuccess == status ) {
            theItem = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
            if ( theItem->item( ) == aChild ) {
                result = remove( childIter->name( ) );
                status = BdbcError;
            }
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::removeAndDestroy( const char* const theName ) 
{
    BdbHandle(BdbPersObj) theChild; 
    BdbHandle(BdbTreeNodeItemP) theItem; 
    BdbHandle(BdbTreeNodeP) theNodeP; 
    BdbStatus result = item( theItem, theName );
    if ( BdbcSuccess == result ) {
        theChild = theItem->item( );
        if ( theItem->isTreeNode( ) ) {
            theNodeP = (BdbHandle(BdbTreeNodeP)&)theChild;
            theNodeP->clearAndDestroy( );
        }
        BdbDelete( theItem  );
        BdbDelete( theChild );
    }
    return result;
}

BdbStatus
BdbTreeNodeP::removeAndDestroy( BdbHandle(BdbPersObj)& aChild ) 
{
    BdbRef(BdbTreeNodeItemP) theItem;
    BdbStatus result = BdbcError;
    BdbStatus status = BdbcSuccess;

    ooMapItr childIter( _children );
    while ( BdbcSuccess == status ) {
        status = childIter.next( );
        if ( BdbcSuccess == status ) {
            theItem = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
            if ( theItem->item( ) == aChild ) {
                result = removeAndDestroy( childIter->name( ) );
                status = BdbcError;
            }
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::replace( BdbHandle(BdbPersObj)& aChild, const char* const theName ) 
{
    BdbStatus result = remove( theName );
    result = add( aChild, theName );
    return result;
}

BdbStatus 
BdbTreeNodeP::root( BdbHandle(BdbTreeNodeP)& theRoot ) const
{
    BdbHandle(BdbTreeNodeP) theParent = ooThis( );
    BdbStatus status;
    while ( ! BdbIsNull( theParent ) ) {
        theRoot = theParent;
        status  = theRoot->parent( theParent );
    }
    return BdbcSuccess;
}

BdbStatus
BdbTreeNodeP::cloneChildren( BdbHandle(BdbTreeNodeP)& theOther )
{
    BdbStatus result = BdbcSuccess;
    BdbStatus status = BdbcSuccess;
    BdbRef(BdbMap) otherChildren = theOther->children( );
    ooMapItr childIter( otherChildren );
    BdbRef(BdbTreeNodeItemP) theItem;
    while ( BdbcSuccess == status ) {
        status = childIter.next( );
        if ( BdbcSuccess == status ) {
            theItem = (const BdbRef(BdbTreeNodeItemP)&) childIter->oid( );
            BdbHandleAny newItemP = theItem->item( );
            if ( newItemP.isValid( ) ) {
                BdbHandle(BdbTreeNodeItemP) newItem;
                newItem = new( ooThis( ) ) BdbTreeNodeItemP( newItemP );
                status = _children->add( childIter->name( ), newItem );
                if ( theItem->isTreeNode( ) ) {
                    BdbHandle(BdbTreeNodeP) newNodeP = (BdbHandle(BdbTreeNodeP)&) newItemP;
                    static BdbHandle( BdbTreeNodeP ) tmp ;
                    status = newNodeP->setParent( ooThis( tmp ), newNodeP->name( ) );
                }
            } else {
                BdbSignal( BdbcUserError, BdbTreesErrItemNotValid, 0, 
                           "BdbTreeNodeP::cloneChildren" ); 
            }
        }
    }

    // Now clone any metadata associated with this node
    BdbHandle(BdbMetaDataP) otherData;
    status = theOther->metaData( otherData );
    if ( ! BdbIsNull(otherData) ) {
        BdbHandle(BdbMetaDataP) theData;
        status = fetchMetaData( theData );
        if ( BdbcSuccess == status ) {
            status = theData->clone( otherData );
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::upgradeName( )
{
    // Upgrade the tree node name to the new format (full path name)
    // if necessary
    BdbStatus result = BdbcError;
    const char* theName = (const char*)_name;
    const char* theFragment = strrchr( theName, '/' );
    if ( 0 == theFragment ) {

        // Old format - upgrade to new format
        ooUpdate( );
        theName = fullName( );
        _name   = theName;
        result  = BdbcSuccess;
    }
    return result;
}

//              ------------------------
//              --MetaData Operations --
//              ------------------------

BdbStatus 
BdbTreeNodeP::fetchMetaData( BdbHandle(BdbMetaDataP)& theData )
{
    BdbHandle(BdbTreeNodeP) self = ooThis( );
    BdbHandle(BdbMetaDataP) theDataP = _metadata;
    BdbStatus result = BdbcSuccess;
    if ( BdbIsNull( theDataP ) ) {
        theDataP = new (self) BdbMetaDataP( self, name( ) );
        if ( ! BdbIsNull( theDataP ) ) {
            _metadata = theDataP;
        } else {
            result = BdbcError;
        }
    }
    theData = theDataP;
    return result;
}

BdbStatus 
BdbTreeNodeP::metaData( BdbHandle(BdbMetaDataP)& theData ) const
{
    theData = _metadata;
    return BdbcSuccess;
}

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

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

BdbTreeNodeP::BdbTreeNodeP( const char* const theName )
{
    initialize( theName );
}

BdbTreeNodeP::BdbTreeNodeP( BdbHandle(BdbTreeNodeP)& theParent, 
                            const char* const theName )
{
    _parent = theParent;
    initialize( theName );
    setParent( theParent, theName );
}

BdbStatus
BdbTreeNodeP::item( BdbHandle(BdbTreeNodeItemP)& anItem, 
                    const char* const theName ) const
{
    BdbStatus result = BdbcError;
    if ( 0 != theName ) {
        _children->lookup( theName, anItem, BdbcRead );
        if ( ! BdbIsNull( anItem ) ) {
            result = BdbcSuccess;
        }
    }
    return result;
}

BdbStatus
BdbTreeNodeP::setParent( BdbHandle(BdbTreeNodeP)& theParent, 
                         const char* const theName )
{
    BdbStatus result = BdbcError;
    if ( isValid( theName ) ) {
        ooUpdate( );
        _name   = theName;
        _parent = theParent;

        // Disable the conversion to the full name until after the
        // migration has been adopted. The following code needs to be
        // uncommented at that point.
        //// const char* newName = fullName( );
        //// _name = newName;
        result = BdbcSuccess;
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrNodeNameNotValid, 0, 
                   "BdbTreeNodeP::setParent", theName ); 
    }
    return result;
}

BdbRef(BdbMap) 
BdbTreeNodeP::children( ) const
{
    return _children;
}

void
BdbTreeNodeP::initialize( const char* const theName )
{
    _name = theName;
    BdbHandle(BdbMap) theMap;
    theMap = new( ooThis( ) ) BdbMap;
    if ( ! BdbIsNull( theMap ) ) {
        _children = theMap;
    } else {
        BdbSignal( BdbcUserError, BdbTreesErrTreeNotInitialized, 0, 
                   "BdbTreeNodeP::initialize", theName ); 
    }
}

 

---

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

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