mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 12:44:46 +00:00
438 lines
12 KiB
C++
438 lines
12 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
|
|
// Copyright (C) 2015 Faust Logic, Inc.
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
|
|
#include "platform/platform.h"
|
|
#include "console/simFieldDictionary.h"
|
|
|
|
#include "console/console.h"
|
|
#include "console/consoleInternal.h"
|
|
#include "core/frameAllocator.h"
|
|
|
|
U32 SimFieldDictionary::getHashValue(StringTableEntry slotName)
|
|
{
|
|
return HashPointer(slotName) % HashTableSize;
|
|
}
|
|
|
|
U32 SimFieldDictionary::getHashValue(const String& fieldName)
|
|
{
|
|
return getHashValue(StringTable->insert(fieldName));
|
|
}
|
|
|
|
SimFieldDictionary::Entry *SimFieldDictionary::addEntry(U32 bucket, StringTableEntry slotName, ConsoleBaseType* type, char* value)
|
|
{
|
|
Entry ret;
|
|
ret.slotName = slotName;
|
|
ret.type = type;
|
|
ret.value = value;
|
|
|
|
mNumFields++;
|
|
mVersion++;
|
|
|
|
mHashTable[bucket].push_back(std::move(ret));
|
|
return &mHashTable[bucket].back();
|
|
}
|
|
|
|
void SimFieldDictionary::freeEntry(SimFieldDictionary::Entry *ent)
|
|
{
|
|
auto &vec = mHashTable[getHashValue(ent->slotName)];
|
|
|
|
// 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--;
|
|
}
|
|
}
|
|
|
|
SimFieldDictionary::SimFieldDictionary()
|
|
: mNumFields(0),
|
|
mVersion(0)
|
|
{
|
|
|
|
}
|
|
|
|
SimFieldDictionary::~SimFieldDictionary()
|
|
{
|
|
|
|
}
|
|
|
|
void SimFieldDictionary::setFieldType(StringTableEntry slotName, const char *typeString)
|
|
{
|
|
ConsoleBaseType *cbt = ConsoleBaseType::getTypeByName(typeString);
|
|
setFieldType(slotName, cbt);
|
|
}
|
|
|
|
void SimFieldDictionary::setFieldType(StringTableEntry slotName, const U32 typeId)
|
|
{
|
|
ConsoleBaseType *cbt = ConsoleBaseType::getType(typeId);
|
|
setFieldType(slotName, cbt);
|
|
}
|
|
|
|
void SimFieldDictionary::setFieldType(StringTableEntry slotName, ConsoleBaseType *type)
|
|
{
|
|
// If the field exists on the object, set the type
|
|
U32 bucket = getHashValue(slotName);
|
|
|
|
for (Entry &ref : mHashTable[bucket])
|
|
{
|
|
if (ref.slotName == slotName)
|
|
{
|
|
// Found and type assigned, let's bail
|
|
ref.type = type;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Otherwise create the field, and set the type. Assign a null value.
|
|
addEntry(bucket, slotName, type);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
return TypeString;
|
|
}
|
|
|
|
SimFieldDictionary::Entry *SimFieldDictionary::findDynamicField(const String &fieldName) const
|
|
{
|
|
U32 bucket = getHashValue(fieldName);
|
|
|
|
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 (fieldName.equal(ref.slotName, String::NoCase))
|
|
return const_cast<Entry*>(&ref);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
SimFieldDictionary::Entry *SimFieldDictionary::findDynamicField(StringTableEntry fieldName) const
|
|
{
|
|
U32 bucket = getHashValue(fieldName);
|
|
|
|
const std::vector<Entry> &vec = mHashTable[bucket];
|
|
size_t size = vec.size();
|
|
for (size_t i = 0; i < size; ++i)
|
|
{
|
|
if (vec[i].slotName == fieldName)
|
|
{
|
|
return const_cast<Entry*>(&vec[i]);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void SimFieldDictionary::setFieldValue(StringTableEntry slotName, const char *value)
|
|
{
|
|
U32 bucket = getHashValue(slotName);
|
|
|
|
for (Entry &ref : mHashTable[bucket])
|
|
{
|
|
if (ref.slotName == slotName)
|
|
{
|
|
if (!value || !*value)
|
|
{
|
|
mVersion++;
|
|
|
|
if (ref.value)
|
|
dFree(ref.value);
|
|
|
|
freeEntry(&ref);
|
|
}
|
|
else
|
|
{
|
|
if (ref.value)
|
|
dFree(ref.value);
|
|
|
|
ref.value = dStrdup(value);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// no field, add entry.
|
|
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;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void SimFieldDictionary::assignFrom(SimFieldDictionary *dict)
|
|
{
|
|
mVersion++;
|
|
|
|
for (U32 i = 0; i < HashTableSize; i++)
|
|
{
|
|
for (const Entry &ref : mHashTable[i])
|
|
{
|
|
setFieldValue(ref.slotName, ref.value);
|
|
setFieldType(ref.slotName, ref.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);
|
|
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__);
|
|
|
|
for (U32 i = 0; i < HashTableSize; i++)
|
|
{
|
|
for (const Entry &walk : mHashTable[i])
|
|
{
|
|
// make sure we haven't written this out yet:
|
|
U32 j;
|
|
for (j = 0; j < list.size(); j++)
|
|
if (list[j].pFieldname == walk.slotName)
|
|
break;
|
|
|
|
if (j != list.size())
|
|
continue;
|
|
|
|
|
|
if (!obj->writeField(walk.slotName, walk.value))
|
|
continue;
|
|
|
|
flist.push_back(walk);
|
|
}
|
|
}
|
|
|
|
// Sort Entries to prevent version control conflicts
|
|
dQsort(flist.address(), flist.size(), sizeof(Entry), compareEntries);
|
|
|
|
// Save them out
|
|
for (const Entry &ref : flist)
|
|
{
|
|
U32 nBufferSize = (dStrlen(ref.value) * 2) + dStrlen(ref.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);
|
|
dStrcat(expandedBuffer, "\";\r\n");
|
|
|
|
stream.write(dStrlen(expandedBuffer), expandedBuffer);
|
|
}
|
|
|
|
}
|
|
void SimFieldDictionary::printFields(SimObject *obj)
|
|
{
|
|
const AbstractClassRep::FieldList &list = obj->getFieldList();
|
|
char expandedBuffer[4096];
|
|
Vector<Entry> flist(__FILE__, __LINE__);
|
|
|
|
for (U32 i = 0; i < HashTableSize; i++)
|
|
{
|
|
for (const Entry &walk : mHashTable[i])
|
|
{
|
|
// make sure we haven't written this out yet:
|
|
U32 j;
|
|
for (j = 0; j < list.size(); j++)
|
|
if (list[i].pFieldname == walk.slotName)
|
|
break;
|
|
|
|
if (j != list.size())
|
|
continue;
|
|
|
|
flist.push_back(walk);
|
|
}
|
|
}
|
|
dQsort(flist.address(), flist.size(), sizeof(Entry), compareEntries);
|
|
|
|
for (const Entry &ref : flist)
|
|
{
|
|
const char* type = "string";
|
|
if (ref.type)
|
|
type = ref.type->getTypeClassName();
|
|
|
|
dSprintf(expandedBuffer, sizeof(expandedBuffer), " %s %s = \"", type, ref.slotName);
|
|
if (ref.value)
|
|
expandEscape(expandedBuffer + dStrlen(expandedBuffer), ref.value);
|
|
Con::printf("%s\"", expandedBuffer);
|
|
}
|
|
}
|
|
|
|
SimFieldDictionary::Entry *SimFieldDictionary::operator[](U32 index)
|
|
{
|
|
AssertFatal(index < mNumFields, "out of range");
|
|
|
|
if (index > mNumFields)
|
|
return NULL;
|
|
|
|
SimFieldDictionaryIterator itr(this);
|
|
|
|
for (S32 i = 0; i < index && *itr; i++)
|
|
++itr;
|
|
|
|
return (*itr);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SimFieldDictionaryIterator::SimFieldDictionaryIterator(SimFieldDictionary * dictionary)
|
|
{
|
|
mDictionary = dictionary;
|
|
mHashIndex = 0;
|
|
mVecIndex = -1; // -1 since we immediately call operator++
|
|
mEntry = NULL;
|
|
operator++();
|
|
}
|
|
|
|
SimFieldDictionary::Entry* SimFieldDictionaryIterator::operator++()
|
|
{
|
|
if (!mDictionary || mHashIndex >= SimFieldDictionary::HashTableSize)
|
|
{
|
|
mEntry = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
std::vector<SimFieldDictionary::Entry> &vec = mDictionary->mHashTable[mHashIndex];
|
|
|
|
while (vec.size() == 0 && mHashIndex < (SimFieldDictionary::HashTableSize - 1))
|
|
{
|
|
vec = mDictionary->mHashTable[++mHashIndex];
|
|
mVecIndex = 0;
|
|
}
|
|
|
|
if (mVecIndex >= vec.size() || mHashIndex >= SimFieldDictionary::HashTableSize)
|
|
{
|
|
mEntry = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
mEntry = &vec[mVecIndex];
|
|
++mVecIndex;
|
|
return mEntry;
|
|
}
|
|
|
|
SimFieldDictionary::Entry* SimFieldDictionaryIterator::operator*()
|
|
{
|
|
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.
|
|
//
|
|
// AFX uses this when an effects-choreographer (afxMagicSpell, afxEffectron) is created
|
|
// using the new operator. It prevents any in-line effect parameters from being overwritten
|
|
// by default parameters that are copied over later.
|
|
void SimFieldDictionary::setFieldValue(StringTableEntry slotName, const char *value, ConsoleBaseType *type, bool no_replace)
|
|
{
|
|
if (!no_replace)
|
|
{
|
|
setFieldValue(slotName, value);
|
|
return;
|
|
}
|
|
|
|
if (!value || !*value)
|
|
return;
|
|
|
|
U32 bucket = getHashValue(slotName);
|
|
for (const Entry &walk : mHashTable[bucket])
|
|
{
|
|
if (walk.slotName == slotName)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
addEntry(bucket, slotName, type, dStrdup(value));
|
|
}
|
|
// A variation of the stock SimFieldDictionary::assignFrom(), this method adds <no_replace>
|
|
// and <filter> arguments. When true, <no_replace> prohibits the replacement of fields that already
|
|
// have a value. When <filter> is specified, only fields with leading characters that exactly match
|
|
// the characters in <filter> are copied.
|
|
void SimFieldDictionary::assignFrom(SimFieldDictionary *dict, const char* filter, bool no_replace)
|
|
{
|
|
dsize_t filter_len = (filter) ? dStrlen(filter) : 0;
|
|
if (filter_len == 0 && !no_replace)
|
|
{
|
|
assignFrom(dict);
|
|
return;
|
|
}
|
|
|
|
mVersion++;
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
} |