misc-template.c

Go to the documentation of this file.

/* LIBDGL -- a Directed Graph Library implementation
 * Copyright (C) 2002 Roberto Micarelli
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * best view with tabstop=4
 */

/*
 * Edge Traversing
 */
int DGL_EDGE_T_INITIALIZE_FUNC( dglGraph_s * pGraph , dglEdgeTraverser_s * pT , dglEdgePrioritizer_s * pEP ) {
#if defined(_DGL_V1)
        pGraph->iErrno = DGL_ERR_NotSupported;
        return -pGraph->iErrno;
#else
        if ( pGraph->Flags & DGL_GS_FLAT ) {
                if ( pEP && pEP->pvAVL ) {
                        if ( (pT->pvAVLT = malloc( sizeof(struct avl_traverser) )) == NULL ) {
                                pGraph->iErrno = DGL_ERR_MemoryExhausted;
                                return -pGraph->iErrno;
                        }
                        avl_t_init( pT->pvAVLT , pEP->pvAVL );
                        pT->pnEdge = NULL;
                        pT->pEdgePrioritizer = pEP;
                }
                else {
                        pT->pvAVLT = NULL;
                        pT->pnEdge = NULL;
                        pT->pEdgePrioritizer = NULL;
                }
        }
        else {
                if ( (pT->pvAVLT = malloc( sizeof(struct avl_traverser) )) == NULL ) {
                        pGraph->iErrno = DGL_ERR_MemoryExhausted;
                        return -pGraph->iErrno;
                }
                if ( pEP && pEP->pvAVL ) {
                        avl_t_init( pT->pvAVLT , pEP->pvAVL );
                        pT->pnEdge = NULL;
                        pT->pEdgePrioritizer = pEP;
                }
                else {
                        avl_t_init( pT->pvAVLT , pGraph->pEdgeTree );
                        pT->pnEdge = NULL;
                        pT->pEdgePrioritizer = NULL;
                }
        }
        pT->pGraph = pGraph;
        return 0;
#endif
}

void DGL_EDGE_T_RELEASE_FUNC( dglEdgeTraverser_s * pT ) {
#if defined(_DGL_V1)
        pT->pGraph->iErrno = DGL_ERR_NotSupported;
#else
        if ( pT->pvAVLT ) free( pT->pvAVLT );
        pT->pvAVLT = NULL;
        pT->pnEdge = NULL;
        pT->pEdgePrioritizer = NULL;
#endif
}

dglInt32_t * DGL_EDGE_T_FIRST_FUNC( dglEdgeTraverser_s * pT ) {
#if defined(_DGL_V1)
        pT->pGraph->iErrno = DGL_ERR_NotSupported;
        return NULL;
#else
        dglGraph_s * pG = pT->pGraph;

        pT->pnEdge = NULL;
        if ( pT->pvAVLT && pT->pEdgePrioritizer ) {
                dglEdgePrioritizer_s * pPri = pT->pEdgePrioritizer;
                dglTreeEdgePri32_s * pItem;

                pItem = avl_t_first( pT->pvAVLT, pPri->pvAVL );
                if ( pItem ) {
/*
printf("edge_t_first: cEdge=%ld\n", pItem->cnData);
*/
                        pPri->cEdge = pItem->cnData;
                        pPri->iEdge = 0;
                        if ( pPri->iEdge < pPri->cEdge ) {
                                pT->pnEdge = DGL_GET_EDGE_FUNC(pG, pItem->pnData[pPri->iEdge]);
                                pPri->iEdge++;
                        }
                }
                pPri->pEdgePri32Item = pItem;
        }
        else if ( pT->pvAVLT ) {
                dglTreeEdge_s * pEdgeItem;

                if ( (pEdgeItem = avl_t_first( pT->pvAVLT, pG->pEdgeTree )) == NULL ) {
                        pT->pnEdge = NULL;
                }
                else {
                        pT->pnEdge = pEdgeItem->pv;
                }
        }
        else {
                if ( pG->cEdge > 0 ) pT->pnEdge = (dglInt32_t*)pG->pEdgeBuffer;
                else pT->pnEdge = NULL;
        }
        return pT->pnEdge;
#endif
}

dglInt32_t * DGL_EDGE_T_NEXT_FUNC( dglEdgeTraverser_s * pT )
{
#if defined(_DGL_V1)
        pT->pGraph->iErrno = DGL_ERR_NotSupported;
        return NULL;
#else
        dglGraph_s * pG = pT->pGraph;

        pT->pnEdge = NULL;

        if ( pT->pvAVLT && pT->pEdgePrioritizer ) {
                dglEdgePrioritizer_s * pPri = pT->pEdgePrioritizer;
                dglTreeEdgePri32_s * pItem = pPri->pEdgePri32Item;

                if (pItem && pPri->iEdge < pPri->cEdge) {
                        pT->pnEdge = DGL_GET_EDGE_FUNC(pG, pItem->pnData[pPri->iEdge]);
                        pPri->iEdge++;
                }
                else {
                        if ( (pItem = avl_t_next(pT->pvAVLT)) != NULL ) {
                                pPri->cEdge = pItem->cnData;
                                pPri->iEdge = 0;
                                if ( pPri->iEdge < pPri->cEdge ) {
                                        pT->pnEdge = DGL_GET_EDGE_FUNC(pG, pItem->pnData[pPri->iEdge]);
                                        pPri->iEdge++;
                                }
                        }
                        pPri->pEdgePri32Item = pItem;
                }
        }
        else if ( pT->pvAVLT ) {
                dglTreeEdge_s * pItem;

                if ( (pItem = avl_t_next( pT->pvAVLT )) != NULL ) {
                        pT->pnEdge = pItem->pv;
                }
        }
        else {
                pT->pnEdge += DGL_NODE_WSIZE( pG->EdgeAttrSize);
                if (pT->pnEdge >= (dglInt32_t*)(pG->pEdgeBuffer + pG->iEdgeBuffer) ) {
                        pT->pnEdge = NULL;
                }
        }
        return pT->pnEdge;
#endif
}


/*
 * Node Traversing
 */
int DGL_NODE_T_INITIALIZE_FUNC( dglGraph_s * pGraph , dglNodeTraverser_s * pT ) {
        if ( pGraph->Flags & DGL_GS_FLAT ) {
                pT->pnNode = NULL;
                pT->pvAVLT = NULL;
        }
        else {
                if ( (pT->pvAVLT = malloc( sizeof(struct avl_traverser) )) == NULL ) {
                        pGraph->iErrno = DGL_ERR_MemoryExhausted;
                        return -pGraph->iErrno;
                }
                avl_t_init( pT->pvAVLT , pGraph->pNodeTree );
                pT->pnNode = NULL;
        }
        pT->pGraph = pGraph;
        return 0;
}

void DGL_NODE_T_RELEASE_FUNC( dglNodeTraverser_s * pT ) {
        if ( pT->pvAVLT ) free( pT->pvAVLT );
        pT->pvAVLT = NULL;
        pT->pnNode = NULL;
}

dglInt32_t * DGL_NODE_T_FIRST_FUNC( dglNodeTraverser_s * pT )
{
        DGL_T_NODEITEM_TYPE * pNodeItem;

        if ( pT->pvAVLT ) {
                if ( (pNodeItem = avl_t_first( pT->pvAVLT, pT->pGraph->pNodeTree )) == NULL )
                        pT->pnNode = NULL;
                else
                        pT->pnNode = DGL_T_NODEITEM_NodePTR(pNodeItem);
        }
        else {
                if ( pT->pGraph->cNode > 0 ) pT->pnNode = (dglInt32_t*)pT->pGraph->pNodeBuffer;
                else pT->pnNode = NULL;
        }
        return pT->pnNode;
}

dglInt32_t * DGL_NODE_T_NEXT_FUNC( dglNodeTraverser_s * pT )
{
        DGL_T_NODEITEM_TYPE * pNodeItem;

        if ( pT->pvAVLT ) {
                if ( (pNodeItem = avl_t_next( pT->pvAVLT )) == NULL )
                        pT->pnNode = NULL;
                else
                        pT->pnNode = DGL_T_NODEITEM_NodePTR(pNodeItem);
        }
        else {
                pT->pnNode += DGL_NODE_WSIZE( pT->pGraph->NodeAttrSize );
                if ( pT->pnNode >= (dglInt32_t*)(pT->pGraph->pNodeBuffer + pT->pGraph->iNodeBuffer) ) pT->pnNode = NULL;
        }
        return pT->pnNode;
}

dglInt32_t * DGL_NODE_T_FIND_FUNC( dglNodeTraverser_s * pT , dglInt32_t nNodeId )
{
        DGL_T_NODEITEM_TYPE * pNodeItem , findItem;

        if ( pT->pvAVLT ) {
                findItem.nKey = nNodeId;
                if ( (pNodeItem = avl_t_find( pT->pvAVLT , pT->pGraph->pNodeTree , &findItem )) == NULL )
                        pT->pnNode = NULL;
                else
                        pT->pnNode = DGL_T_NODEITEM_NodePTR(pNodeItem);
        }
        else {
                pT->pnNode = DGL_GET_NODE_FUNC(pT->pGraph, nNodeId);
        }
        return pT->pnNode;
}


/*
 * Edgeset Traversing
 */
int     DGL_EDGESET_T_INITIALIZE_FUNC(
                        dglGraph_s * pGraph ,
                        dglEdgesetTraverser_s * pT ,
                        dglInt32_t * pnEdgeset
                        )
{
        pT->pGraph = pGraph;
        pT->pnEdgeset = pnEdgeset;
        pT->cEdge = (pnEdgeset)?*pnEdgeset:0;
        pT->iEdge = 0;
        return 0;
}


void DGL_EDGESET_T_RELEASE_FUNC( dglEdgesetTraverser_s * pT )
{
}

dglInt32_t * DGL_EDGESET_T_FIRST_FUNC( dglEdgesetTraverser_s * pT )
{
#if defined(_DGL_V2)
        dglInt32_t * pnOffset;
        dglTreeEdge_s * pEdgeItem, EdgeItem;
#endif

        if ( pT->cEdge == 0 ) return NULL;
        pT->iEdge = 1;
#if defined(_DGL_V1)
        return pT->pnEdgeset + 1;
#endif
#if defined(_DGL_V2)
        pnOffset = pT->pnEdgeset + 1;   
        if ( pT->pGraph->Flags & DGL_GS_FLAT ) {
                pT->pvCurrentItem = NULL;
                return DGL_EDGEBUFFER_SHIFT(pT->pGraph, *pnOffset);
        }
        else {
                EdgeItem.nKey = *pnOffset;
                if ( (pEdgeItem = avl_find( pT->pGraph->pEdgeTree, &EdgeItem )) != NULL) {
                        pT->pvCurrentItem = pEdgeItem;
                        return pEdgeItem->pv;
                }
        }
#endif
        return NULL;
}


dglInt32_t * DGL_EDGESET_T_NEXT_FUNC( dglEdgesetTraverser_s * pT )
{
#if defined(_DGL_V2)
        dglInt32_t * pnOffset;
        dglTreeEdge_s * pEdgeItem, EdgeItem;
#endif

        if ( pT->cEdge > 0 && pT->iEdge < pT->cEdge ) {
#if defined(_DGL_V1)
                return DGL_EDGESET_EDGE_PTR(pT->pnEdgeset, pT->iEdge++, pT->pGraph->EdgeAttrSize);
#endif
#if defined(_DGL_V2)
                pnOffset = pT->pnEdgeset + 1 + pT->iEdge++;     
                if ( pT->pGraph->Flags & DGL_GS_FLAT ) {
                        return DGL_EDGEBUFFER_SHIFT(pT->pGraph, *pnOffset);
                }
                else {
                        EdgeItem.nKey = *pnOffset;
                        if ( (pEdgeItem = avl_find( pT->pGraph->pEdgeTree, &EdgeItem )) != NULL) {
                                pT->pvCurrentItem = pEdgeItem;
                                return pEdgeItem->pv;
                        }
                }
#endif
        }
        return NULL;
}


/*
 * Flatten the graph
 */
int DGL_FLATTEN_FUNC( dglGraph_s * pgraph )
{
        register DGL_T_NODEITEM_TYPE * ptreenode;
#if defined(_DGL_V2)
        register dglTreeEdge_s * ptreeEdge;
        int i;
#endif
        register dglInt32_t *   pEdge;
        register dglInt32_t *   pnode;
        register dglInt32_t *   pnodescan;
        dglInt32_t *                            pOutEdgeset;
        dglInt32_t *                            pInEdgeset;
        int                                     cOutEdgeset;
        int                                     cInEdgeset;

        struct avl_traverser    avlTraverser;

        if ( pgraph->Flags & DGL_GS_FLAT )
        {
                pgraph->iErrno = DGL_ERR_BadOnFlatGraph;
                return -pgraph->iErrno;
        }

        pgraph->pNodeBuffer = NULL; /* should be already */
        pgraph->iNodeBuffer = 0;
        pgraph->pEdgeBuffer = NULL;
        pgraph->iEdgeBuffer = 0;


#if defined(_DGL_V2)
/*
printf("flatten: traversing edges\n");
*/
        avl_t_init( & avlTraverser, pgraph->pEdgeTree );

        for     (
                        ptreeEdge = avl_t_first( & avlTraverser , pgraph->pEdgeTree ) ;
                        ptreeEdge ;
                        ptreeEdge = avl_t_next( & avlTraverser )
                )
        {
                pEdge = ptreeEdge->pv;

/*
printf( "flatten: add edge %ld to edge buffer\n", DGL_EDGE_ID(pEdge) );
*/

                pgraph->pEdgeBuffer = realloc(
                                pgraph->pEdgeBuffer , 
                                pgraph->iEdgeBuffer + DGL_EDGE_SIZEOF(pgraph->EdgeAttrSize)
                                );

                if ( pgraph->pEdgeBuffer == NULL ) {
                        pgraph->iErrno = DGL_ERR_MemoryExhausted;
                        return -pgraph->iErrno;
                }

                memcpy( pgraph->pEdgeBuffer + pgraph->iEdgeBuffer, pEdge, DGL_EDGE_SIZEOF(pgraph->EdgeAttrSize) );

                pgraph->iEdgeBuffer += DGL_EDGE_SIZEOF(pgraph->EdgeAttrSize);
        }
#endif

/*
printf("flatten: traversing nodes\n");
*/
        avl_t_init( & avlTraverser, pgraph->pNodeTree );

        for     (
                        ptreenode = avl_t_first( & avlTraverser , pgraph->pNodeTree ) ;
                        ptreenode ;
                        ptreenode = avl_t_next( & avlTraverser )
                )
        {
                pnode       = DGL_T_NODEITEM_NodePTR(ptreenode);
                pOutEdgeset = DGL_T_NODEITEM_OutEdgesetPTR(ptreenode);
                pInEdgeset  = DGL_T_NODEITEM_InEdgesetPTR(ptreenode);

                if ( !(DGL_NODE_STATUS(pnode) & DGL_NS_ALONE) )
                {
                        cOutEdgeset = (pOutEdgeset) ?
                                        DGL_EDGESET_SIZEOF(DGL_EDGESET_EDGECOUNT(pOutEdgeset), pgraph->EdgeAttrSize) :
                                        sizeof(dglInt32_t);

#if !defined(_DGL_V1)
                        cInEdgeset = (pInEdgeset) ?
                                        DGL_EDGESET_SIZEOF(DGL_EDGESET_EDGECOUNT(pInEdgeset),  pgraph->EdgeAttrSize) :
                                        sizeof(dglInt32_t);
#else
                        cInEdgeset = 0;
#endif

                        pgraph->pEdgeBuffer = realloc( pgraph->pEdgeBuffer ,
                                        pgraph->iEdgeBuffer + cOutEdgeset + cInEdgeset );

                        if ( pgraph->pEdgeBuffer == NULL )
                        {
                                pgraph->iErrno = DGL_ERR_MemoryExhausted;
                                return -pgraph->iErrno;
                        }

                        {
                        dglInt32_t nDummy = 0;

                        memcpy( pgraph->pEdgeBuffer + pgraph->iEdgeBuffer , (pOutEdgeset)?pOutEdgeset:&nDummy , cOutEdgeset );
#if !defined(_DGL_V1)
                        memcpy( pgraph->pEdgeBuffer + pgraph->iEdgeBuffer + cOutEdgeset , (pInEdgeset)?pInEdgeset:&nDummy, cInEdgeset );
#endif
                        }

                        DGL_NODE_EDGESET_OFFSET(pnode) = pgraph->iEdgeBuffer;

                        pgraph->iEdgeBuffer += cOutEdgeset + cInEdgeset;
                }

                pgraph->pNodeBuffer = realloc(pgraph->pNodeBuffer, pgraph->iNodeBuffer + DGL_NODE_SIZEOF(pgraph->NodeAttrSize));

                if ( pgraph->pNodeBuffer == NULL )
                {
                        pgraph->iErrno = DGL_ERR_MemoryExhausted;
                        return -pgraph->iErrno;
                }

                memcpy( pgraph->pNodeBuffer + pgraph->iNodeBuffer , pnode , DGL_NODE_SIZEOF(pgraph->NodeAttrSize) );
                pgraph->iNodeBuffer += DGL_NODE_SIZEOF(pgraph->NodeAttrSize);
        }

#if defined(_DGL_V2)
        if ( pgraph->pEdgeTree ) {
                avl_destroy( pgraph->pEdgeTree, dglTreeEdgeCancel );
                pgraph->pEdgeTree = NULL;
        }
#endif

        if ( pgraph->pNodeTree ) {
                avl_destroy( pgraph->pNodeTree, dglTreeNodeCancel );
                pgraph->pNodeTree = NULL;
        }

        pgraph->Flags |= DGL_GS_FLAT; /* flattened */

        /*
         * convert node-id to node-offset
         */
        DGL_FOREACH_NODE(pgraph, pnodescan)
        {
                if ( !(DGL_NODE_STATUS(pnodescan) & DGL_NS_ALONE) )
                {
                        pOutEdgeset = DGL_EDGEBUFFER_SHIFT(pgraph, DGL_NODE_EDGESET_OFFSET(pnodescan));

#if defined(_DGL_V2)
                        for( i = 0 ; i < pOutEdgeset[0] ; i ++ ) {
/*
printf("flatten: node %ld: scan out edge %ld/%ld - %ld\n", DGL_NODE_ID(pnodescan), i+1, pOutEdgeset[0], pOutEdgeset[i+1]);
*/
                                pEdge = DGL_GET_EDGE_FUNC(pgraph, pOutEdgeset[i+1]);
                                if (pEdge == NULL) {
                                        pgraph->iErrno = DGL_ERR_UnexpectedNullPointer;
                                        return -pgraph->iErrno;
                                }
                                /*
printf("         retrieved id %ld\n", DGL_EDGE_ID(pEdge) );
*/
                                pOutEdgeset[i+1] = DGL_EDGEBUFFER_OFFSET(pgraph,pEdge);
                        }

                        pInEdgeset = pOutEdgeset + pOutEdgeset[0] + 1;

                        for( i = 0 ; i < pInEdgeset[0] ; i ++ ) {
                                        /*
printf("flatten: node %ld: scan in edge %ld/%ld - %ld\n",
                           DGL_NODE_ID(pnodescan), i+1, pInEdgeset[0], pInEdgeset[i+1]);
                           */
                                pEdge = DGL_GET_EDGE_FUNC(pgraph, pInEdgeset[i+1]);
                                if (pEdge == NULL) {
                                        pgraph->iErrno = DGL_ERR_UnexpectedNullPointer;
                                        return -pgraph->iErrno;
                                }
                                /*
printf("         retrieved id %ld\n", DGL_EDGE_ID(pEdge) );
*/
                                pInEdgeset[i+1] = DGL_EDGEBUFFER_OFFSET(pgraph,pEdge);
                        }
#endif

#if defined(_DGL_V2)
                        {
                        int iEdge;
                        DGL_FOREACH_EDGE(pgraph, pOutEdgeset, pEdge, iEdge)
#else
                        DGL_FOREACH_EDGE(pgraph, pOutEdgeset, pEdge)
#endif
                        {
                                if ( (pnode = DGL_GET_NODE_FUNC( pgraph, DGL_EDGE_HEADNODE_OFFSET(pEdge))) == NULL )
                                {
                                        pgraph->iErrno = DGL_ERR_HeadNodeNotFound;
                                        return -pgraph->iErrno;
                                }
                                DGL_EDGE_HEADNODE_OFFSET(pEdge) = DGL_NODEBUFFER_OFFSET(pgraph, pnode);

                                if ( (pnode = DGL_GET_NODE_FUNC( pgraph , DGL_EDGE_TAILNODE_OFFSET(pEdge))) == NULL )
                                {
                                        pgraph->iErrno = DGL_ERR_TailNodeNotFound;
                                        return -pgraph->iErrno;
                                }
                                DGL_EDGE_TAILNODE_OFFSET(pEdge) = DGL_NODEBUFFER_OFFSET(pgraph, pnode);
                        }
#if defined(_DGL_V2)
                        }
#endif
                }
        }

        return 0;
}


int DGL_UNFLATTEN_FUNC( dglGraph_s * pgraph )
{
        register dglInt32_t *           pHead;
        register dglInt32_t *           pTail;
        register dglInt32_t *           pEdge;
        register dglInt32_t *           pEdgeset;
        int                                                     nret;

        if ( ! (pgraph->Flags & DGL_GS_FLAT) )
        {
                pgraph->iErrno = DGL_ERR_BadOnTreeGraph;
                return -pgraph->iErrno;
        }

        /*
         * unflag it now to avoid DGL_ADD_EDGE_FUNC() failure
         */
        pgraph->Flags &= ~DGL_GS_FLAT;
        pgraph->cNode = 0;
        pgraph->cEdge = 0;
        pgraph->cHead = 0;
        pgraph->cTail = 0;
        pgraph->cAlone = 0;
        pgraph->nnCost = (dglInt64_t)0;

        if ( pgraph->pNodeTree == NULL ) pgraph->pNodeTree = avl_create( DGL_T_NODEITEM_Compare, NULL, dglTreeGetAllocator() );
        if ( pgraph->pNodeTree == NULL ) {
                pgraph->iErrno = DGL_ERR_MemoryExhausted;
                return -pgraph->iErrno;
        }
#if defined(_DGL_V1)
        pgraph->pEdgeTree = NULL;
#else
        if ( pgraph->pEdgeTree == NULL ) pgraph->pEdgeTree = avl_create( dglTreeEdgeCompare, NULL, dglTreeGetAllocator() );
        if ( pgraph->pEdgeTree == NULL ) {
                pgraph->iErrno = DGL_ERR_MemoryExhausted;
                return -pgraph->iErrno;
        }
#endif

        DGL_FOREACH_NODE(pgraph,pHead)
        {
                if ( DGL_NODE_STATUS(pHead) & DGL_NS_HEAD )
                {
                        pEdgeset = DGL_EDGEBUFFER_SHIFT(pgraph, DGL_NODE_EDGESET_OFFSET(pHead));

#if defined(_DGL_V2)
                        {
                        int iEdge;
                        DGL_FOREACH_EDGE(pgraph, pEdgeset, pEdge, iEdge)
#else
                        DGL_FOREACH_EDGE(pgraph, pEdgeset, pEdge)
#endif
                        {
                                pTail = DGL_NODEBUFFER_SHIFT(pgraph, DGL_EDGE_TAILNODE_OFFSET(pEdge));

                                nret = DGL_ADD_EDGE_FUNC( pgraph,
                                                        DGL_NODE_ID(pHead),
                                                        DGL_NODE_ID(pTail),
                                                        DGL_EDGE_COST(pEdge),
                                                        DGL_EDGE_ID(pEdge),
                                                        DGL_NODE_ATTR_PTR(pHead),
                                                        DGL_NODE_ATTR_PTR(pTail),
                                                        DGL_EDGE_ATTR_PTR(pEdge),
                                                        0 );

                                if ( nret < 0 ) {
                                        goto error;
                                }
                        }
#if defined(_DGL_V2)
                        }
#endif
                }
                else if ( DGL_NODE_STATUS(pHead) & DGL_NS_ALONE ) {
                        nret = DGL_ADD_NODE_FUNC( pgraph, 
                                                DGL_NODE_ID(pHead),
                                                DGL_NODE_ATTR_PTR(pHead),
                                                0 );
                        if ( nret < 0 ) {
                                goto error;
                        }
                }
        }

        /* move away flat-state data
         */
        if ( pgraph->pNodeBuffer ) free( pgraph->pNodeBuffer );
        if ( pgraph->pEdgeBuffer ) free( pgraph->pEdgeBuffer );
        pgraph->pNodeBuffer = NULL;
        pgraph->pEdgeBuffer = NULL;
        return 0;

error:
        if ( pgraph->pNodeTree ) avl_destroy( pgraph->pNodeTree, dglTreeNodeCancel );
        if ( pgraph->pEdgeTree ) avl_destroy( pgraph->pEdgeTree, dglTreeEdgeCancel );
        pgraph->pNodeTree = NULL;
        pgraph->pEdgeTree = NULL;
        pgraph->Flags |= DGL_GS_FLAT;
        return nret;
}