UT/UT_TokenString.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 Alexander
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Utility Library (C++)
 *
 * COMMENTS:    String class for quick exact comparison & hashing by using
 *              tokens (non-ASCII bytes). 
 *
 */
#ifndef __UT_TOKENSTRING_H__
#define __UT_TOKENSTRING_H__

#include "UT_API.h"
class UT_String;
class UT_WorkBuffer;
#include "UT_Endian.h"
#include "UT_Hash.h"


// Turning on the following define will cause checks to be put in place to
// detect buffer over/underruns.
// 
//#define UT_TS_DETECT_BUFFER_ERRORS

class UT_API UT_TokenString
{
public:
    static UT_TokenString *allocString();
    static UT_TokenString *dupString(const UT_TokenString &);
    static void            freeString(UT_TokenString *&);

    unsigned            operator==(const UT_TokenString &str) const;
    int                 strcmp(const UT_TokenString &str) const;
    UT_TokenString      &operator=(const UT_TokenString &str);
    UT_TokenString      &operator+=(const UT_TokenString &str);

    void                append(int value, bool hashonly = false);
    void                append(unsigned value, bool hashonly = false);
    void                append(short value, bool hashonly = false);
    void                append(unsigned short value, bool hashonly = false);
    void                append(long value, bool hashonly = false);
    void                append(fpreal32 value, bool hashonly = false);
    void                append(fpreal64 value, bool hashonly = false);
    void                append(char value, bool hashonly = false);
    void                append(const char *value, bool hashonly = false);
    void                append(const UT_String &value, bool hashonly = false);
    void                append(const UT_WorkBuffer &value, bool hashonly=false);

    void                clear();
    unsigned int        getHashCode() const { return myHashCode; }

    // for writing to disk with direct IO
    int                 getMemSize() const;
    int                 copyToMem(void *mem, int *length) const;
    void                copyFromMem(void *mem, int *length);
    
    void                print() const; // for debug

    void                getPrintable(UT_String &string) const;

    void                compress();

private:
                 UT_TokenString();
    virtual     ~UT_TokenString();

    // This will realloc myString and ensure it is at least the given
    // size.  It does nothing if there is already room, so call this
    // wherever you want to grow or are not sure.
    void         resizeString(int size);
    
    void         append(const void *str, int length, bool hashonly);

    unsigned int myHashCode;
    int          myLength;
    int          myTrueSize;

    union {
        unsigned char *myString;
        UT_TokenString *myNext;
    };

#ifdef UT_TS_DETECT_BUFFER_ERRORS
    unsigned char   *myMemString;
#endif

    friend class OP_Node;
};


class UT_API UT_Hash_TokenString : public UT_Hash
{
    private:
        UT_TokenString          *myTs;
    public:
        UT_Hash_TokenString( UT_TokenString *a )
        {
            myTs = UT_TokenString::dupString(*a);
        }

        ~UT_Hash_TokenString()
        {
            UT_TokenString::freeString(myTs);
        }

        int compare( const UT_Hash & a) const
        {
            return !(*myTs == *((const UT_Hash_TokenString&)a).myTs);
        }

        void            copy(const UT_Hash &a)
        {
            myTs = UT_TokenString::dupString(
                        *static_cast<const UT_Hash_TokenString &>(a).myTs);
        }

        unsigned        hash() const
        {
            return myTs->getHashCode();
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_TokenString( myTs );
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this) + myTs->getMemSize());
        }
};

#endif

---