GB/GB_ElementTree.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Rob Bairos
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GB_ElementTree.C (C++)
 *
 * COMMENTS:    This class keeps a list of elements used by GB_Group
 *              with the ordered flag turned on. This allows for faster
 *              looping through the elements in a group. It also returns
 *              the elements in the same order in which they were added
 *              to the group.
 */

#ifndef __GB_ElementTree_h__
#define __GB_ElementTree_h__

#include "GB_API.h"
#include <UT/UT_RefArray.h>
#include <UT/UT_LinkList.h>

class GB_Element;
class GB_Group;

//
// Element class methods
//      A link node of GB_Elements
//

//
// A derivation of the above to include a secondary element
//
class GB_API GB_ElementNode
{
public:
    GB_ElementNode(const GB_Element *elem=0, const GB_Element *sec=0)
                   : myElement(elem), mySecondary(sec) {}

    int                          operator==(const GB_ElementNode &elem) const
                                 { return (myElement == elem.myElement &&
                                           mySecondary == elem.mySecondary); }

    const GB_Element            *element(void) const                    
                                 { return myElement; }
    void                         element(const GB_Element *elem)        
                                 { myElement = elem; }

    const GB_Element            *secondary(void) const          
                                 { return mySecondary;}
    void                         secondary(const GB_Element *elem)      
                                 { mySecondary = elem;}

private:
    const GB_Element            *myElement;
    const GB_Element            *mySecondary;
};

class GB_API GB_ElementTree
{
public:
     GB_ElementTree(void);
    virtual     ~GB_ElementTree(void);

    // Since the linkList is not directly composed of GB_Elements but
    // rather GB_ElementNodes, these routines are slightly slower,
    // esp. prev/next.

    unsigned    entries();
    unsigned    mixedEntries();

    void        add(const GB_Element *);
    void        addMix(const GB_Element *, const GB_Element *);

    int         containsMix(const GB_Element *, const GB_Element *);

    // returns 1 if found 0 otherwise
    int         remove(const GB_Element *);
    int         removeMix(const GB_Element *, const GB_Element *);

    // Sequentially search the tree for the element with this
    // number and remove it (and all its dependents) from the tree
    void        remove(int idx);
    void        removeAll(int idx);

    // Removes all the elements of group from our list by asking
    // our list elements if they are in the group.
    // Warning: This does NOT remove the element from the group, just
    // from the ordered list.  This is to be used where you are going
    // to be deleting the item in the group anyways.
    void        removeGroup(const GB_Group *grp);

    void        clear(void);

    const GB_Element    *prev(const GB_Element *node) const;
    int                  prevMix(const GB_Element *node, const GB_Element *sec,
                                 const GB_Element *&newnode, 
                                 const GB_Element *&newsec) const;

    const GB_Element    *next(const GB_Element *node) const;
    int                  nextMix(const GB_Element *node, const GB_Element *sec,
                                 const GB_Element *&newnode, 
                                 const GB_Element *&newsec) const;

    const GB_Element    *head() const;
    int                  headMix(const GB_Element *&newnode, 
                                 const GB_Element *&newsec) const;

    const GB_Element    *tail() const;
    int                  tailMix(const GB_Element *&newnode, 
                                 const GB_Element *&newsec) const;

private:
    // GB_ElementNode methods
    // These methods work directly with the link node type and hence
    // are more efficient
    GB_ElementNode      *findList(GB_ElementNode *) const;

    // NOTE: 
    // 1) removeList requires that the node is part of the myElements
    //    array
    // 2) After removeList() is called, any pointers you have to GB_ElementNode
    //    inside myElements are now invalid.
    void                 removeList(GB_ElementNode *);

    // These wrapper methods are around for backwards compatibility and
    // disguise the fact that this is built on a ref array rather than
    // a linked list.  DO NOT BE DECIEVED.  Use of these methods is
    // depreceated as it will lead to programming errors.
    GB_ElementNode      *prevList(GB_ElementNode *node) const 
                         { return (node > headList()) ? node - 1 : 0; }

    GB_ElementNode      *nextList(GB_ElementNode *node) const 
                         { return (node < tailList()) ? node + 1 : 0; }

    GB_ElementNode      *headList() const       
                         { return myElements.entries()
                                  ? (GB_ElementNode *)&myElements(0)
                                  : 0; }

    GB_ElementNode      *tailList() const       
                         { return myElements.entries()
                                  ? (GB_ElementNode *)
                                    &myElements(myElements.entries() - 1)
                                  : 0; }

    // The actual place we store all the elements of our group.
    UT_RefArray<GB_ElementNode>  myElements;

    // This is the last element node queried.  Using this lets us quickly
    // find the index of the prev pointer in the next() or prev() methods.
    mutable GB_ElementNode      *myLastAccess;

    // This tracks the number of mixed primitives in the group.  A mixed
    // primitive is something like a nurbs surface and its profile curve.
    unsigned                     myMixCount;

    friend class GB_GroupList;
};

#endif

---