GDT/GDT_TokenList.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:        GDT Library. (Geo Delta)
 *
 * COMMENTS:    GDT_TokenList is an abstract class for a list of attribute
 *              tokens.
 *
 */

#ifndef __GDT_TokenList_h__
#define __GDT_TokenList_h__

#include "GDT_API.h"
#include <fstream.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_RefArray.h>
#include <GB/GB_Attribute.h>

class GB_BaseGroup;
class GDT_BaseAttribute;
class GDT_JSON;
class GEO_Detail;
class UT_String;
class UT_JSONParser;

class GDT_API GDT_TokenList
{
public:

    GDT_TokenList();
    GDT_TokenList(const GDT_TokenList &other);
    virtual ~GDT_TokenList() = 0;
   
    // Apply the stored deltas to the given gdp
    virtual void         applyDeltas(GEO_Detail &gdp, bool inverse=0) const;

    // Zero (but don't destroy) the attribute deltas
    virtual void         zeroDeltas();
    // Destroy the attribute delta lists
    virtual void         clearDeltas();
    // Destroy the attribute delta lists and attributes
    virtual void         destroy();

    
    // Make sure the attributes in the dictionary exist in this
    // token list, in preparation for attribute changes using
    // beginAttributeChange/endAttributeChange.  Any begin/end calls
    // will be working on elements with the given attribute dictionary.
    void                 setAttribDict(const GB_AttributeDict &dict);

    // Refresh attributes added from setAttribDict.
    // This function assumes that your geometry has not changed but your
    // attribute offsets might have changed because of added/deleted attributes
    void                 refreshAttribDict(const GB_AttributeDict &dict);

    // Begin and end a change to the element specified by index.
    // The delta is computed and stored based on the attributes in the
    // dictionary given in the call to addAttributesFromDict.
    void                 beginAttributeChange(const GB_AttributeData &data);
    void                 endAttributeChange(const GB_AttributeData &data,
                                            unsigned int index);
    
    // Begin and end a change to a list of elements.
    // The deltas for all the elements in the list are computed and stored
    // based on the attributes in the dictionary given in the call to
    // addAttributesFromDict.
    void                 resizeSavedListData(int numelem);
    void                 beginListAttributeChange(const GB_AttributeData &data,
                                                  unsigned int index);
    void                 endListAttributeChange(const GB_AttributeData &data,
                                                unsigned int index);

    // Can't take const gdps because even looking at attributes requires
    // write access.
//    virtual bool       takeAttributeSnapshot(const GEO_Detail &beforegdp,
//                                             const GEO_Detail &aftergdp,
//                                             const UT_String &name,
//                                             int size,
//                                             GB_AttribType type,
//                                             const GB_BaseGroup *grp=0) = 0;

    virtual unsigned int       getElementCount(const GEO_Detail &gdp)   const=0;


    // The following methods allow for iterating through the list's 
    // attribute elements without knowing what these are.
    // Note: the gdp is not const because we need to return a non-const element
    virtual void               initIterate() const = 0;
    virtual GB_AttributeElem  *getNextAttributeElement(GEO_Detail &gdp) const=0;
    virtual GB_AttributeElem  *getAttributeElement(GEO_Detail &gdp,
                                                   unsigned int index)  const=0;

    // Get the attribute dictionary associated with this list
    virtual GB_AttributeDict  &getAttributeDict(GEO_Detail &gdp) const=0;


    //TODO: the *GdpAttribute methods are here because they are not virtual
    // in the GB_AttributeDict.  If ever they are made virtual we should
    // get rid of them from here

    // This method creates a new attribute in the gdp.  The owner of the 
    // attribute depends on which list the call was made.
    virtual GB_AttributeRef     appendGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int size,
                                                GB_AttribType type,
                                                const void *defvalue) const=0;
    virtual GB_AttributeRef     growGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int oldsize,
                                                GB_AttribType type,
                                                unsigned int addedsize) const=0;

    // Returns true if this list will have an effect on the gdp if its deltas
    // are applied, false otherwise.
    // This is useful because if you need to know if the list
    // has anything worth saving or applying, then knowing the number of
    // attributes isn't enough (all the attributes might be empty).
    virtual bool               hasChange() const;

    // Returns the number of elements NOT the number of attributes.  For 
    // example if this were a point list, then this would return the total 
    // number of points that COULD be affected by change.  If no attributes
    // exist returns 0.
    virtual unsigned int       entries() const;

    // I/O Methods
    virtual int                saveAttribs(ostream &os, int binary = 0) const;
    virtual bool               loadAttribs(UT_JSONParser &p,
                                           const GDT_JSON &json);
    virtual bool               legacyLoadAttribs(UT_IStream &is, uint size);

    // Searches through myAttributes and finds the attribute named
    // oldname and sets its name to newname.
    void                       renameAttribute(const UT_String &oldname,
                               const UT_String &newname);

protected:

    // Called by subclasses in function mergeDeltas
    void                 mergeAttributeDeltas(const GDT_TokenList &other,
                                              bool inverse = false);

    // These methods return attribute elements from the list.  
    // GDT_TokenList is too general to know what kind of elements 
    // it's dealing with, the derived lists should know.
    virtual void         getAttributeElements(const GEO_Detail &beforegdp,
                                 const GEO_Detail &aftergdp,
                                 unsigned int before_elem_index,
                                 unsigned int after_elem_index,
                                 const GB_AttributeElem *&beforeelem,
                                 const GB_AttributeElem *&afterelem) const=0;

    // Returns the index in the attributes array of the attribute,
    // returns -1 if the attribute is not there.
    int                  getAttributeIndex(const UT_String &name,
                                           GB_AttribType type);
    int                  getAttributeIndex(const UT_String &name,
                                           int size,
                                           GB_AttribType type);

    // Adds an attribute and returns its index in the array
    unsigned int         appendAttribute(const UT_String &name, 
                                         int attrib_size, 
                                         GB_AttribType type, 
                                         const void *defaults,
                                         unsigned int array_size);
    unsigned int         appendAttribute(const GB_Attribute &attrib,
                                         unsigned int array_size);

    GDT_BaseAttribute   *attribs(unsigned int i) { return myAttributes(i); }
    const GDT_BaseAttribute *attribs(unsigned int i) const 
                                                { return myAttributes(i); }
    int                  numAttribs() const { return myAttributes.entries(); }
    GB_AttributeRef      getAttributeOffset(unsigned int i)
                                { return myAttributeOffsets(i); }

    // takeAttributeDict snapshot performs the delta operation on two gdps,
    // with a generic dictionary, and optionally takes a subset of indices
    // to diff (so that it won't do the snapshot from elements 0 to 
    // num_after_elems - 1).
//    virtual bool       takeAttributeDictSnapshot(const GEO_Detail &beforegdp,
//                                       const GEO_Detail &aftergdp,
//                                       const GB_AttributeDict &beforedict,
//                                       const GB_AttributeDict &afterdict,
//                                       unsigned int num_before_elems,
//                                       unsigned int num_after_elems,
//                                       const UT_String &name,
//                                       int size,
//                                       GB_AttribType type,
//                                       const UT_IntArray *subset=0);


private:
    // Stored data for begin/end calls
    int                                  mySavedDataSize;
    GB_AttributeData                     mySavedData;
    UT_PtrArray<GB_AttributeData *>      mySavedListData;

    // Attribute deltas with their offsets
    UT_PtrArray<GDT_BaseAttribute *>     myAttributes;
    UT_RefArray<GB_AttributeRef>         myAttributeOffsets;             
};
#endif

---