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

#ifndef __GA_AttributeDict__
#define __GA_AttributeDict__

#include "GA_API.h"
#include <UT/UT_SymbolTable.h>
#include <UT/UT_Pair.h>
#include <UT/UT_OrderedIterator.h>
#include "GA_Attribute.h"
#include "GA_AttributeProxy.h"

class GA_AttributeSet;

/// @brief A symbol table of attributes to ease backward compatibility
/// In the GB/GEO/GU library code would often pass around a GB_AttributeDict
/// around.  The GA library really only requires a symbol table of attributes
/// since the attributes are managed by the GA_AttributeSet.  This class is
/// really just a symbol table wrapper to ease backward compatibility.
class GA_API GA_AttributeDict 
{
public:
     GA_AttributeDict() {}
    ~GA_AttributeDict() {}

    /// @{
    /// Get access to the containing attribute set.
    const GA_AttributeSet       &getSet() const { return *mySet; }
    GA_AttributeSet             &getSet()       { return *mySet; }
    /// @}

    /// Report memory usage
    int64               getMemoryUsage() const
                        {
                            int64       mem = sizeof(*this);
                            mem += myTable.getMemUsage();
                            iterator    it;
                            for (it = begin(); !it.atEnd(); ++it)
                                mem += it.proxy()->getMemoryUsage();
                            return mem;
                        }

    GA_AttributeProxy   *findProxy(GA_AttributeScope scope,
                                   const char *name) const;
    GA_AttributeProxy   *findProxyByFullName(const char *name) const
                         {
                            UT_Thing    thing;
                            if (myTable.findSymbol(name, &thing))
                            {
                                return thing.asPointer<GA_AttributeProxy>();
                            }
                            return NULL;
                         }

    GA_Attribute        *find(GA_AttributeScope scope, const char *name) const;
    GA_Attribute        *findByFullName(const char *name) const
                         {
                             GA_AttributeProxy *proxy = findProxyByFullName(
                                                                        name);
                             return proxy ? proxy->getAttribute() : NULL;
                         }

    void        addByFullName(const char *name, GA_AttributeProxy *proxy)
                    { myTable.addSymbol(name, proxy); }
    int         removeByFullName(const char *name)
                    { return myTable.deleteSymbol(name); }
    void        clear()
                    { myTable.clear(); }

    uint        entries() const
                    { return myTable.entries(); }
    uint        entries(GA_AttributeScope scope) const
                    {
                        if (scope != GA_SCOPE_INVALID)
                        {
                            iterator     it = begin(scope);
                            uint         count = 0;
                            for ( ; !it.atEnd(); ++it)
                                count++;
                            return count;
                        }
                        else
                            return entries();
                    }
    uint        empty() const
                    { return myTable.entries(); }
    uint        empty(GA_AttributeScope scope) const
                    { return entries(scope) == 0; }

    typedef int (*AttributeTraverseCallback)(GA_Attribute*, const char*, void*);
    int         traverseConst( AttributeTraverseCallback F, void *data) const
                    { 
                        UT_Pair<AttributeTraverseCallback, void*>   p(F, data);
                        return myTable.traverseConst(traverseProxyCallback, &p);
                    }

    class GA_API iterator
    {
        public:
             iterator() : myTraverser(), myDict(NULL),
                           myScope(GA_SCOPE_INVALID) {}
             iterator(GA_AttributeScope scope) : myTraverser(), myDict(NULL),
                           myScope(scope) {}
             iterator(const iterator &src) { *this = src; }
            ~iterator() {}

            const char          *internalName() const
                                 { return myTraverser.name(); }
            const char          *name() const
                                 {
                                     const GA_Attribute *atr =
                                         const_cast<iterator *>(this)->attrib();
                                     return atr ? atr->getName() : 0;
                                 }
            GA_AttributeProxy   *proxy()
                                 {
                                     return myTraverser.thing().
                                                asPointer<GA_AttributeProxy>();
                                 }
            GA_Attribute        *attrib()
                                 {
                                     return proxy()->getAttribute();
                         }
        GA_Attribute    *operator*()
                         {
                             return attrib();
                                 }
            int                 operator==(const iterator &cmp) const
                                    { return myTraverser == cmp.myTraverser; }
            int                 operator!=(const iterator &cmp) const
                                    { return myTraverser != cmp.myTraverser; }
            bool                atEnd() const
                                {
                                    return myTraverser.atEnd(); 
                                }
            iterator            &operator++()
                                {
                                    ++myTraverser;
                                    if (myScope != GA_SCOPE_INVALID)
                                    {
                                        while (!atEnd() &&
                                                attrib()->getScope() != myScope)
                                            ++myTraverser;
                                    }
                                    return *this;
                                }
            const iterator      &operator=(const iterator &src)
                                {
                                    myTraverser = src.myTraverser;
                                    myDict = src.myDict;
                                    myScope = src.myScope;
                                    return *this;
                                }
        private:
            iterator(const GA_AttributeDict *dict,
                      GA_AttributeScope scope)
                : myTraverser(dict->myTable.begin()),
                  myDict(dict), myScope(scope)
            {
                if (myScope != GA_SCOPE_INVALID)
                {
                    if (!atEnd() && attrib()->getScope() != myScope)
                        operator++();
                }
            }
            UT_SymbolTable::traverser    myTraverser;
            const GA_AttributeDict      *myDict;
            GA_AttributeScope            myScope;
            friend class                 GA_AttributeDict;
    };

    static int  compareAlpha(GA_Attribute *const*a, GA_Attribute *const*b)
                {
                    const char  *aname = (*a)->getName();
                    const char  *bname = (*b)->getName();
                    if (!strcmp(aname, "P"))
                        return -1;
                    if (!strcmp(bname, "P"))
                        return 1;

                    // Not case-sensitive
                    return UT_String::compareNumberedString(aname,bname,false);
                }

    /// Iterator which traverses attributes in given order
    typedef UT_OrderedIterator< GA_Attribute *, iterator > ordered_iterator;

    /// @{
    /// Unordered (fastest) iteration
    iterator            begin(GA_AttributeScope scope = GA_SCOPE_INVALID) const
                                        { return iterator(this, scope); }
    iterator            end(GA_AttributeScope scope = GA_SCOPE_INVALID) const
                                        { return iterator(scope); }
    /// @}

    /// @{
    /// Ordered iteration.  This traverses attributes in a fixed order
    ordered_iterator    obegin(GA_AttributeScope scope = GA_SCOPE_INVALID) const
                        {
                            iterator    it(this, scope);
                            return ordered_iterator(it, compareAlpha);
                        }
    ordered_iterator    oend(GA_AttributeScope scope = GA_SCOPE_INVALID) const
                        {
                            return ordered_iterator();
                        }
    /// @}

    /// @private
    /// Used only by GA_AttributeSet 
    void                setSet(GA_AttributeSet *s)      { mySet = s; }
    void                setMinLoadFactor(float minload) { myTable.setMinLoadFactor(minload); }
    void                reserveNewSymbolTableSpace(int n)
                        {
                            if (myTable.entries() + n > myTable.size())
                                myTable.reserveTableSize(myTable.entries() + n);
                        }


private:
    static int      traverseProxyCallback(UT_Thing &thing, const char *key, 
                                              void *data)
                        {
                            UT_Pair<AttributeTraverseCallback, void*>   *p =
                                static_cast<UT_Pair<AttributeTraverseCallback, 
                                                    void*> *>(data);
                            GA_Attribute    *a = 
                                static_cast<GA_AttributeProxy *>(
                                    thing.value.voidp)->getAttribute();
                            return (*p->myFirst)(a, key, p->mySecond);
                        }

    UT_SymbolTable      myTable;
    GA_AttributeSet     *mySet;
};

#endif

---