llstringtable.cpp

Go to the documentation of this file.

#include "linden_common.h"

#include "llstringtable.h"
#include "llstl.h"

LLStringTable gStringTable(32768);

LLStringTable::LLStringTable(int tablesize)
: mUniqueEntries(0)
{
        S32 i;
        if (!tablesize)
                tablesize = 4096; // some arbitrary default
        // Make sure tablesize is power of 2
        for (i = 31; i>0; i--)
        {
                if (tablesize & (1<<i))
                {
                        if (tablesize >= (3<<(i-1)))
                                tablesize = (1<<(i+1));
                        else
                                tablesize = (1<<i);
                        break;
                }
        }
        mMaxEntries = tablesize;

#if !STRING_TABLE_HASH_MAP
        // ALlocate strings
        mStringList = new string_list_ptr_t[mMaxEntries];
        // Clear strings
        for (i = 0; i < mMaxEntries; i++)
        {
                mStringList[i] = NULL;
        }
#endif
}

LLStringTable::~LLStringTable()
{
#if !STRING_TABLE_HASH_MAP
        if (mStringList)
        {
                for (S32 i = 0; i < mMaxEntries; i++)
                {
                        if (mStringList[i])
                        {
                                string_list_t::iterator iter;
                                for (iter = mStringList[i]->begin(); iter != mStringList[i]->end(); iter++)
                                        delete *iter; // *iter = (LLStringTableEntry*)
                        }
                        delete mStringList[i];
                }
                delete [] mStringList;
                mStringList = NULL;
        }
#else
        // Need to clean up the string hash
        for_each(mStringHash.begin(), mStringHash.end(), DeletePairedPointer());
        mStringHash.clear();
#endif
}


static U32 hash_my_string(const char *str, int max_entries)
{
        U32 retval = 0;
#if 0
        while (*str)
        {
                retval <<= 1;
                retval += *str++;
        }
#else
        while (*str)
        {
                retval = (retval<<4) + *str;
                U32 x = (retval & 0xf0000000);
                if (x) retval = retval ^ (x>>24);
                retval = retval & (~x);
                str++;
        }
#endif
        return (retval & (max_entries-1)); // max_entries is gauranteed to be power of 2
}

char* LLStringTable::checkString(const std::string& str)
{
        return checkString(str.c_str());
}

char* LLStringTable::checkString(const char *str)
{
    LLStringTableEntry* entry = checkStringEntry(str);
    if (entry)
    {
        return entry->mString;
    }
    else
    {
        return NULL;
    }
}

LLStringTableEntry* LLStringTable::checkStringEntry(const std::string& str)
{
    return checkStringEntry(str.c_str());
}

LLStringTableEntry* LLStringTable::checkStringEntry(const char *str)
{
        if (str)
        {
                char *ret_val;
                LLStringTableEntry      *entry;
                U32                                     hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
#if 1 // Microsoft
                string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
                string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
#else // stlport
                std::pair<string_hash_t::iterator, string_hash_t::iterator> P = mStringHash.equal_range(hash_value);
                string_hash_t::iterator lower = P.first;
                string_hash_t::iterator upper = P.second;
#endif
                for (string_hash_t::iterator iter = lower; iter != upper; iter++)
                {
                        entry = iter->second;
                        ret_val = entry->mString;
                        if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                        {
                                return entry;
                        }
                }
#else
                string_list_t           *strlist = mStringList[hash_value];
                if (strlist)
                {
                        string_list_t::iterator iter;
                        for (iter = strlist->begin(); iter != strlist->end(); iter++)
                        {
                                entry = *iter;
                                ret_val = entry->mString;
                                if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                                {
                                        return entry;
                                }
                        }
                }
#endif
        }
        return NULL;
}

char* LLStringTable::addString(const std::string& str)
{
        //RN: safe to use temporary c_str since string is copied
        return addString(str.c_str());
}

char* LLStringTable::addString(const char *str)
{

    LLStringTableEntry* entry = addStringEntry(str);
    if (entry)
    {
        return entry->mString;
    }
    else
    {
        return NULL;
    }
}

LLStringTableEntry* LLStringTable::addStringEntry(const std::string& str)
{
    return addStringEntry(str.c_str());
}

LLStringTableEntry* LLStringTable::addStringEntry(const char *str)
{
        if (str)
        {
                char *ret_val = NULL;
                LLStringTableEntry      *entry;
                U32                                     hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
#if 1 // Microsoft
                string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
                string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
#else // stlport
                std::pair<string_hash_t::iterator, string_hash_t::iterator> P = mStringHash.equal_range(hash_value);
                string_hash_t::iterator lower = P.first;
                string_hash_t::iterator upper = P.second;
#endif
                for (string_hash_t::iterator iter = lower; iter != upper; iter++)
                {
                        entry = iter->second;
                        ret_val = entry->mString;
                        if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                        {
                                entry->incCount();
                                return entry;
                        }
                }

                // not found, so add!
                LLStringTableEntry* newentry = new LLStringTableEntry(str);
                ret_val = newentry->mString;
                mStringHash.insert(string_hash_t::value_type(hash_value, newentry));
#else
                string_list_t           *strlist = mStringList[hash_value];

                if (strlist)
                {
                        string_list_t::iterator iter;
                        for (iter = strlist->begin(); iter != strlist->end(); iter++)
                        {
                                entry = *iter;
                                ret_val = entry->mString;
                                if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                                {
                                        entry->incCount();
                                        return entry;
                                }
                        }
                }
                else
                {
                        mStringList[hash_value] = new string_list_t;
                        strlist = mStringList[hash_value];
                }

                // not found, so add!
                LLStringTableEntry *newentry = new LLStringTableEntry(str);
                //ret_val = newentry->mString;
                strlist->push_front(newentry);
#endif
                mUniqueEntries++;
                return newentry;
        }
        else
        {
                return NULL;
        }
}

void LLStringTable::removeString(const char *str)
{
        if (str)
        {
                char *ret_val;
                LLStringTableEntry      *entry;
                U32                                     hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
                {
#if 1 // Microsoft
                        string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
                        string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
#else // stlport
                        std::pair<string_hash_t::iterator, string_hash_t::iterator> P = mStringHash.equal_range(hash_value);
                        string_hash_t::iterator lower = P.first;
                        string_hash_t::iterator upper = P.second;
#endif
                        for (string_hash_t::iterator iter = lower; iter != upper; iter++)
                        {
                                entry = iter->second;
                                ret_val = entry->mString;
                                if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                                {
                                        if (!entry->decCount())
                                        {
                                                mUniqueEntries--;
                                                if (mUniqueEntries < 0)
                                                {
                                                        llerror("LLStringTable:removeString trying to remove too many strings!", 0);
                                                }
                                                delete iter->second;
                                                mStringHash.erase(iter);
                                        }
                                        return;
                                }
                        }
                }
#else
                string_list_t           *strlist = mStringList[hash_value];

                if (strlist)
                {
                        string_list_t::iterator iter;
                        for (iter = strlist->begin(); iter != strlist->end(); iter++)
                        {
                                entry = *iter;
                                ret_val = entry->mString;
                                if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
                                {
                                        if (!entry->decCount())
                                        {
                                                mUniqueEntries--;
                                                if (mUniqueEntries < 0)
                                                {
                                                        llerror("LLStringTable:removeString trying to remove too many strings!", 0);
                                                }
                                                strlist->remove(entry);
                                                delete entry;
                                        }
                                        return;
                                }
                        }
                }
#endif
        }
}

---