GB/GB_GroupList.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:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GB library (C++)
 *
 * COMMENTS:    List of groups for a particular element
 *
 */

#ifndef __GB_GroupList_h__
#define __GB_GroupList_h__

#include "GB_API.h"
#include <UT/UT_LinkList.h>
#include <UT/UT_SymbolTable.h>
#include "GB_ElementList.h"

class UT_BitArray;
class GB_ElementTree;
class GB_Group;
class GB_PointList;
class GB_PrimList;
class UT_IStream;

class GB_API GB_GroupList : public UT_LinkList
{
public:
                 GB_GroupList(GB_ElementList &list);
    virtual     ~GB_GroupList();

    int          isEmpty() const        { return head() ? 0 : 1; }
    int          getPersistentCount() const;

    GB_Group    *find(const char *name) const;
    GB_Group    *head() const; // { return (GB_Group *)UT_LinkList::head(); }
    GB_Group    *tail() const; // { return (GB_Group *)UT_LinkList::tail(); }

    GB_Element  *element(int num) const
                { return  (num >= 0 && num < (int)myElements.entries()) ?
                            myElements((unsigned)num) : 0;
                }

    int          numOrdered() const     { return myOrdered; }
    void         numOrdered(int n)      { myOrdered = n;    }

    int          getAllocSize() const   { return myAllocSize; }

    // low-level function to copy the group definitions from the source
    void         copyDefinition(const GB_GroupList &src);

protected:
    virtual GB_Group    *groupSpecies(const char *name, int internal) const=0;

private:
    friend class GB_Detail;

    GB_Group    *newGroup(const char *name, int internal);
    void         destroy(GB_Group *group);
    void         destroy(const char *name) { destroy(find(name)); }
    void         clear();

    void                 findAvailable(unsigned &offset, unsigned &mask);
    void                 resizeElements(int oldSize, int newSize);

    int                  myAllocSize;   // How many words are allocated
    unsigned            *myAvailable;
    GB_ElementList      &myElements;
    UT_SymbolTable       myHashtable;   // accelerate searches
    int                  myOrdered;     // number of ordered groups


//
// Now, we define some methods which are only used by GB_Group.  These
//      are here for logical programming
    friend class         GB_Group;

    void         rename(const char *name, GB_Group &g);

    // NOTE: These calls are O(N) for unordered groups (N = number of entities)
    unsigned             entries(const GB_Group &grp);
    unsigned             entriesMix(const GB_Group &grp);
    int                  isEmpty(const GB_Group &grp);
    int                  isEmptyMix(const GB_Group &grp);

    void                 clearEntries(GB_Group &grp);
    void                 clearAllEntries();
    void                 setEntries(GB_Group &grp);
    void                 toggleEntries(GB_Group &grp);

    // All of the operator type methods work on the first argument as the
    //  operand.  The second argument's bit flags are not touched
    void                 orEqual    (GB_Group &dst, const GB_Group &g);
    void                 andEqual   (GB_Group &dst, const GB_Group &g);
    void                 minusEqual (GB_Group &dst, const GB_Group &g);
    void                 xorEqual   (GB_Group &dst, const GB_Group &g);
    void                 assignEqual(GB_Group &dst, const GB_Group &g);

    int                  save(const GB_Group &src, ostream &os, int bin) const;
    bool                 load(GB_Group &src, UT_IStream &is);

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

    int                  saveTree(ostream &os, int binary, 
                                  GB_ElementTree *tree) const;
    bool                 loadTree(UT_IStream &is, GB_ElementTree *tree);

    void                 saveToBitArray(const GB_Group &, UT_BitArray &) const;
    void                 loadFromBitArray(GB_Group &, UT_BitArray &);
};

class GB_API GB_PointGroupList : public GB_GroupList
{
public:
                 GB_PointGroupList(GB_ElementList &list);
    virtual     ~GB_PointGroupList();

protected:
    virtual GB_Group    *groupSpecies(const char *name, int internal) const;
};

class GB_API GB_PrimGroupList : public GB_GroupList
{
public:
                 GB_PrimGroupList(GB_ElementList &list);
    virtual     ~GB_PrimGroupList();

protected:
    virtual GB_Group    *groupSpecies(const char *name, int internal) const;
};

#endif

---