GB/GB_EdgeGroup.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:
 *      George ElKoura
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Lightweight group definition for GB_Edge types (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __GB_EdgeGroup_h__
#define __GB_EdgeGroup_h__

#include "GB_API.h"
#include <UT/UT_HashTable.h>
#include <UT/UT_LinkList.h>
#include <UT/UT_Notifier.h>

#include "GB_Detail.h"
#include "GB_Edge.h"
#include "GB_BaseGroup.h"

class GB_API GB_EdgeGroup : public GB_BaseGroup 
{
public:
     GB_EdgeGroup(const GB_Detail &gdp, const char *name, int hidden = 1, 
                  unsigned short type = GBEDGEGROUP);
    ~GB_EdgeGroup();

    GB_Edge     *find(const GB_Edge *it) const;
    GB_Edge     *find(const GB_Edge &it) const
                        { return find(&it); }
    int          contains(const GB_Edge *it) const;

    int          contains(const GB_Edge &it) const
                        { return contains(&it); }


    // Adds return 1 if successful and 0 otherwise
    int          add(GB_Edge *it);

    int          add(GB_Edge &it) 
                        {return add(&it);}

    int          add(GB_Element *p0, GB_Element *p1, GB_Element *prim = 0);

    // The append options on the toggle methods is used to specify whether
    // or not the edge that is passed in should be used or should a private 
    // copy be used instead.  An append value of 1 will not create a new edge.
    int          toggle(GB_Edge *it);

    int          toggle(GB_Edge &it)
                        {return toggle(&it);}

    int          toggle(unsigned int num)
                        {return toggle((GB_Edge *)myEdgeList.find((int)num));}

    int          remove(GB_Edge *it);

    int          remove(GB_Edge &it)
                        {return remove(&it);}

    int          remove(unsigned int num)
                        {return remove( (GB_Edge *)myEdgeList.find((int)num) );}

    UT_LinkList       &list()           { return myEdgeList; }
    const UT_LinkList &list() const     { return myEdgeList; } 
    
    void         elementRemoved(GB_Element *);

    // TODO: resolve: entries() is returning unsigned but length() returns
    //       int.  Base class uses unsigned.  Should UT_LinkList::length 
    //       really return signed?
    // Yep.  UT_LinkList should be changed, or we should abandon this whole
    // signed/unsigned distinction.  For now, I'm just putting in casts
    // everywhere :<
    virtual unsigned     entries() const {return (unsigned)myEdgeList.length();}
    virtual int          isEmpty() const { return myEdgeList.isEmpty(); }
    virtual void         clearEntries(void);

    virtual int          save(ostream &os, int binary) const;
    virtual bool         load(UT_IStream &is);

private:

    UT_LinkList                  myEdgeList;    // list of edges in the group
    UT_HashTable                 myEdgeTable;

    const GB_Detail             &myGdp;
    UT_NotifierList              myNotifierList;
};
#endif

---