UT/UT_FSASymbolTable.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:        UT_FSASymbolTable.h ( UT Library, C++)
 *
 * COMMENTS:    Insertion and deletion of symbols is incredibly expensive.
 *              Searching in the table is faster than other symbol tables (on
 *              most architectures).
 *
 */

#ifndef __UT_FSASymbolTable__
#define __UT_FSASymbolTable__

#include "UT_API.h"
#include "UT_FSA.h"
#include "UT_SmallObject.h"
#include "UT_Thing.h"
#include "UT_PtrArray.h"

class ut_FSASymbolStorage;
class ut_FSASymbolStorage
    : public UT_SmallObject<ut_FSASymbolStorage,
                            UT_SMALLOBJECT_CLEANPAGES_ON,
                            1024,
                            UT_SMALLOBJECT_THREADSAFE_ON>
{
public:
    UT_Thing     myThing;
    char        *myString;
};

class UT_API UT_FSASymbolTable {
public:
     UT_FSASymbolTable();
    ~UT_FSASymbolTable();

    void        addSymbol(const char *symbol, UT_Thing data);
    int         deleteSymbol(const char *symbol);
    void        clear();

    int         findSymbol(const char *symbol, UT_Thing *datap) const
                {
                    int         idx;
                    if (myDirty) rebuild();
                    idx = myTable.findSymbol(symbol);
                    if (idx >= 0)
                    {
                        *datap = myStorage(idx)->myThing;
                        return 1;
                    }
                    return 0;
                }

    unsigned    entries() const { return myStorage.entries(); }
    bool        empty() const   { return !myStorage.entries(); }

    const char  *getStringReference(const char *symbol)
                 {
                     int        idx;
                     if (myDirty) rebuild();
                     idx = myTable.findSymbol(symbol);
                     return idx >= 0 ? myStorage(idx)->myString : 0;
                 }

    int64        getMemUsage(bool /*only_this*/=false) const
                 {
                     if (myDirty) rebuild();
                     return sizeof(*this) + myTable.getMemUsage()
                                          + myStorage.getMemoryUsage();
                 }

    int          traverseConst(
                        int (*function)(UT_Thing &, const char *, void *),
                        void *data) const
                 {
                     int                i;
                     for (i = 0; i < myStorage.entries(); i++)
                     {
                         if (!function(myStorage(i)->myThing,
                                      myStorage(i)->myString, data))
                             return 0;
                     }
                     return 1;
                 }
    int          traverse(int (*function)(UT_Thing &, const char *, void *),
                        void *data)
                 {
                     int                i;
                     for (i = 0; i < myStorage.entries(); i++)
                     {
                         if (!function(myStorage(i)->myThing,
                                      myStorage(i)->myString, data))
                             return 0;
                     }
                     return 1;
                 }

    void         rebuild();

private:
    void         rebuild() const;

    UT_FSA                              myTable;
    UT_PtrArray<ut_FSASymbolStorage *>  myStorage;
    bool                                myDirty;
};

#endif

---