UT/UT_Hash.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:
 *      Neil
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Hash.h ( UT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_Hash__
#define __UT_Hash__

#include "UT_API.h"
#include <string.h>
#include <stdlib.h>
#include <malloc.h>

#include "UT_Math.h"
#include "UT_String.h"
#include "UT_SmallObject.h"

class UT_API UT_Hash
    : public UT_SmallObject<UT_Hash,
                            UT_SMALLOBJECT_CLEANPAGES_DEFAULT,
                            UT_SMALLOBJECT_PAGESIZE_DEFAULT,
                            UT_SMALLOBJECT_THREADSAFE_ON>
{
    public:
        virtual ~UT_Hash() { }

        // return 0 on equality
        //
        // Often, the comparison function for a UT_Hash is more expensive
        // than computing the unsigned integer hash code.  However, it's
        // possible for the compare() function to be called even when
        // there is no collision on the hash codes, therefore, if you
        // have the hash codes cached, its often efficient to do
        // a quick comparison of the hash codes before computing the
        // expensive compare function.
        virtual int             compare(const UT_Hash &a) const = 0;

        // Copies data from another UT_Hash into this one.
        virtual void            copy(const UT_Hash &a) = 0;

        // return hash value
        // should never change i.e. should rely on const data
        virtual unsigned        hash() const = 0;

        virtual UT_Hash*        copy() const = 0;

        virtual int64           getMemUsage() const { return 0; }
};

class UT_API UT_Hash_String : public UT_Hash {
    private:
        char            *myData;
    public:
        UT_Hash_String( const char *s )
        {
            myData = strdup( s );
        }

        ~UT_Hash_String()
        {
            free(myData);
        }

        int compare( const UT_Hash & a) const
        {
            return strcmp(myData, ((const UT_Hash_String&)a).myData);
        }

        void            copy(const UT_Hash &a)
        {
            free(myData);
            myData = strdup(static_cast<const UT_Hash_String &>(a).myData);
        }

        unsigned        hash() const
        {
            return UT_String::hash(myData);
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_String( myData );
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this) + (::strlen(myData) + 1) * sizeof(char));
        }

        const char*     getString() const
        {
            return myData;
        }
};

class UT_API UT_Hash_Int : public UT_Hash {
    private:
        int                     myData;
        unsigned                myKey;
    public:
        UT_Hash_Int( int a ) : myData( a )
        {
            myKey = (unsigned) a;
            myKey = UTwang_inthash(myKey);
        }

        ~UT_Hash_Int()
        {
        }

        int compare( const UT_Hash & a) const
        {
            return !(myData==((const UT_Hash_Int&)a).myData);
        }

        void            copy(const UT_Hash &a)
        {
            myData = static_cast<const UT_Hash_Int &>(a).myData;
            myKey = static_cast<const UT_Hash_Int &>(a).myKey;
        }

        unsigned        hash() const
        {
            return myKey;
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_Int( myData );
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this));
        }

        int             getData() const { return myData; }
};

class UT_API UT_Hash_Int64 : public UT_Hash {
    private:
        int64                   myData;
        uint64                  myKey;
    public:
        UT_Hash_Int64( int64 a ) : myData( a )
        {
            myKey = (uint64) a;
            myKey = UTwang_inthash64(myKey);
        }

        ~UT_Hash_Int64()
        {
        }

        int compare( const UT_Hash & a) const
        {
            return !(myData==((const UT_Hash_Int64&)a).myData);
        }

        void            copy(const UT_Hash &a)
        {
            myData = static_cast<const UT_Hash_Int64 &>(a).myData;
            myKey = static_cast<const UT_Hash_Int64 &>(a).myKey;
        }

        unsigned        hash() const
        {
            return myKey;
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_Int64( myData );
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this));
        }

        int64           getData() const { return myData; }
};

class UT_API UT_Hash_Ptr : public UT_Hash {
    private:
        const void      *myData;
    public:
        UT_Hash_Ptr( const void *p ) : myData(p)
        {
        }

        ~UT_Hash_Ptr()
        {
        }

        int compare(const UT_Hash &a) const
        {
            return !(myData==((const UT_Hash_Ptr&)a).myData);
        }

        void            copy(const UT_Hash &a)
        {
            myData = static_cast<const UT_Hash_Ptr &>(a).myData;
        }

        unsigned        hash() const
        {
            unsigned            key;
            key = SYSpointerHash(myData);
            key = UTwang_inthash(key);
            return key;
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_Ptr(myData);
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this));
        }

        operator const void *() const
        {
            return myData;
        }
        operator void *() const
        {
            return const_cast<void *>(myData);
        }
};

class UT_API UT_Hash_Const_Ptr : public UT_Hash {
    private:
        const void  *myData;
    public:
        UT_Hash_Const_Ptr( const void *p ) : myData(p)
        {
        }

        ~UT_Hash_Const_Ptr()
        {
        }

        int compare(const UT_Hash &a) const
        {
            return !(myData==((const UT_Hash_Const_Ptr&)a).myData);
        }

        void            copy(const UT_Hash &a)
        {
            myData = static_cast<const UT_Hash_Const_Ptr &>(a).myData;
        }

        unsigned        hash() const
        {
            unsigned            key;
            key = SYSpointerHash(myData);
            key = UTwang_inthash(key);
            return key;
        }

        UT_Hash*        copy() const
        {
            return new UT_Hash_Const_Ptr(myData);
        }

        int64 getMemUsage() const
        {
            return (sizeof(*this));
        }
};

#endif

---