mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-13 03:33:48 +00:00
roll back changes to simFieldDictionary as it doesn't want to play nice and causing corruption
This commit is contained in:
Jeff Hutchinson
parent
d666322a1b
commit
c7e12d3be7
3 changed files with 1259 additions and 1269 deletions
|
|
@ -32,6 +32,10 @@
|
|||
#include "console/consoleInternal.h"
|
||||
#include "core/frameAllocator.h"
|
||||
|
||||
SimFieldDictionary::Entry *SimFieldDictionary::smFreeList = NULL;
|
||||
|
||||
static Chunker<SimFieldDictionary::Entry> fieldChunker;
|
||||
|
||||
U32 SimFieldDictionary::getHashValue(StringTableEntry slotName)
|
||||
{
|
||||
return HashPointer(slotName) % HashTableSize;
|
||||
|
|
@ -44,43 +48,58 @@ U32 SimFieldDictionary::getHashValue(const String& fieldName)
|
|||
|
||||
SimFieldDictionary::Entry *SimFieldDictionary::addEntry(U32 bucket, StringTableEntry slotName, ConsoleBaseType* type, char* value)
|
||||
{
|
||||
Entry ret;
|
||||
ret.slotName = slotName;
|
||||
ret.type = type;
|
||||
ret.value = value;
|
||||
Entry* ret;
|
||||
if (smFreeList)
|
||||
{
|
||||
ret = smFreeList;
|
||||
smFreeList = ret->next;
|
||||
}
|
||||
else
|
||||
ret = fieldChunker.alloc();
|
||||
|
||||
ret->next = mHashTable[bucket];
|
||||
ret->slotName = slotName;
|
||||
ret->type = type;
|
||||
ret->value = value;
|
||||
|
||||
mHashTable[bucket] = ret;
|
||||
mNumFields++;
|
||||
mVersion++;
|
||||
|
||||
mHashTable[bucket].push_back(std::move(ret));
|
||||
return &mHashTable[bucket].back();
|
||||
return ret;
|
||||
}
|
||||
|
||||
void SimFieldDictionary::freeEntry(SimFieldDictionary::Entry *ent)
|
||||
{
|
||||
auto &vec = mHashTable[getHashValue(ent->slotName)];
|
||||
ent->next = smFreeList;
|
||||
smFreeList = ent;
|
||||
|
||||
// Find the slot.
|
||||
auto iter = std::find_if(vec.begin(), vec.end(), [&](const Entry &ref) -> bool {
|
||||
return ref.slotName == ent->slotName;
|
||||
});
|
||||
if (iter != vec.end())
|
||||
{
|
||||
vec.erase(iter);
|
||||
mNumFields--;
|
||||
}
|
||||
mNumFields--;
|
||||
}
|
||||
|
||||
SimFieldDictionary::SimFieldDictionary()
|
||||
: mNumFields(0),
|
||||
mVersion(0)
|
||||
{
|
||||
|
||||
dMemset(mHashTable, 0, sizeof(mHashTable));
|
||||
}
|
||||
|
||||
SimFieldDictionary::~SimFieldDictionary()
|
||||
{
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (Entry *walk = mHashTable[i]; walk;)
|
||||
{
|
||||
Entry *temp = walk;
|
||||
walk = temp->next;
|
||||
|
||||
if (temp->value)
|
||||
dFree(temp->value);
|
||||
freeEntry(temp);
|
||||
}
|
||||
}
|
||||
|
||||
AssertFatal(mNumFields == 0, "Incorrect count on field dictionary");
|
||||
}
|
||||
|
||||
void SimFieldDictionary::setFieldType(StringTableEntry slotName, const char *typeString)
|
||||
|
|
@ -100,12 +119,12 @@ void SimFieldDictionary::setFieldType(StringTableEntry slotName, ConsoleBaseType
|
|||
// If the field exists on the object, set the type
|
||||
U32 bucket = getHashValue(slotName);
|
||||
|
||||
for (Entry &ref : mHashTable[bucket])
|
||||
for (Entry *walk = mHashTable[bucket]; walk; walk = walk->next)
|
||||
{
|
||||
if (ref.slotName == slotName)
|
||||
if (walk->slotName == slotName)
|
||||
{
|
||||
// Found and type assigned, let's bail
|
||||
ref.type = type;
|
||||
walk->type = type;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -118,14 +137,9 @@ U32 SimFieldDictionary::getFieldType(StringTableEntry slotName) const
|
|||
{
|
||||
U32 bucket = getHashValue(slotName);
|
||||
|
||||
const std::vector<Entry> &vec = mHashTable[bucket];
|
||||
size_t size = vec.size();
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
const Entry &ref = vec[i];
|
||||
if (ref.slotName == slotName)
|
||||
return ref.type ? ref.type->getTypeID() : TypeString;
|
||||
}
|
||||
for (Entry *walk = mHashTable[bucket]; walk; walk = walk->next)
|
||||
if (walk->slotName == slotName)
|
||||
return walk->type ? walk->type->getTypeID() : TypeString;
|
||||
|
||||
return TypeString;
|
||||
}
|
||||
|
|
@ -134,13 +148,10 @@ SimFieldDictionary::Entry *SimFieldDictionary::findDynamicField(const String &f
|
|||
{
|
||||
U32 bucket = getHashValue(fieldName);
|
||||
|
||||
const std::vector<Entry> &vec = mHashTable[bucket];
|
||||
size_t size = vec.size();
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
for (Entry *walk = mHashTable[bucket]; walk; walk = walk->next)
|
||||
{
|
||||
const Entry &ref = vec[i];
|
||||
if (fieldName.equal(ref.slotName, String::NoCase))
|
||||
return const_cast<Entry*>(&ref);
|
||||
if (fieldName.equal(walk->slotName, String::NoCase))
|
||||
return walk;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
|
@ -150,13 +161,11 @@ SimFieldDictionary::Entry *SimFieldDictionary::findDynamicField(StringTableEntry
|
|||
{
|
||||
U32 bucket = getHashValue(fieldName);
|
||||
|
||||
const std::vector<Entry> &vec = mHashTable[bucket];
|
||||
size_t size = vec.size();
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
for (Entry *walk = mHashTable[bucket]; walk; walk = walk->next)
|
||||
{
|
||||
if (vec[i].slotName == fieldName)
|
||||
if (walk->slotName == fieldName)
|
||||
{
|
||||
return const_cast<Entry*>(&vec[i]);
|
||||
return walk;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -167,43 +176,45 @@ SimFieldDictionary::Entry *SimFieldDictionary::findDynamicField(StringTableEntry
|
|||
void SimFieldDictionary::setFieldValue(StringTableEntry slotName, const char *value)
|
||||
{
|
||||
U32 bucket = getHashValue(slotName);
|
||||
Entry **walk = &mHashTable[bucket];
|
||||
while (*walk && (*walk)->slotName != slotName)
|
||||
walk = &((*walk)->next);
|
||||
|
||||
for (Entry &ref : mHashTable[bucket])
|
||||
Entry *field = *walk;
|
||||
if (!value || !*value)
|
||||
{
|
||||
if (ref.slotName == slotName)
|
||||
if (field)
|
||||
{
|
||||
if (!value || !*value)
|
||||
{
|
||||
mVersion++;
|
||||
mVersion++;
|
||||
|
||||
if (ref.value)
|
||||
dFree(ref.value);
|
||||
if (field->value)
|
||||
dFree(field->value);
|
||||
|
||||
freeEntry(&ref);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ref.value)
|
||||
dFree(ref.value);
|
||||
|
||||
ref.value = dStrdup(value);
|
||||
}
|
||||
|
||||
return;
|
||||
*walk = field->next;
|
||||
freeEntry(field);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (field)
|
||||
{
|
||||
if (field->value)
|
||||
dFree(field->value);
|
||||
|
||||
// no field, add entry.
|
||||
addEntry(bucket, slotName, 0, dStrdup(value));
|
||||
field->value = dStrdup(value);
|
||||
}
|
||||
else
|
||||
addEntry(bucket, slotName, 0, dStrdup(value));
|
||||
}
|
||||
}
|
||||
|
||||
const char *SimFieldDictionary::getFieldValue(StringTableEntry slotName)
|
||||
{
|
||||
U32 bucket = getHashValue(slotName);
|
||||
|
||||
for (const Entry &ref : mHashTable[bucket])
|
||||
if (ref.slotName == slotName)
|
||||
return ref.value;
|
||||
for (Entry *walk = mHashTable[bucket]; walk; walk = walk->next)
|
||||
if (walk->slotName == slotName)
|
||||
return walk->value;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -214,41 +225,41 @@ void SimFieldDictionary::assignFrom(SimFieldDictionary *dict)
|
|||
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (const Entry &ref : mHashTable[i])
|
||||
for (Entry *walk = dict->mHashTable[i]; walk; walk = walk->next)
|
||||
{
|
||||
setFieldValue(ref.slotName, ref.value);
|
||||
setFieldType(ref.slotName, ref.type);
|
||||
setFieldValue(walk->slotName, walk->value);
|
||||
setFieldType(walk->slotName, walk->type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static S32 QSORT_CALLBACK compareEntries(const void* a, const void* b)
|
||||
{
|
||||
const SimFieldDictionary::Entry *fa = reinterpret_cast<const SimFieldDictionary::Entry*>(a);
|
||||
const SimFieldDictionary::Entry *fb = reinterpret_cast<const SimFieldDictionary::Entry*>(b);
|
||||
SimFieldDictionary::Entry *fa = *((SimFieldDictionary::Entry **)a);
|
||||
SimFieldDictionary::Entry *fb = *((SimFieldDictionary::Entry **)b);
|
||||
return dStricmp(fa->slotName, fb->slotName);
|
||||
}
|
||||
|
||||
void SimFieldDictionary::writeFields(SimObject *obj, Stream &stream, U32 tabStop)
|
||||
{
|
||||
const AbstractClassRep::FieldList &list = obj->getFieldList();
|
||||
Vector<Entry> flist(__FILE__, __LINE__);
|
||||
Vector<Entry *> flist(__FILE__, __LINE__);
|
||||
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (const Entry &walk : mHashTable[i])
|
||||
for (Entry *walk = mHashTable[i]; walk; walk = walk->next)
|
||||
{
|
||||
// make sure we haven't written this out yet:
|
||||
U32 j;
|
||||
for (j = 0; j < list.size(); j++)
|
||||
if (list[j].pFieldname == walk.slotName)
|
||||
U32 i;
|
||||
for (i = 0; i < list.size(); i++)
|
||||
if (list[i].pFieldname == walk->slotName)
|
||||
break;
|
||||
|
||||
if (j != list.size())
|
||||
if (i != list.size())
|
||||
continue;
|
||||
|
||||
|
||||
if (!obj->writeField(walk.slotName, walk.value))
|
||||
if (!obj->writeField(walk->slotName, walk->value))
|
||||
continue;
|
||||
|
||||
flist.push_back(walk);
|
||||
|
|
@ -256,20 +267,20 @@ void SimFieldDictionary::writeFields(SimObject *obj, Stream &stream, U32 tabStop
|
|||
}
|
||||
|
||||
// Sort Entries to prevent version control conflicts
|
||||
dQsort(flist.address(), flist.size(), sizeof(Entry), compareEntries);
|
||||
dQsort(flist.address(), flist.size(), sizeof(Entry *), compareEntries);
|
||||
|
||||
// Save them out
|
||||
for (const Entry &ref : flist)
|
||||
for (Vector<Entry *>::iterator itr = flist.begin(); itr != flist.end(); itr++)
|
||||
{
|
||||
U32 nBufferSize = (dStrlen(ref.value) * 2) + dStrlen(ref.slotName) + 16;
|
||||
U32 nBufferSize = (dStrlen((*itr)->value) * 2) + dStrlen((*itr)->slotName) + 16;
|
||||
FrameTemp<char> expandedBuffer(nBufferSize);
|
||||
|
||||
stream.writeTabs(tabStop + 1);
|
||||
|
||||
const char *typeName = ref.type && ref.type->getTypeID() != TypeString ? ref.type->getTypeName() : "";
|
||||
dSprintf(expandedBuffer, nBufferSize, "%s%s%s = \"", typeName, *typeName ? " " : "", ref.slotName);
|
||||
if (ref.value)
|
||||
expandEscape((char*)expandedBuffer + dStrlen(expandedBuffer), ref.value);
|
||||
const char *typeName = (*itr)->type && (*itr)->type->getTypeID() != TypeString ? (*itr)->type->getTypeName() : "";
|
||||
dSprintf(expandedBuffer, nBufferSize, "%s%s%s = \"", typeName, *typeName ? " " : "", (*itr)->slotName);
|
||||
if ((*itr)->value)
|
||||
expandEscape((char*)expandedBuffer + dStrlen(expandedBuffer), (*itr)->value);
|
||||
dStrcat(expandedBuffer, "\";\r\n");
|
||||
|
||||
stream.write(dStrlen(expandedBuffer), expandedBuffer);
|
||||
|
|
@ -280,35 +291,35 @@ void SimFieldDictionary::printFields(SimObject *obj)
|
|||
{
|
||||
const AbstractClassRep::FieldList &list = obj->getFieldList();
|
||||
char expandedBuffer[4096];
|
||||
Vector<Entry> flist(__FILE__, __LINE__);
|
||||
Vector<Entry *> flist(__FILE__, __LINE__);
|
||||
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (const Entry &walk : mHashTable[i])
|
||||
for (Entry *walk = mHashTable[i]; walk; walk = walk->next)
|
||||
{
|
||||
// make sure we haven't written this out yet:
|
||||
U32 j;
|
||||
for (j = 0; j < list.size(); j++)
|
||||
if (list[i].pFieldname == walk.slotName)
|
||||
U32 i;
|
||||
for (i = 0; i < list.size(); i++)
|
||||
if (list[i].pFieldname == walk->slotName)
|
||||
break;
|
||||
|
||||
if (j != list.size())
|
||||
if (i != list.size())
|
||||
continue;
|
||||
|
||||
flist.push_back(walk);
|
||||
}
|
||||
}
|
||||
dQsort(flist.address(), flist.size(), sizeof(Entry), compareEntries);
|
||||
dQsort(flist.address(), flist.size(), sizeof(Entry *), compareEntries);
|
||||
|
||||
for (const Entry &ref : flist)
|
||||
for (Vector<Entry *>::iterator itr = flist.begin(); itr != flist.end(); itr++)
|
||||
{
|
||||
const char* type = "string";
|
||||
if (ref.type)
|
||||
type = ref.type->getTypeClassName();
|
||||
if ((*itr)->type)
|
||||
type = (*itr)->type->getTypeClassName();
|
||||
|
||||
dSprintf(expandedBuffer, sizeof(expandedBuffer), " %s %s = \"", type, ref.slotName);
|
||||
if (ref.value)
|
||||
expandEscape(expandedBuffer + dStrlen(expandedBuffer), ref.value);
|
||||
dSprintf(expandedBuffer, sizeof(expandedBuffer), " %s %s = \"", type, (*itr)->slotName);
|
||||
if ((*itr)->value)
|
||||
expandEscape(expandedBuffer + dStrlen(expandedBuffer), (*itr)->value);
|
||||
Con::printf("%s\"", expandedBuffer);
|
||||
}
|
||||
}
|
||||
|
|
@ -332,44 +343,29 @@ SimFieldDictionary::Entry *SimFieldDictionary::operator[](U32 index)
|
|||
SimFieldDictionaryIterator::SimFieldDictionaryIterator(SimFieldDictionary * dictionary)
|
||||
{
|
||||
mDictionary = dictionary;
|
||||
mHashIndex = 0;
|
||||
mVecIndex = -1; // -1 since we immediately call operator++
|
||||
mEntry = NULL;
|
||||
mHashIndex = -1;
|
||||
mEntry = 0;
|
||||
operator++();
|
||||
}
|
||||
|
||||
SimFieldDictionary::Entry* SimFieldDictionaryIterator::operator++()
|
||||
{
|
||||
if (!mDictionary || mHashIndex >= SimFieldDictionary::HashTableSize)
|
||||
{
|
||||
mEntry = NULL;
|
||||
return NULL;
|
||||
}
|
||||
if (!mDictionary)
|
||||
return(mEntry);
|
||||
|
||||
std::vector<SimFieldDictionary::Entry> &vec = mDictionary->mHashTable[mHashIndex];
|
||||
if (mEntry)
|
||||
mEntry = mEntry->next;
|
||||
|
||||
while (vec.size() == 0 && mHashIndex < (SimFieldDictionary::HashTableSize - 1))
|
||||
{
|
||||
vec = mDictionary->mHashTable[++mHashIndex];
|
||||
mVecIndex = 0;
|
||||
}
|
||||
while (!mEntry && (mHashIndex < (SimFieldDictionary::HashTableSize - 1)))
|
||||
mEntry = mDictionary->mHashTable[++mHashIndex];
|
||||
|
||||
if (mVecIndex >= vec.size() || mHashIndex >= SimFieldDictionary::HashTableSize)
|
||||
{
|
||||
mEntry = NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mEntry = &vec[mVecIndex];
|
||||
++mVecIndex;
|
||||
return mEntry;
|
||||
return(mEntry);
|
||||
}
|
||||
|
||||
SimFieldDictionary::Entry* SimFieldDictionaryIterator::operator*()
|
||||
{
|
||||
return mEntry;
|
||||
return(mEntry);
|
||||
}
|
||||
|
||||
// A variation of the stock SimFieldDictionary::setFieldValue(), this method adds the
|
||||
// <no_replace> argument which, when true, prohibits the replacement of fields that
|
||||
// already have a value.
|
||||
|
|
@ -389,13 +385,13 @@ void SimFieldDictionary::setFieldValue(StringTableEntry slotName, const char *va
|
|||
return;
|
||||
|
||||
U32 bucket = getHashValue(slotName);
|
||||
for (const Entry &walk : mHashTable[bucket])
|
||||
{
|
||||
if (walk.slotName == slotName)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
Entry **walk = &mHashTable[bucket];
|
||||
while (*walk && (*walk)->slotName != slotName)
|
||||
walk = &((*walk)->next);
|
||||
|
||||
Entry *field = *walk;
|
||||
if (field)
|
||||
return;
|
||||
|
||||
addEntry(bucket, slotName, type, dStrdup(value));
|
||||
}
|
||||
|
|
@ -417,22 +413,14 @@ void SimFieldDictionary::assignFrom(SimFieldDictionary *dict, const char* filter
|
|||
if (filter_len == 0)
|
||||
{
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (const Entry &walk : dict->mHashTable[i])
|
||||
{
|
||||
setFieldValue(walk.slotName, walk.value, walk.type, no_replace);
|
||||
}
|
||||
}
|
||||
for (Entry *walk = dict->mHashTable[i]; walk; walk = walk->next)
|
||||
setFieldValue(walk->slotName, walk->value, walk->type, no_replace);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (U32 i = 0; i < HashTableSize; i++)
|
||||
{
|
||||
for (const Entry &walk : dict->mHashTable[i])
|
||||
{
|
||||
if (dStrncmp(walk.slotName, filter, filter_len) == 0)
|
||||
setFieldValue(walk.slotName, walk.value, walk.type, no_replace);
|
||||
}
|
||||
}
|
||||
for (Entry *walk = dict->mHashTable[i]; walk; walk = walk->next)
|
||||
if (dStrncmp(walk->slotName, filter, filter_len) == 0)
|
||||
setFieldValue(walk->slotName, walk->value, walk->type, no_replace);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue