/*============================================
SUMiscUtils::LinkListenerToControls
Note:
This is the same as the UReanimator method, but this will work with
any broadcaster instead of just LControl.
==============================================*/
void SUMiscUtils::LinkListenerToControls(
LListener *inListener,
LView *inControlContainer,
ResIDT inResListID)
{
#pragma options align=mac68k
typedef struct {
SInt16 numberOfItems;
PaneIDT itemID[1];
} SResList, *SResListP;
#pragma options align=reset
StResource idList('RidL', inResListID);
HLockHi(idList.mResourceH);
SResListP resListP = (SResListP) *idList.mResourceH;
for (SInt16 i = 0; i < resListP->numberOfItems; i++)
{
LPane* thePane = inControlContainer->FindPaneByID(resListP->itemID[i] ) ;
LBroadcaster *theBroad = dynamic_cast<LBroadcaster*>(thePane);
if (theBroad != nil) {
theBroad->AddListener( inListener );
}
}
}
void hash_index_object_t::test<3>()
{
LLUUIDHashMap<UUIDTableEntry, 5> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
const int numElementsToCheck = 10;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id = idList[i];
// set new entry with value = i+numElementsToCheck
UUIDTableEntry entry(id, i+numElementsToCheck);
hashTable.set(id, entry);
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
ensure("set/get did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)(i+numElementsToCheck));
}
}
void datalogProgram ::scheme(){
predicate mypredicate;
if (tokens.at(vecIndex).getTokenType() == ID){
mypredicate.ident = tokens.at(vecIndex).getText();
match(ID);
match(LEFT_PAREN);
if (tokens.at(vecIndex).getTokenType() == ID){
parameter aParam;
aParam.textValue =tokens.at(vecIndex).getText();
match(ID);
mypredicate.myParameters.push_back(aParam);
idList(mypredicate.myParameters);
match(RIGHT_PAREN);
schemes.push_back(mypredicate);
}
else{
if (currentStatus == true){
currentStatus = false;
falseTok = tokens.at(vecIndex);
}
}
}
else{
if (currentStatus == true){
currentStatus = false;
falseTok = tokens.at(vecIndex);
}
}
}
void hash_index_object_t::test<6>()
{
LLUUIDHashMap<UUIDTableEntry, 2> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
LLUUIDHashMapIter<UUIDTableEntry, 2> hashIter(&hashTable);
const int numElementsToCheck = 256;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
// LLUUIDHashMap uses mData[0] to pick the bucket
// overwrite mData[0] so that it ranges from 0 to 255
// to create a sparse map
id.mData[0] = i;
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
hashIter.first();
int numElementsIterated = 0;
while(!hashIter.done())
{
numElementsIterated++;
UUIDTableEntry tableEntry = *hashIter;
LLUUID id = tableEntry.getID();
hashIter.next();
ensure("Iteration failed for sparse map", tableEntry.getValue() < (size_t)numElementsToCheck && idList[tableEntry.getValue()] == tableEntry.getID());
}
ensure("iteration count failed", numElementsIterated == numElementsToCheck);
}
void hash_index_object_t::test<7>()
{
LLUUIDHashMap<UUIDTableEntry, 2> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
LLUUIDHashMapIter<UUIDTableEntry, 2> hashIter(&hashTable);
const int numElementsToCheck = 256;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
LLUUID uuidtoSearch;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
// LLUUIDHashMap uses mData[0] to pick the bucket
// overwrite mData[0] so that it ranges from 0 to 255
// to create a sparse map
id.mData[0] = i;
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
// pick uuid somewhere in the middle
if (i == 5)
{
uuidtoSearch = id;
}
}
hashIter.first();
int numElementsIterated = 0;
while(!hashIter.done())
{
numElementsIterated++;
UUIDTableEntry tableEntry = *hashIter;
LLUUID id = tableEntry.getID();
if (uuidtoSearch == id)
{
break;
}
hashIter.next();
}
// current iterator implementation will not allow any remove operations
// until ALL elements have been iterated over. this seems to be
// an unnecessary restriction. Iterator should have a method to
// reset() its state so that further operations (inckuding remove)
// can be performed on the HashMap without having to iterate thru
// all the remaining nodes.
// hashIter.reset();
// hashTable.remove(uuidtoSearch);
// ensure("remove after iteration reset failed", hashTable.check(uuidtoSearch) == FALSE);
}
void datalogProgram ::idList(vector<parameter>& myParams){
if (tokens.at(vecIndex).getTokenType() == COMMA){
match (COMMA);
parameter aParam;
aParam.textValue = tokens.at(vecIndex).getText();
myParams.push_back(aParam);
match(ID);
idList(myParams);
}
else if(tokens.at(vecIndex).getTokenType() == RIGHT_PAREN){}
else{
if (currentStatus == true){
currentStatus = false;
falseTok = tokens.at(vecIndex);
}
}
}
list<int>* ClassifBPlusTree::searchAllIds(Key k){
pair<Record*, BPlusTreeIterator*> searchResult = BPlusTree::search(k);
list<int>* toReturn = new list<int>;
if(searchResult.first != NULL){
int listOffset = searchResult.first->getData()->readAsInt(0);
ListofID idList(this->fileBlockManager, listOffset);
list<int>::iterator it;
list<int> listOfIds = idList.getListID();
for(it=listOfIds.begin();it!=listOfIds.end();++it)
{
int current = *it;
toReturn->push_back(current);
}
}
return toReturn;
}
void statement () {
std::cout << "\nIn statement\n";
nextToken = getNextToken();
switch (nextToken) {
case (scanner::Id) :
ident ();
match (scanner::AssignOp);
expression();
match (scanner::SemiColon);
break;
case (scanner::ReadSym) :
match (scanner::ReadSym);
match (scanner::LParen);
idList();
match (scanner::RParen);
match (scanner::SemiColon);
break;
case (scanner::WriteSym) :
match (scanner::WriteSym);
match (scanner::LParen);
exprList ();
match (scanner::RParen);
match (scanner::SemiColon);
break;
default:
syntaxError (nextToken);
}
std::cout << "\nEnd statement\n";
}
void idList () {
std::cout << "\nIn idList\n";
ident();
nextToken = getNextToken();
if (nextToken == scanner::Comma) {
match(scanner::Comma);
idList();
}
std::cout << "\nEnd idList\n";
}
void datalogProgram ::headPred(predicate &headPredicate){
if (tokens.at(vecIndex).getTokenType() == ID){
headPredicate.ident = tokens.at(vecIndex).getText();
match(ID);
match(LEFT_PAREN);
parameter aParam;
aParam.textValue =tokens.at(vecIndex).getText();
headPredicate.myParameters.push_back(aParam);
match(ID);
idList(headPredicate.myParameters);
match(RIGHT_PAREN);
}
else{
if (currentStatus == true){
currentStatus = false;
falseTok = tokens.at(vecIndex);
}
}
}
void hash_index_object_t::test<4>()
{
LLUUIDHashMap<UUIDTableEntry, 5> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
const int numElementsToCheck = 10;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
hashTable.removeAll();
ensure("removeAll failed", hashTable.getLength() == 0);
}
void hash_index_object_t::test<2>()
{
LLUUIDHashMap<UUIDTableEntry, 2> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
const int numElementsToCheck = 5;
std::vector<LLUUID> idList(numElementsToCheck*10);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
ensure("getLength failed", hashTable.getLength() == numElementsToCheck);
// remove all but the last element
for (i = 0; i < numElementsToCheck-1; i++)
{
LLUUID idToCheck = idList[i];
hashTable.remove(idToCheck);
}
// there should only be one element left now.
ensure("getLength failed", hashTable.getLength() == 1);
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
if (i != numElementsToCheck - 1)
{
ensure("remove did not work", hashTable.check(idToCheck) == FALSE);
}
else
{
UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
ensure("remove did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
}
}
}
bool ClassifBPlusTree::removeKey(Key key,int idToRemove)
{
bool toReturn;
pair<Record*, BPlusTreeIterator*> searchResult = BPlusTree::search(key);
if(searchResult.first != NULL)
{
int listOffset = searchResult.first->getData()->readAsInt(0);
ListofID idList(this->fileBlockManager, listOffset);
toReturn = idList.removeID(idToRemove);
if(idList.getListID().size() == 0)
toReturn = BPlusTree::removeKey(key);
else
idList.writeListinFile();
}
else
{
return false;
}
return toReturn;
}
void hash_index_object_t::test<5>()
{
LLUUIDHashMap<UUIDTableEntry, 2> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
const int numElementsToCheck = 256;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
// LLUUIDHashMap uses mData[0] to pick the bucket
// overwrite mData[0] so that it ranges from 0 to 255
id.mData[0] = i;
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
ensure("set/get did not work for sparse map", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
if (i % 2 != 0)
{
hashTable.remove(idToCheck);
}
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
ensure("remove or check did not work for sparse map", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
}
}
void hash_index_object_t::test<1>()
{
LLUUIDHashMap<UUIDTableEntry, 32> hashTable(UUIDTableEntry::uuidEq, UUIDTableEntry());
const int numElementsToCheck = 32*256*32;
std::vector<LLUUID> idList(numElementsToCheck);
int i;
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID id;
id.generate();
UUIDTableEntry entry(id, i);
hashTable.set(id, entry);
idList[i] = id;
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
UUIDTableEntry entryToCheck = hashTable.get(idToCheck);
ensure("set/get did not work", entryToCheck.getID() == idToCheck && entryToCheck.getValue() == (size_t)i);
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
if (i % 2 != 0)
{
hashTable.remove(idToCheck);
}
}
for (i = 0; i < numElementsToCheck; i++)
{
LLUUID idToCheck = idList[i];
ensure("remove or check did not work", (i % 2 == 0 && hashTable.check(idToCheck)) || (i % 2 != 0 && !hashTable.check(idToCheck)));
}
}
QStringList Layer::_getLayerIds( ) const {
QStringList idList( m_state.getValue<QString>( Util::ID));
return idList;
}
//Produção NameDecl
NameDeclNode* namedecl(){
printf("Statement'\n");
ModifierListNode* modifiers = modifierList();
IdListNode* idlistdl = idList();
return new NameDeclNode(modifiers,idlistdl);
}
/// Create wxPdfDocument font metrics file
void
MakeFont::CreateFontMetricsFile(const wxString& xmlFileName, wxPdfFontData& font, bool includeGlyphInfo)
{
wxXmlDocument fontMetrics;
const wxPdfFontDescription& fd = font.GetDescription();
wxXmlNode* rootNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("wxpdfdoc-font-metrics"));
#if wxCHECK_VERSION(2,9,0)
rootNode->AddAttribute(wxT("type"), font.GetType() /*wxT("TrueTypeUnicode")*/);
#else
rootNode->AddProperty(wxT("type"), font.GetType() /*wxT("TrueTypeUnicode")*/);
#endif
wxXmlNode* node;
wxXmlNode* textNode;
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("font-name"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), font.GetName());
node->AddChild(textNode);
rootNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("encoding"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), font.GetEncoding());
node->AddChild(textNode);
rootNode->AddChild(node);
wxXmlNode* descNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("description"));
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("ascent"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetAscent()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("descent"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetDescent()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("cap-height"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetCapHeight()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("flags"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetFlags()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("font-bbox"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), fd.GetFontBBox());
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("italic-angle"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetItalicAngle()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("stem-v"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetStemV()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("missing-width"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetMissingWidth()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("x-height"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetXHeight()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("underline-position"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetUnderlinePosition()));
node->AddChild(textNode);
descNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("underline-thickness"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), wxString::Format(wxT("%d"), fd.GetUnderlineThickness()));
node->AddChild(textNode);
descNode->AddChild(node);
rootNode->AddChild(descNode);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("diff"));
textNode = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), font.GetDiffs());
node->AddChild(textNode);
rootNode->AddChild(node);
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("file"));
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("name"), font.GetFontFile());
#else
node->AddProperty(wxT("name"), font.GetFontFile());
#endif
wxString fontType = font.GetType();
if (fontType == wxT("TrueTypeUnicode") || fontType == wxT("OpenTypeUnicode"))
{
// TrueTypeUnicode (name,ctg,originalsize)
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("ctg"), font.GetCtgFile());
node->AddAttribute(wxT("originalsize"), wxString::Format(wxT("%d"), font.GetSize1()));
#else
node->AddProperty(wxT("ctg"), font.GetCtgFile());
node->AddProperty(wxT("originalsize"), wxString::Format(wxT("%d"), font.GetSize1()));
#endif
}
else if (fontType == wxT("TrueType"))
{
// Truetype (name, originalsize)
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("originalsize"), wxString::Format(wxT("%d"), font.GetSize1()));
#else
node->AddProperty(wxT("originalsize"), wxString::Format(wxT("%d"), font.GetSize1()));
#endif
}
else if (fontType == wxT("Type1"))
{
// Type1 (name, size1, size2)
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("size1"), wxString::Format(wxT("%d"), font.GetSize1()));
#else
node->AddProperty(wxT("size1"), wxString::Format(wxT("%d"), font.GetSize1()));
#endif
if (font.HasSize2())
{
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("size2"), wxString::Format(wxT("%d"), font.GetSize2()));
#else
node->AddProperty(wxT("size2"), wxString::Format(wxT("%d"), font.GetSize2()));
#endif
}
}
rootNode->AddChild(node);
wxXmlNode* widthsNode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("widths"));
if (includeGlyphInfo)
{
#if wxCHECK_VERSION(2,9,0)
widthsNode->AddAttribute(wxT("subsetting"), wxT("enabled"));
#else
widthsNode->AddProperty(wxT("subsetting"), wxT("enabled"));
#endif
}
wxPdfGlyphWidthMap* widths = (wxPdfGlyphWidthMap*) font.GetGlyphWidthMap();
wxPdfChar2GlyphMap* glyphs = (wxPdfChar2GlyphMap*) font.GetChar2GlyphMap();
wxPdfSortedArrayInt idList(CompareInts);
wxPdfGlyphWidthMap::iterator iter = widths->begin();
for (iter = widths->begin(); iter != widths->end(); iter++)
{
idList.Add(iter->first);
}
size_t j;
for (j = 0; j < idList.GetCount(); j++)
{
node = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("char"));
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("id"), wxString::Format(wxT("%d"), idList[j]));
#else
node->AddProperty(wxT("id"), wxString::Format(wxT("%d"), idList[j]));
#endif
if (includeGlyphInfo)
{
int glyph = (*glyphs)[idList[j]];
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("gn"), wxString::Format(wxT("%d"), glyph));
#else
node->AddProperty(wxT("gn"), wxString::Format(wxT("%d"), glyph));
#endif
}
#if wxCHECK_VERSION(2,9,0)
node->AddAttribute(wxT("width"), wxString::Format(wxT("%d"), (*widths)[idList[j]]));
#else
node->AddProperty(wxT("width"), wxString::Format(wxT("%d"), (*widths)[idList[j]]));
#endif
widthsNode->AddChild(node);
}
rootNode->AddChild(widthsNode);
wxXmlDocument voltData;
wxXmlNode* voltRoot = NULL;
if (!m_volt.IsEmpty())
{
wxFileSystem fs;
// Open volt data XML file
wxFSFile* xmlVoltData = fs.OpenFile(wxFileSystem::FileNameToURL(m_volt));
if (xmlVoltData != NULL)
{
// Load the XML file
bool loaded = voltData.Load(*(xmlVoltData->GetStream()));
delete xmlVoltData;
if (loaded)
{
if (voltData.IsOk() && voltData.GetRoot()->GetName().IsSameAs(wxT("volt")))
{
voltRoot = voltData.GetRoot();
rootNode->AddChild(voltRoot);
}
}
}
}
fontMetrics.SetRoot(rootNode);
fontMetrics.Save(xmlFileName);
if (voltRoot != NULL)
{
rootNode->RemoveChild(voltRoot);
}
}
//********************************************
//* Increment the account to the next ID number
//* available.
//********************************************
int AccountsManager::getNewIdNumber() {
QList<int> numbers = idList();
for (int i = 1;; i++)
if (!numbers.contains(i))
return i;
}
