UT/UT_SymList.h

Go to the documentation of this file.

#ifndef __UT_Sym__
#define __UT_Sym__

#include "UT_API.h"
#include <stdio.h>
#include "UT_Defines.h"
#include "UT_Thing.h"
#include "UT_SmallObject.h"

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

    int          insertEntry(const char *name, const UT_Thing &value);
    int            findEntry(const char *name, UT_Thing *valuep) const;
    UT_Thing       &getEntry(const char *name, int *created = 0);
    int          deleteEntry(const char *name);

    // Returns true if found and assigns valuep; otherwise returns false
    // and creates a new blank entry.
    bool        findOrCreate(const char *name, UT_Thing **valuep);

    const char  *insertEntryAndGetReference(const char *name,
                            const UT_Thing &value, int &created);

    const char  *getStringReference(const char *name, int *created = 0);

    int          count() const;
    int          traverse(int (*function)(UT_Thing &, const char *, void *),
                          void *data) const;

    void         dump(FILE *output, const char *format) const;

    unsigned     entries(void) const;
    unsigned     empty(void) const;     // Return true if empty

    class UT_Sym;
public:
    class UT_API traverser
    {
        public:
            traverser()
                : myCurrSym(0) { }
            traverser(const traverser &src)
                         { *this = src; }
            ~traverser() { }

            UT_Thing    &thing() { return myCurrSym->data; }
            const char  *name() const { return myCurrSym->name; }

            int          operator==(const traverser &cmp) const
                         {  return (myCurrSym == cmp.myCurrSym); }
            int          operator!=(const traverser &cmp) const
                         { return !(*this == cmp); }

            traverser   &operator++()
                         {
                             myCurrSym = myCurrSym->next;
                             return *this;
                         }

            const traverser     &operator=(const traverser &src)
                         {
                             myCurrSym = src.myCurrSym;
                             return *this;
                         }

        private:
            traverser(UT_Sym *sym)
                : myCurrSym(sym) { }

            UT_Sym      *myCurrSym;

            friend class UT_SymList;
    };

    traverser    begin() const { return traverser(symbols); }
    traverser    end() const { return traverser(); }
    
    int64        getMemUsage(bool only_this) const;

    class UT_API UT_Sym : public UT_SmallObject<UT_Sym,
                                         UT_SMALLOBJECT_CLEANPAGES_DEFAULT,
                                         UT_SMALLOBJECT_PAGESIZE_DEFAULT,
                                         UT_SMALLOBJECT_THREADSAFE_DEFAULT>
    {
        public:
            UT_Thing     data;
            char        *name;
            UT_Sym      *next;
    };

    UT_Sym      *symbols;

    // These methods are called when rebuilding the symbol table.
    UT_Sym      *removeFirstSym();
    void         insertSym(UT_Sym &sym);
    UT_Sym      *findOrCreate(const char *name, int *created);

    friend class traverser;
};

#endif

---