TTErr TTEnvironment::registerClass(const TTSymbolPtr className, const TTString& tagString, const TTObjectInstantiationMethod anInstantiationMethod)
{
TTValue v((TTString&)tagString); // The tags to be associated with the class we are registering.
TTValue tagObjects; // Contains a TTList of objects in the environment with the given tag.
TTClassPtr theClass;
TTErr err;
TTList* classNamesForTag; // The TTList contained by tagObjects
TTUInt16 size;
TTSymbolPtr tag;
TTValue result;
err = classes->lookup(className, result);
// If a class is already registered with this name, then we do not want to register another class with the same name!
if (err == kTTErrValueNotFound) {
// 1. Turn the string into an array of symbols
v.transformCSVStringToSymbolArray();
// 2. Create the class and associate it with its name
theClass = new TTClass(className, v, anInstantiationMethod);
// 3. For each symbol in the TTValue array...
size = v.getSize();
for (TTUInt16 i=0; i<size; i++) {
v.get(i, &tag);
// 4. Look to see if this tag exists yet
err = tags->lookup(tag, tagObjects);
if (!err) {
classNamesForTag = (TTList*)(TTPtr(tagObjects));
// TODO: The following code demonstrates so extreme lameness that we need to evaluate.
// First, we should probably just do this section of code with TTValue instead of TTList (but we needed code to test TTList)
// Second, TTList is taking references but keeping things internally as pointers, which leads to lots of confusion
// Third, we have to pass objects that are permanent - so no temporaries are allowed unless we make TTList do a copy
// etc.
// TODO: We need to factor out a function to add a tag for a named class (or a given class ptr)
//classNamesForTag->append(className);
classNamesForTag->append(*new TTValue(className));
}
else {
classNamesForTag = new TTList;
tagObjects = TTPtr(classNamesForTag);
tags->append(tag ,tagObjects);
classNamesForTag->append(*new TTValue(className));
}
}
// 4. Register it
err = registerClass(theClass);
}
return err;
}
TTErr TTHash::getKeysSorted(TTValue& hashKeysSorted, TTBoolean(comparisonFunction)(TTValue&, TTValue&))
{
lock();
TTList listToSort;
TTValue v;
TTSymbol key;
// fill a list to sort
for (TTHashMapIter iter = HASHMAP->begin(); iter != HASHMAP->end(); iter++) {
TTPtrSizedInt a = iter->first;
TTSymbol b((TTSymbolBase*)a);
if (comparisonFunction) {
v = b; // the key
v.append(TTPtr(iter->second)); // a pointer to the stored value
listToSort.append(v);
}
else
listToSort.append(b);
}
listToSort.sort(comparisonFunction);
// fill the result
hashKeysSorted.clear();
for (listToSort.begin(); listToSort.end(); listToSort.next()) {
if (comparisonFunction) {
key = listToSort.current()[0];
hashKeysSorted.append(key);
}
else
hashKeysSorted.append(listToSort.current());
}
unlock();
return kTTErrNone;
}
