GB/GB_AttributeDict.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 Software Inc.
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __GB_AttributeDict_h__
#define __GB_AttributeDict_h__

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

#include "GB_AttributeDefines.h"

class UT_IStream;
class GB_Attribute;
class GB_AttributeData;
class GB_FloatOffsets;

/// This contains the class definition for attributes dictionaries.
/// The size passed in is the size in bytes of the attribute.
/// STRING types are stored as a fixed length array, not as pointers
/// to strings.  However, the string must still be null terminated.
class GB_API GB_AttributeDict : public UT_LinkList
{
public:

     GB_AttributeDict() : UT_LinkList() { myUsedSize = myAllocSize = 0; }
    ~GB_AttributeDict();

    GB_Attribute        *find(const char *name, int s, GB_AttribType t) const;

    /// relaxed search ignoring size (used only variable size attribs)
    GB_Attribute        *find(const char *name, GB_AttribType t) const;

    /// even more relaxed search ignoring size and type (find first available)
    GB_Attribute        *find(const char *name) const;

    /// find using another GB_Attribute
    GB_Attribute        *findClone(const GB_Attribute *src) const;

    GB_Attribute        *getHead(void) const    {return (GB_Attribute*)head();}
    int                  getSize(void) const    { return myUsedSize;  }
    int                  getAlloc(void) const   { return myAllocSize; }
    int                  getOffset(const char *name, int size, 
                                   GB_AttribType type) const;

    /// relaxed search ignoring size (used only variable size attribs)
    int                  getOffset(const char *name, GB_AttribType type) const;

    /// search using another GB_Attribute
    int                  getOffset(const GB_Attribute *src) const;

    GB_Attribute        *grow(const char* name, int oldsize,
                                unsigned int addedsize, GB_AttribType type,
                                int &offset);

    GB_Attribute        *shrink( const char* name, int oldsize,
                                 unsigned int removedsize, GB_AttribType type,
                                 int &offset );

    void                 clearAndDestroy()
                         {
                             clear();
                             myUsedSize = myAllocSize = 0;
                         }
    
    /// Fill the data with default values. If alloc is 1, this method first  
    /// resizes the data.
    void                 useDefaults(GB_AttributeData &d, int alloc=1) const;


    /// Go back and forth through the list to retrieve the offset of each
    /// attribute.
    // @{
    GB_Attribute        *headFloatOffset(int &o) const;
    GB_Attribute        *nextFloatOffset(int &o, const GB_Attribute *a) const;

    GB_Attribute        *headVectorOffset(int &o) const;
    GB_Attribute        *nextVectorOffset(int &o, const GB_Attribute *a) const;
    // @}

    /// Build a list of offsets for float attributes. If you want to 
    /// exclude some offsets from being added to the list, specify them as 
    /// varargs and assign the total number of exceptions to "in_out_count" as a
    /// NEGATIVE number. Similarly, if you want only certain offsets to be
    /// added to the list, specify them as varargs and assign the number of
    /// inclusions to "in_out_count" as a POSITIVE number. The method returns
    /// the number of floats added to the "offsets" list. If not nil,
    /// "startattrib" indicates the attribute where to start collecting float
    /// indices, and startidx is the 1st index.
    /// The first getFloatOffsets will get float offsets based on the list of
    /// "interesting" float attributes passed to it.
    // @{
    int                  getFloatOffsets(GB_FloatOffsets &offsets,
                                         const char *interests[]) const;
    int                  getFloatOffsets(GB_FloatOffsets &offsets,
                                         GB_Attribute *startattrib =  0,
                                         int startidx               = -1,
                                         int exceptions = 0, ...) const;
    // @}
    int                  getVectorOffsets(GB_FloatOffsets &offsets,
                                         GB_Attribute *startattrib = 0,
                                         int startidx               = -1) const;

    /// Find the number of attributes that are non MIXED (ie are to be saved 
    /// on disk).
    int                  getPersistentCount(void) const;

    /// Sort the attributes into a specific order. Basically used for making 
    /// two details mergable. Attributes will be added if they don't already 
    /// exist. At the conclusion, the attribute list will be identical
    /// to the table...
    virtual void         sortAs(const GB_AttributeDict &) = 0;
    
    ///  Return true if they contain the same entries in the same order
    ///  NB: This ignores myTypeInfo!
    virtual int          isEqual(const GB_AttributeDict &table) const;


    //  I/O methods:

    ///  a) Save or load some attribute data (formerly saveAttribute())
    ///  The attribute delimiter must be one of '(', '[' and '{'.
    // @{
    int  save(ostream &os, const GB_AttributeData &data, int binary,
                                char attribDelim='(') const;
    bool         load(UT_IStream &is, GB_AttributeData &data);
    // @}

    /// b) Save or load the table (formerly saveAttributeTable())
    // @{
    int                  save(ostream &os, const char *label) const;
    GB_Attribute        *load(UT_IStream &is, int tblSize);
    // @}

    /// Helper class used for sorting attributes:
    class GB_API AttribXlate {
    public:
        int              srcOff, size;
        int              idxType;       // We're dealing with an INDEX
        int              idxOffset;     // Offset for INDEX type
        GB_Attribute    *atr;           // The entry from our table
        AttribXlate     *next;
    };
    void                 translateData(const AttribXlate *table, void *input,
                                void *tmp) const;

protected:
    /// Append an attribute (or insert before a given attribute) and 
    /// return a pointer to it if the operation was necessary. If the 
    /// pointer is zero, it means that an attribute was found and either 
    /// it was OK (offset >= 0) or not (offset = -1).
    GB_Attribute        *append(const char *n, int s,
                                GB_AttribType type, GB_AttribTypeInfo type_info,
                                const void *defValue, int *offset);
    GB_Attribute        *insertBefore(const char *n, int s, GB_AttribType type, 
                            GB_AttribTypeInfo type_info,
                            const void *defValue, int dup_check, 
                            GB_Attribute *before, int *offset);

    /// Remove an attribute and return it and the offset in the attribute 
    /// array. If a matching attribute is not found, the method returns 0
    /// and offset is undefined.
    GB_Attribute        *destroy(const char *name, int size,
                                 GB_AttribType type, int *offset);
    /// same as destroy but uses a relaxed search which ignores size.  This
    /// is to support dynamically sized attributes such as point capture
    /// attribs.
    GB_Attribute        *destroy(const char *name,
                                 GB_AttribType type, int *offset);

    /// Allow a derived class to adjust the allocated size:
    void                 setAlloc(int a)        { myAllocSize = a; }

    /// This method is used solely by the sortAs() method to prepare
    /// the attribute xlate table for sorting.  The method returns NULL
    /// if no sorting needs to be done.
    AttribXlate         *preSort(const GB_AttributeDict &table, int *totSize);

private:
    /// The guts of the I/O methods:
    // @{
    int         saveData(ostream &os, const void *d, int size, int type, 
                         int binary, char leadChar = ' ') const;
    int         loadData(UT_IStream &is, void *d, int size, int type);
    // @}

    int         myUsedSize;     // size of attribute array being used
    int         myAllocSize;    // size of allocated array; allocSize>=usedSize
};

#endif

---