bool SVNCommitLog::parseCommit(RCommit& commit) {
//fprintf(stderr,"parsing svn log\n");
std::string line;
if(!getNextLine(line)) return false;
//start of log entry
if(!svn_logentry_start.match(line)) {
//is this the start of the document
if(!svn_xml_tag.match(line)) return false;
//fprintf(stderr,"found xml tag\n");
//if so find the first logentry tag
bool found_logentry = false;
while(getNextLine(line)) {
if(svn_logentry_start.match(line)) {
found_logentry = true;
break;
}
}
if(!found_logentry) return false;
}
//fprintf(stderr,"found logentry\n");
logentry.clear();
logentry.append(line);
logentry.append("\n");
//fprintf(stderr,"found opening tag\n");
bool endfound = false;
while(getNextLine(line)) {
logentry.append(line);
logentry.append("\n");
if(svn_logentry_end.match(line)) {
//fprintf(stderr,"found closing tag\n");
endfound=true;
break;
}
}
//incomplete commit
if(!endfound) return false;
//fprintf(stderr,"read logentry\n");
TiXmlDocument doc;
if(!doc.Parse(logentry.c_str())) return false;
//fprintf(stderr,"try to parse logentry: %s\n", logentry.c_str());
TiXmlElement* leE = doc.FirstChildElement( "logentry" );
std::vector<std::string> entries;
if(!leE) return false;
//parse date
TiXmlElement* dateE = leE->FirstChildElement( "date" );
if(!dateE) return false;
std::string timestamp_str(dateE->GetText());
if(!svn_logentry_timestamp.match(timestamp_str, &entries))
return false;
struct tm time_str;
time_str.tm_year = atoi(entries[0].c_str()) - 1900;
time_str.tm_mon = atoi(entries[1].c_str()) - 1;
time_str.tm_mday = atoi(entries[2].c_str());
time_str.tm_hour = atoi(entries[3].c_str());
time_str.tm_min = atoi(entries[4].c_str());
time_str.tm_sec = atoi(entries[5].c_str());
time_str.tm_isdst = -1;
#ifdef HAVE_TIMEGM
commit.timestamp = timegm(&time_str);
#else
commit.timestamp = __timegm_hack(&time_str);
#endif
//parse author
TiXmlElement* authorE = leE->FirstChildElement("author");
if(authorE != 0) {
// GetText() may return NULL, causing author instantiation to crash.
std::string author;
if(authorE->GetText()) author = authorE->GetText();
if(author.empty()) author = "Unknown";
commit.username = author;
}
TiXmlElement* pathsE = leE->FirstChildElement( "paths" );
//log entries sometimes dont have any paths
if(!pathsE) return true;
//parse changes
for(TiXmlElement* pathE = pathsE->FirstChildElement("path"); pathE != 0; pathE = pathE->NextSiblingElement()) {
//parse path
const char* kind = pathE->Attribute("kind");
const char* action = pathE->Attribute("action");
//check for action
if(action == 0) continue;
bool is_dir = false;
//if has the 'kind' attribute (old versions of svn dont have this), check if it is a dir
if(kind != 0 && strcmp(kind,"dir") == 0) {
//accept only deletes for directories
if(strcmp(action, "D") != 0) continue;
is_dir = true;
}
std::string file(pathE->GetText());
std::string status(action);
if(file.empty()) continue;
if(status.empty()) continue;
//append trailing slash if is directory
if(is_dir && file[file.size()-1] != '/') {
file = file + std::string("/");
}
commit.addFile(file, status);
}
//fprintf(stderr,"parsed logentry\n");
//read files
return true;
}
bool IMContactXMLSerializer1::unserialize(const std::string & data) {
TiXmlDocument doc;
doc.Parse(data.c_str());
TiXmlHandle docHandle(&doc);
TiXmlHandle im = docHandle.FirstChild("im");
// Retrieving associated account
EnumIMProtocol::IMProtocol protocol;
TiXmlElement * lastChildElt = im.Element();
if (lastChildElt) {
protocol = EnumIMProtocol::toIMProtocol(lastChildElt->Attribute("protocol"));
} else {
return false;
}
TiXmlText * login = im.FirstChild("account").FirstChild().Text();
if (login) {
const IMAccount *imAccount = NULL;
std::string loginValue = std::string(login->Value());
//VOXOX - JRT - 2009.04.09
//for (IMAccountList::const_iterator it = _imAccountList.begin();
// it != _imAccountList.end();
// ++it) {
// if ((it->getLogin() == loginValue) &&
// (it->getProtocol() == protocol) ) {
// imAccount = &(*it);
// }
//}
imAccount = _imAccountList.findByLoginInfo( loginValue, protocol );
//End VOXOX
if (imAccount) {
_imContact.setIMAccount(imAccount);
} else {
LOG_ERROR("this IMAccount does not exist in IMAccountList: " + std::string(login->Value()));
return false;
}
////
} else {
_imContact._imAccount = NULL;
_imContact._protocol = protocol;
}
////
//Retrieving contactId
TiXmlText * contactId = im.FirstChild("id").FirstChild().Text();
if (contactId) {
// wengo or sip account should have a domain
// (unfortunately not saved before 2.1rc2...
String completeLogin(contactId->Value());
if (!completeLogin.contains("@"))
{
if (protocol == EnumIMProtocol::IMProtocolWengo) {
completeLogin += "@voip.wengo.fr";
}
//else if (protocol == EnumIMProtocol::IMProtocolSIP) {
// // TO DO ?
//}
}
////
_imContact._contactId = completeLogin;
}
////
// Retrieving alias
TiXmlText * alias = im.FirstChild("alias").FirstChild().Text();
if (alias) {
_imContact._alias = alias->Value();
}
////
//VOXOX CHANGE CJC ADD SUPPORT FOR STATUS MESSAGE
// Retrieving statusMessage
TiXmlText * statusMessage = im.FirstChild("statusMessage").FirstChild().Text();
if (statusMessage) {
_imContact._statusMessage = statusMessage->Value();
}
///VOXOX CHANGE Marin Block option when right clicking contact 4/24/2009
TiXmlText * blocked = im.FirstChild("blocked").FirstChild().Text();
if (blocked) {
String strBlocked = blocked->Value();
_imContact._blocked = strBlocked.toBoolean();
}
// Retrieving icon
TiXmlText * photo = im.FirstChild("photo").FirstChild().Text();
if (photo) {
OWPicture picture = OWPicture::pictureFromData(Base64::decode(photo->Value()));
_imContact.setIcon(picture);
}
////
return true;
}
IndexTimeRef::IndexTimeRef(TiXmlNode* xmlNode)
: ISerialized(xmlNode)
{
#ifdef ConsolePrint
std::string initialtap_ = FileManager::instance().tap_;
FileManager::instance().tap_.append(" ");
#endif
//underlyingIndexRefNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* underlyingIndexRefNode = xmlNode->FirstChildElement("underlyingIndexRef");
if(underlyingIndexRefNode){underlyingIndexRefIsNull_ = false;}
else{underlyingIndexRefIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- underlyingIndexRefNode , address : " << underlyingIndexRefNode << std::endl;
#endif
if(underlyingIndexRefNode)
{
if(underlyingIndexRefNode->Attribute("href") || underlyingIndexRefNode->Attribute("id"))
{
if(underlyingIndexRefNode->Attribute("id"))
{
underlyingIndexRefIDRef_ = underlyingIndexRefNode->Attribute("id");
underlyingIndexRef_ = boost::shared_ptr<UnderlyingIndex>(new UnderlyingIndex(underlyingIndexRefNode));
underlyingIndexRef_->setID(underlyingIndexRefIDRef_);
IDManager::instance().setID(underlyingIndexRefIDRef_,underlyingIndexRef_);
}
else if(underlyingIndexRefNode->Attribute("href")) { underlyingIndexRefIDRef_ = underlyingIndexRefNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { underlyingIndexRef_ = boost::shared_ptr<UnderlyingIndex>(new UnderlyingIndex(underlyingIndexRefNode));}
}
//fixingDaysNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* fixingDaysNode = xmlNode->FirstChildElement("fixingDays");
if(fixingDaysNode){fixingDaysIsNull_ = false;}
else{fixingDaysIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- fixingDaysNode , address : " << fixingDaysNode << std::endl;
#endif
if(fixingDaysNode)
{
if(fixingDaysNode->Attribute("href") || fixingDaysNode->Attribute("id"))
{
if(fixingDaysNode->Attribute("id"))
{
fixingDaysIDRef_ = fixingDaysNode->Attribute("id");
fixingDays_ = boost::shared_ptr<FixingDays>(new FixingDays(fixingDaysNode));
fixingDays_->setID(fixingDaysIDRef_);
IDManager::instance().setID(fixingDaysIDRef_,fixingDays_);
}
else if(fixingDaysNode->Attribute("href")) { fixingDaysIDRef_ = fixingDaysNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { fixingDays_ = boost::shared_ptr<FixingDays>(new FixingDays(fixingDaysNode));}
}
#ifdef ConsolePrint
FileManager::instance().tap_ = initialtap_;
#endif
}
int main()
{
//
// We start with the 'demoStart' todo list. Process it. And
// should hopefully end up with the todo list as illustrated.
//
const char* demoStart =
"<?xml version=\"1.0\" standalone='no' >\n"
"<!-- Our to do list data -->"
"<ToDo>\n"
"<!-- Do I need a secure PDA? -->\n"
"<Item priority=\"1\" distance='close'> Go to the <bold>Toy store!</bold></Item>"
"<Item priority=\"2\" distance='none'> Do bills </Item>"
"<Item priority=\"2\" distance='far & back'> Look for Evil Dinosaurs! </Item>"
"</ToDo>";
{
#ifdef TIXML_USE_STL
/* What the todo list should look like after processing.
In stream (no formatting) representation. */
const char* demoEnd =
"<?xml version=\"1.0\" standalone=\"no\" ?>"
"<!-- Our to do list data -->"
"<ToDo>"
"<!-- Do I need a secure PDA? -->"
"<Item priority=\"2\" distance=\"close\">Go to the"
"<bold>Toy store!"
"</bold>"
"</Item>"
"<Item priority=\"1\" distance=\"far\">Talk to:"
"<Meeting where=\"School\">"
"<Attendee name=\"Marple\" position=\"teacher\" />"
"<Attendee name=\"Voel\" position=\"counselor\" />"
"</Meeting>"
"<Meeting where=\"Lunch\" />"
"</Item>"
"<Item priority=\"2\" distance=\"here\">Do bills"
"</Item>"
"</ToDo>";
#endif
// The example parses from the character string (above):
#if defined( WIN32 ) && defined( TUNE )
_CrtMemCheckpoint( &startMemState );
#endif
{
// Write to a file and read it back, to check file I/O.
TiXmlDocument doc( "demotest.xml" );
doc.Parse( demoStart );
if ( doc.Error() )
{
printf( "Error in %s: %s\n", doc.Value(), doc.ErrorDesc() );
exit( 1 );
}
doc.SaveFile();
}
TiXmlDocument doc( "demotest.xml" );
bool loadOkay = doc.LoadFile();
if ( !loadOkay )
{
printf( "Could not load test file 'demotest.xml'. Error='%s'. Exiting.\n", doc.ErrorDesc() );
exit( 1 );
}
printf( "** Demo doc read from disk: ** \n\n" );
printf( "** Printing via doc.Print **\n" );
doc.Print( stdout );
{
printf( "** Printing via TiXmlPrinter **\n" );
TiXmlPrinter printer;
doc.Accept( &printer );
fprintf( stdout, "%s", printer.CStr() );
}
#ifdef TIXML_USE_STL
{
printf( "** Printing via operator<< **\n" );
std::cout << doc;
}
#endif
TiXmlNode* node = 0;
TiXmlElement* todoElement = 0;
TiXmlElement* itemElement = 0;
// --------------------------------------------------------
// An example of changing existing attributes, and removing
// an element from the document.
// --------------------------------------------------------
// Get the "ToDo" element.
// It is a child of the document, and can be selected by name.
node = doc.FirstChild( "ToDo" );
assert( node );
todoElement = node->ToElement();
assert( todoElement );
// Going to the toy store is now our second priority...
// So set the "priority" attribute of the first item in the list.
node = todoElement->FirstChildElement(); // This skips the "PDA" comment.
assert( node );
itemElement = node->ToElement();
assert( itemElement );
itemElement->SetAttribute( "priority", 2 );
// Change the distance to "doing bills" from
// "none" to "here". It's the next sibling element.
itemElement = itemElement->NextSiblingElement();
assert( itemElement );
itemElement->SetAttribute( "distance", "here" );
// Remove the "Look for Evil Dinosaurs!" item.
// It is 1 more sibling away. We ask the parent to remove
// a particular child.
itemElement = itemElement->NextSiblingElement();
todoElement->RemoveChild( itemElement );
itemElement = 0;
// --------------------------------------------------------
// What follows is an example of created elements and text
// nodes and adding them to the document.
// --------------------------------------------------------
// Add some meetings.
TiXmlElement item( "Item" );
item.SetAttribute( "priority", "1" );
item.SetAttribute( "distance", "far" );
TiXmlText text( "Talk to:" );
TiXmlElement meeting1( "Meeting" );
meeting1.SetAttribute( "where", "School" );
TiXmlElement meeting2( "Meeting" );
meeting2.SetAttribute( "where", "Lunch" );
TiXmlElement attendee1( "Attendee" );
attendee1.SetAttribute( "name", "Marple" );
attendee1.SetAttribute( "position", "teacher" );
TiXmlElement attendee2( "Attendee" );
attendee2.SetAttribute( "name", "Voel" );
attendee2.SetAttribute( "position", "counselor" );
// Assemble the nodes we've created:
meeting1.InsertEndChild( attendee1 );
meeting1.InsertEndChild( attendee2 );
item.InsertEndChild( text );
item.InsertEndChild( meeting1 );
item.InsertEndChild( meeting2 );
// And add the node to the existing list after the first child.
node = todoElement->FirstChild( "Item" );
assert( node );
itemElement = node->ToElement();
assert( itemElement );
todoElement->InsertAfterChild( itemElement, item );
printf( "\n** Demo doc processed: ** \n\n" );
doc.Print( stdout );
#ifdef TIXML_USE_STL
printf( "** Demo doc processed to stream: ** \n\n" );
cout << doc << endl << endl;
#endif
// --------------------------------------------------------
// Different tests...do we have what we expect?
// --------------------------------------------------------
int count = 0;
TiXmlElement* element;
//////////////////////////////////////////////////////
#ifdef TIXML_USE_STL
cout << "** Basic structure. **\n";
ostringstream outputStream( ostringstream::out );
outputStream << doc;
XmlTest( "Output stream correct.", string( demoEnd ).c_str(),
outputStream.str().c_str(), true );
#endif
node = doc.RootElement();
assert( node );
XmlTest( "Root element exists.", true, ( node != 0 && node->ToElement() ) );
XmlTest ( "Root element value is 'ToDo'.", "ToDo", node->Value());
node = node->FirstChild();
XmlTest( "First child exists & is a comment.", true, ( node != 0 && node->ToComment() ) );
node = node->NextSibling();
XmlTest( "Sibling element exists & is an element.", true, ( node != 0 && node->ToElement() ) );
XmlTest ( "Value is 'Item'.", "Item", node->Value() );
node = node->FirstChild();
XmlTest ( "First child exists.", true, ( node != 0 && node->ToText() ) );
XmlTest ( "Value is 'Go to the'.", "Go to the", node->Value() );
//////////////////////////////////////////////////////
printf ("\n** Iterators. **\n");
// Walk all the top level nodes of the document.
count = 0;
for( node = doc.FirstChild();
node;
node = node->NextSibling() )
{
count++;
}
XmlTest( "Top level nodes, using First / Next.", 3, count );
count = 0;
for( node = doc.LastChild();
node;
node = node->PreviousSibling() )
{
count++;
}
XmlTest( "Top level nodes, using Last / Previous.", 3, count );
// Walk all the top level nodes of the document,
// using a different syntax.
count = 0;
for( node = doc.IterateChildren( 0 );
node;
node = doc.IterateChildren( node ) )
{
count++;
}
XmlTest( "Top level nodes, using IterateChildren.", 3, count );
// Walk all the elements in a node.
count = 0;
for( element = todoElement->FirstChildElement();
element;
element = element->NextSiblingElement() )
{
count++;
}
XmlTest( "Children of the 'ToDo' element, using First / Next.",
3, count );
// Walk all the elements in a node by value.
count = 0;
for( node = todoElement->FirstChild( "Item" );
node;
node = node->NextSibling( "Item" ) )
{
count++;
}
XmlTest( "'Item' children of the 'ToDo' element, using First/Next.", 3, count );
count = 0;
for( node = todoElement->LastChild( "Item" );
node;
node = node->PreviousSibling( "Item" ) )
{
count++;
}
XmlTest( "'Item' children of the 'ToDo' element, using Last/Previous.", 3, count );
#ifdef TIXML_USE_STL
{
cout << "\n** Parsing. **\n";
istringstream parse0( "<Element0 attribute0='foo0' attribute1= noquotes attribute2 = '>' />" );
TiXmlElement element0( "default" );
parse0 >> element0;
XmlTest ( "Element parsed, value is 'Element0'.", "Element0", element0.Value() );
XmlTest ( "Reads attribute 'attribute0=\"foo0\"'.", "foo0", element0.Attribute( "attribute0" ));
XmlTest ( "Reads incorrectly formatted 'attribute1=noquotes'.", "noquotes", element0.Attribute( "attribute1" ) );
XmlTest ( "Read attribute with entity value '>'.", ">", element0.Attribute( "attribute2" ) );
}
#endif
{
const char* error = "<?xml version=\"1.0\" standalone=\"no\" ?>\n"
"<passages count=\"006\" formatversion=\"20020620\">\n"
" <wrong error>\n"
"</passages>";
TiXmlDocument docTest;
docTest.Parse( error );
XmlTest( "Error row", docTest.ErrorRow(), 3 );
XmlTest( "Error column", docTest.ErrorCol(), 17 );
//printf( "error=%d id='%s' row %d col%d\n", (int) doc.Error(), doc.ErrorDesc(), doc.ErrorRow()+1, doc.ErrorCol() + 1 );
}
#ifdef TIXML_USE_STL
{
//////////////////////////////////////////////////////
cout << "\n** Streaming. **\n";
// Round trip check: stream in, then stream back out to verify. The stream
// out has already been checked, above. We use the output
istringstream inputStringStream( outputStream.str() );
TiXmlDocument document0;
inputStringStream >> document0;
ostringstream outputStream0( ostringstream::out );
outputStream0 << document0;
XmlTest( "Stream round trip correct.", string( demoEnd ).c_str(),
outputStream0.str().c_str(), true );
std::string str;
str << document0;
XmlTest( "String printing correct.", string( demoEnd ).c_str(),
str.c_str(), true );
}
#endif
}
{
const char* str = "<doc attr0='1' attr1='2.0' attr2='foo' />";
TiXmlDocument doc;
doc.Parse( str );
TiXmlElement* ele = doc.FirstChildElement();
int iVal, result;
double dVal;
result = ele->QueryDoubleAttribute( "attr0", &dVal );
XmlTest( "Query attribute: int as double", result, TIXML_SUCCESS );
XmlTest( "Query attribute: int as double", (int)dVal, 1 );
result = ele->QueryDoubleAttribute( "attr1", &dVal );
XmlTest( "Query attribute: double as double", (int)dVal, 2 );
result = ele->QueryIntAttribute( "attr1", &iVal );
XmlTest( "Query attribute: double as int", result, TIXML_SUCCESS );
XmlTest( "Query attribute: double as int", iVal, 2 );
result = ele->QueryIntAttribute( "attr2", &iVal );
XmlTest( "Query attribute: not a number", result, TIXML_WRONG_TYPE );
result = ele->QueryIntAttribute( "bar", &iVal );
XmlTest( "Query attribute: does not exist", result, TIXML_NO_ATTRIBUTE );
}
{
const char* str = "\t<?xml version=\"1.0\" standalone=\"no\" ?>\t<room doors='2'>\n"
"</room>";
TiXmlDocument doc;
doc.SetTabSize( 8 );
doc.Parse( str );
TiXmlHandle docHandle( &doc );
TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" );
assert( docHandle.Node() );
assert( roomHandle.Element() );
TiXmlElement* room = roomHandle.Element();
assert( room );
TiXmlAttribute* doors = room->FirstAttribute();
assert( doors );
XmlTest( "Location tracking: Tab 8: room row", room->Row(), 1 );
XmlTest( "Location tracking: Tab 8: room col", room->Column(), 49 );
XmlTest( "Location tracking: Tab 8: doors row", doors->Row(), 1 );
XmlTest( "Location tracking: Tab 8: doors col", doors->Column(), 55 );
}
{
const char* str = "\t<?xml version=\"1.0\" standalone=\"no\" ?>\t<room doors='2'>\n"
" <!-- Silly example -->\n"
" <door wall='north'>A great door!</door>\n"
"\t<door wall='east'/>"
"</room>";
TiXmlDocument doc;
doc.Parse( str );
TiXmlHandle docHandle( &doc );
TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" );
TiXmlHandle commentHandle = docHandle.FirstChildElement( "room" ).FirstChild();
TiXmlHandle textHandle = docHandle.FirstChildElement( "room" ).ChildElement( "door", 0 ).FirstChild();
TiXmlHandle door0Handle = docHandle.FirstChildElement( "room" ).ChildElement( 0 );
TiXmlHandle door1Handle = docHandle.FirstChildElement( "room" ).ChildElement( 1 );
assert( docHandle.Node() );
assert( roomHandle.Element() );
assert( commentHandle.Node() );
assert( textHandle.Text() );
assert( door0Handle.Element() );
assert( door1Handle.Element() );
TiXmlDeclaration* declaration = doc.FirstChild()->ToDeclaration();
assert( declaration );
TiXmlElement* room = roomHandle.Element();
assert( room );
TiXmlAttribute* doors = room->FirstAttribute();
assert( doors );
TiXmlText* text = textHandle.Text();
TiXmlComment* comment = commentHandle.Node()->ToComment();
assert( comment );
TiXmlElement* door0 = door0Handle.Element();
TiXmlElement* door1 = door1Handle.Element();
XmlTest( "Location tracking: Declaration row", declaration->Row(), 1 );
XmlTest( "Location tracking: Declaration col", declaration->Column(), 5 );
XmlTest( "Location tracking: room row", room->Row(), 1 );
XmlTest( "Location tracking: room col", room->Column(), 45 );
XmlTest( "Location tracking: doors row", doors->Row(), 1 );
XmlTest( "Location tracking: doors col", doors->Column(), 51 );
XmlTest( "Location tracking: Comment row", comment->Row(), 2 );
XmlTest( "Location tracking: Comment col", comment->Column(), 3 );
XmlTest( "Location tracking: text row", text->Row(), 3 );
XmlTest( "Location tracking: text col", text->Column(), 24 );
XmlTest( "Location tracking: door0 row", door0->Row(), 3 );
XmlTest( "Location tracking: door0 col", door0->Column(), 5 );
XmlTest( "Location tracking: door1 row", door1->Row(), 4 );
XmlTest( "Location tracking: door1 col", door1->Column(), 5 );
}
// --------------------------------------------------------
// UTF-8 testing. It is important to test:
// 1. Making sure name, value, and text read correctly
// 2. Row, Col functionality
// 3. Correct output
// --------------------------------------------------------
printf ("\n** UTF-8 **\n");
{
TiXmlDocument doc( "utf8test.xml" );
doc.LoadFile();
if ( doc.Error() && doc.ErrorId() == TiXmlBase::TIXML_ERROR_OPENING_FILE ) {
printf( "WARNING: File 'utf8test.xml' not found.\n"
"(Are you running the test from the wrong directory?)\n"
"Could not test UTF-8 functionality.\n" );
}
else
{
TiXmlHandle docH( &doc );
// Get the attribute "value" from the "Russian" element and check it.
TiXmlElement* element = docH.FirstChildElement( "document" ).FirstChildElement( "Russian" ).Element();
const unsigned char correctValue[] = { 0xd1U, 0x86U, 0xd0U, 0xb5U, 0xd0U, 0xbdU, 0xd0U, 0xbdU,
0xd0U, 0xbeU, 0xd1U, 0x81U, 0xd1U, 0x82U, 0xd1U, 0x8cU, 0 };
XmlTest( "UTF-8: Russian value.", (const char*)correctValue, element->Attribute( "value" ), true );
XmlTest( "UTF-8: Russian value row.", 4, element->Row() );
XmlTest( "UTF-8: Russian value column.", 5, element->Column() );
const unsigned char russianElementName[] = { 0xd0U, 0xa0U, 0xd1U, 0x83U,
0xd1U, 0x81U, 0xd1U, 0x81U,
0xd0U, 0xbaU, 0xd0U, 0xb8U,
0xd0U, 0xb9U, 0 };
const char russianText[] = "<\xD0\xB8\xD0\xBC\xD0\xB5\xD0\xB5\xD1\x82>";
TiXmlText* text = docH.FirstChildElement( "document" ).FirstChildElement( (const char*) russianElementName ).Child( 0 ).Text();
XmlTest( "UTF-8: Browsing russian element name.",
russianText,
text->Value(),
true );
XmlTest( "UTF-8: Russian element name row.", 7, text->Row() );
XmlTest( "UTF-8: Russian element name column.", 47, text->Column() );
TiXmlDeclaration* dec = docH.Child( 0 ).Node()->ToDeclaration();
XmlTest( "UTF-8: Declaration column.", 1, dec->Column() );
XmlTest( "UTF-8: Document column.", 1, doc.Column() );
// Now try for a round trip.
doc.SaveFile( "utf8testout.xml" );
// Check the round trip.
char savedBuf[256];
char verifyBuf[256];
int okay = 1;
FILE* saved = fopen( "utf8testout.xml", "r" );
FILE* verify = fopen( "utf8testverify.xml", "r" );
if ( saved && verify )
{
while ( fgets( verifyBuf, 256, verify ) )
{
fgets( savedBuf, 256, saved );
if ( strcmp( verifyBuf, savedBuf ) )
{
okay = 0;
break;
}
}
fclose( saved );
fclose( verify );
}
XmlTest( "UTF-8: Verified multi-language round trip.", 1, okay );
// On most Western machines, this is an element that contains
// the word "resume" with the correct accents, in a latin encoding.
// It will be something else completely on non-wester machines,
// which is why TinyXml is switching to UTF-8.
const char latin[] = "<element>r\x82sum\x82</element>";
TiXmlDocument latinDoc;
latinDoc.Parse( latin, 0, TIXML_ENCODING_LEGACY );
text = latinDoc.FirstChildElement()->FirstChild()->ToText();
XmlTest( "Legacy encoding: Verify text element.", "r\x82sum\x82", text->Value() );
}
}
//////////////////////
// Copy and assignment
//////////////////////
printf ("\n** Copy and Assignment **\n");
{
TiXmlElement element( "foo" );
element.Parse( "<element name='value' />", 0, TIXML_ENCODING_UNKNOWN );
TiXmlElement elementCopy( element );
TiXmlElement elementAssign( "foo" );
elementAssign.Parse( "<incorrect foo='bar'/>", 0, TIXML_ENCODING_UNKNOWN );
elementAssign = element;
XmlTest( "Copy/Assign: element copy #1.", "element", elementCopy.Value() );
XmlTest( "Copy/Assign: element copy #2.", "value", elementCopy.Attribute( "name" ) );
XmlTest( "Copy/Assign: element assign #1.", "element", elementAssign.Value() );
XmlTest( "Copy/Assign: element assign #2.", "value", elementAssign.Attribute( "name" ) );
XmlTest( "Copy/Assign: element assign #3.", true, ( 0 == elementAssign.Attribute( "foo" )) );
TiXmlComment comment;
comment.Parse( "<!--comment-->", 0, TIXML_ENCODING_UNKNOWN );
TiXmlComment commentCopy( comment );
TiXmlComment commentAssign;
commentAssign = commentCopy;
XmlTest( "Copy/Assign: comment copy.", "comment", commentCopy.Value() );
XmlTest( "Copy/Assign: comment assign.", "comment", commentAssign.Value() );
TiXmlUnknown unknown;
unknown.Parse( "<[unknown]>", 0, TIXML_ENCODING_UNKNOWN );
TiXmlUnknown unknownCopy( unknown );
TiXmlUnknown unknownAssign;
unknownAssign.Parse( "incorrect", 0, TIXML_ENCODING_UNKNOWN );
unknownAssign = unknownCopy;
XmlTest( "Copy/Assign: unknown copy.", "[unknown]", unknownCopy.Value() );
XmlTest( "Copy/Assign: unknown assign.", "[unknown]", unknownAssign.Value() );
TiXmlText text( "TextNode" );
TiXmlText textCopy( text );
TiXmlText textAssign( "incorrect" );
textAssign = text;
XmlTest( "Copy/Assign: text copy.", "TextNode", textCopy.Value() );
XmlTest( "Copy/Assign: text assign.", "TextNode", textAssign.Value() );
TiXmlDeclaration dec;
dec.Parse( "<?xml version='1.0' encoding='UTF-8'?>", 0, TIXML_ENCODING_UNKNOWN );
TiXmlDeclaration decCopy( dec );
TiXmlDeclaration decAssign;
decAssign = dec;
XmlTest( "Copy/Assign: declaration copy.", "UTF-8", decCopy.Encoding() );
XmlTest( "Copy/Assign: text assign.", "UTF-8", decAssign.Encoding() );
TiXmlDocument doc;
elementCopy.InsertEndChild( textCopy );
doc.InsertEndChild( decAssign );
doc.InsertEndChild( elementCopy );
doc.InsertEndChild( unknownAssign );
TiXmlDocument docCopy( doc );
TiXmlDocument docAssign;
docAssign = docCopy;
#ifdef TIXML_USE_STL
std::string original, copy, assign;
original << doc;
copy << docCopy;
assign << docAssign;
XmlTest( "Copy/Assign: document copy.", original.c_str(), copy.c_str(), true );
XmlTest( "Copy/Assign: document assign.", original.c_str(), assign.c_str(), true );
#endif
}
//////////////////////////////////////////////////////
#ifdef TIXML_USE_STL
printf ("\n** Parsing, no Condense Whitespace **\n");
TiXmlBase::SetCondenseWhiteSpace( false );
{
istringstream parse1( "<start>This is \ntext</start>" );
TiXmlElement text1( "text" );
parse1 >> text1;
XmlTest ( "Condense white space OFF.", "This is \ntext",
text1.FirstChild()->Value(),
true );
}
TiXmlBase::SetCondenseWhiteSpace( true );
#endif
//////////////////////////////////////////////////////
// GetText();
{
const char* str = "<foo>This is text</foo>";
TiXmlDocument doc;
doc.Parse( str );
const TiXmlElement* element = doc.RootElement();
XmlTest( "GetText() normal use.", "This is text", element->GetText() );
str = "<foo><b>This is text</b></foo>";
doc.Clear();
doc.Parse( str );
element = doc.RootElement();
XmlTest( "GetText() contained element.", element->GetText() == 0, true );
str = "<foo>This is <b>text</b></foo>";
doc.Clear();
TiXmlBase::SetCondenseWhiteSpace( false );
doc.Parse( str );
TiXmlBase::SetCondenseWhiteSpace( true );
element = doc.RootElement();
XmlTest( "GetText() partial.", "This is ", element->GetText() );
}
//////////////////////////////////////////////////////
// CDATA
{
const char* str = "<xmlElement>"
"<![CDATA["
"I am > the rules!\n"
"...since I make symbolic puns"
"]]>"
"</xmlElement>";
TiXmlDocument doc;
doc.Parse( str );
doc.Print();
XmlTest( "CDATA parse.", doc.FirstChildElement()->FirstChild()->Value(),
"I am > the rules!\n...since I make symbolic puns",
true );
#ifdef TIXML_USE_STL
//cout << doc << '\n';
doc.Clear();
istringstream parse0( str );
parse0 >> doc;
//cout << doc << '\n';
XmlTest( "CDATA stream.", doc.FirstChildElement()->FirstChild()->Value(),
"I am > the rules!\n...since I make symbolic puns",
true );
#endif
TiXmlDocument doc1 = doc;
//doc.Print();
XmlTest( "CDATA copy.", doc1.FirstChildElement()->FirstChild()->Value(),
"I am > the rules!\n...since I make symbolic puns",
true );
}
{
// [ 1482728 ] Wrong wide char parsing
char buf[256];
buf[255] = 0;
for( int i=0; i<255; ++i ) {
buf[i] = (char)((i>=32) ? i : 32);
}
TIXML_STRING str( "<xmlElement><![CDATA[" );
str += buf;
str += "]]></xmlElement>";
TiXmlDocument doc;
doc.Parse( str.c_str() );
TiXmlPrinter printer;
printer.SetStreamPrinting();
doc.Accept( &printer );
XmlTest( "CDATA with all bytes #1.", str.c_str(), printer.CStr(), true );
#ifdef TIXML_USE_STL
doc.Clear();
istringstream iss( printer.Str() );
iss >> doc;
std::string out;
out << doc;
XmlTest( "CDATA with all bytes #2.", out.c_str(), printer.CStr(), true );
#endif
}
{
// [ 1480107 ] Bug-fix for STL-streaming of CDATA that contains tags
// CDATA streaming had a couple of bugs, that this tests for.
const char* str = "<xmlElement>"
"<![CDATA["
"<b>I am > the rules!</b>\n"
"...since I make symbolic puns"
"]]>"
"</xmlElement>";
TiXmlDocument doc;
doc.Parse( str );
doc.Print();
XmlTest( "CDATA parse. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(),
"<b>I am > the rules!</b>\n...since I make symbolic puns",
true );
#ifdef TIXML_USE_STL
doc.Clear();
istringstream parse0( str );
parse0 >> doc;
XmlTest( "CDATA stream. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(),
"<b>I am > the rules!</b>\n...since I make symbolic puns",
true );
#endif
TiXmlDocument doc1 = doc;
//doc.Print();
XmlTest( "CDATA copy. [ 1480107 ]", doc1.FirstChildElement()->FirstChild()->Value(),
"<b>I am > the rules!</b>\n...since I make symbolic puns",
true );
}
//////////////////////////////////////////////////////
// Visit()
//////////////////////////////////////////////////////
printf( "\n** Fuzzing... **\n" );
const int FUZZ_ITERATION = 300;
// The only goal is not to crash on bad input.
int len = (int) strlen( demoStart );
for( int i=0; i<FUZZ_ITERATION; ++i )
{
char* demoCopy = new char[ len+1 ];
strcpy( demoCopy, demoStart );
demoCopy[ i%len ] = (char)((i+1)*3);
demoCopy[ (i*7)%len ] = '>';
demoCopy[ (i*11)%len ] = '<';
TiXmlDocument xml;
xml.Parse( demoCopy );
delete [] demoCopy;
}
printf( "** Fuzzing Complete. **\n" );
//////////////////////////////////////////////////////
printf ("\n** Bug regression tests **\n");
// InsertBeforeChild and InsertAfterChild causes crash.
{
TiXmlElement parent( "Parent" );
TiXmlElement childText0( "childText0" );
TiXmlElement childText1( "childText1" );
TiXmlNode* childNode0 = parent.InsertEndChild( childText0 );
TiXmlNode* childNode1 = parent.InsertBeforeChild( childNode0, childText1 );
XmlTest( "Test InsertBeforeChild on empty node.", ( childNode1 == parent.FirstChild() ), true );
}
{
// InsertBeforeChild and InsertAfterChild causes crash.
TiXmlElement parent( "Parent" );
TiXmlElement childText0( "childText0" );
TiXmlElement childText1( "childText1" );
TiXmlNode* childNode0 = parent.InsertEndChild( childText0 );
TiXmlNode* childNode1 = parent.InsertAfterChild( childNode0, childText1 );
XmlTest( "Test InsertAfterChild on empty node. ", ( childNode1 == parent.LastChild() ), true );
}
// Reports of missing constructors, irregular string problems.
{
// Missing constructor implementation. No test -- just compiles.
TiXmlText text( "Missing" );
#ifdef TIXML_USE_STL
// Missing implementation:
TiXmlDocument doc;
string name = "missing";
doc.LoadFile( name );
TiXmlText textSTL( name );
#else
// verifying some basic string functions:
TiXmlString a;
TiXmlString b( "Hello" );
TiXmlString c( "ooga" );
c = " World!";
a = b;
a += c;
a = a;
XmlTest( "Basic TiXmlString test. ", "Hello World!", a.c_str() );
#endif
}
// Long filenames crashing STL version
{
TiXmlDocument doc( "midsummerNightsDreamWithAVeryLongFilenameToConfuseTheStringHandlingRoutines.xml" );
bool loadOkay = doc.LoadFile();
loadOkay = true; // get rid of compiler warning.
// Won't pass on non-dev systems. Just a "no crash" check.
//XmlTest( "Long filename. ", true, loadOkay );
}
{
// Entities not being written correctly.
// From Lynn Allen
const char* passages =
"<?xml version=\"1.0\" standalone=\"no\" ?>"
"<passages count=\"006\" formatversion=\"20020620\">"
"<psg context=\"Line 5 has "quotation marks" and 'apostrophe marks'."
" It also has <, >, and &, as well as a fake copyright ©.\"> </psg>"
"</passages>";
TiXmlDocument doc( "passages.xml" );
doc.Parse( passages );
TiXmlElement* psg = doc.RootElement()->FirstChildElement();
const char* context = psg->Attribute( "context" );
const char* expected = "Line 5 has \"quotation marks\" and 'apostrophe marks'. It also has <, >, and &, as well as a fake copyright \xC2\xA9.";
XmlTest( "Entity transformation: read. ", expected, context, true );
FILE* textfile = fopen( "textfile.txt", "w" );
if ( textfile )
{
psg->Print( textfile, 0 );
fclose( textfile );
}
textfile = fopen( "textfile.txt", "r" );
assert( textfile );
if ( textfile )
{
char buf[ 1024 ];
fgets( buf, 1024, textfile );
XmlTest( "Entity transformation: write. ",
"<psg context=\'Line 5 has "quotation marks" and 'apostrophe marks'."
" It also has <, >, and &, as well as a fake copyright \xC2\xA9.' />",
buf,
true );
}
fclose( textfile );
}
{
FILE* textfile = fopen( "test5.xml", "w" );
if ( textfile )
{
fputs("<?xml version='1.0'?><a.elem xmi.version='2.0'/>", textfile);
fclose(textfile);
TiXmlDocument doc;
doc.LoadFile( "test5.xml" );
XmlTest( "dot in element attributes and names", doc.Error(), 0);
}
}
{
FILE* textfile = fopen( "test6.xml", "w" );
if ( textfile )
{
fputs("<element><Name>1.1 Start easy ignore fin thickness
</Name></element>", textfile );
fclose(textfile);
TiXmlDocument doc;
bool result = doc.LoadFile( "test6.xml" );
XmlTest( "Entity with one digit.", result, true );
TiXmlText* text = doc.FirstChildElement()->FirstChildElement()->FirstChild()->ToText();
XmlTest( "Entity with one digit.",
text->Value(), "1.1 Start easy ignore fin thickness\n" );
}
}
{
// DOCTYPE not preserved (950171)
//
const char* doctype =
"<?xml version=\"1.0\" ?>"
"<!DOCTYPE PLAY SYSTEM 'play.dtd'>"
"<!ELEMENT title (#PCDATA)>"
"<!ELEMENT books (title,authors)>"
"<element />";
TiXmlDocument doc;
doc.Parse( doctype );
doc.SaveFile( "test7.xml" );
doc.Clear();
doc.LoadFile( "test7.xml" );
TiXmlHandle docH( &doc );
TiXmlUnknown* unknown = docH.Child( 1 ).Unknown();
XmlTest( "Correct value of unknown.", "!DOCTYPE PLAY SYSTEM 'play.dtd'", unknown->Value() );
#ifdef TIXML_USE_STL
TiXmlNode* node = docH.Child( 2 ).Node();
std::string str;
str << (*node);
XmlTest( "Correct streaming of unknown.", "<!ELEMENT title (#PCDATA)>", str.c_str() );
#endif
}
{
// [ 791411 ] Formatting bug
// Comments do not stream out correctly.
const char* doctype =
"<!-- Somewhat<evil> -->";
TiXmlDocument doc;
doc.Parse( doctype );
TiXmlHandle docH( &doc );
TiXmlComment* comment = docH.Child( 0 ).Node()->ToComment();
XmlTest( "Comment formatting.", " Somewhat<evil> ", comment->Value() );
#ifdef TIXML_USE_STL
std::string str;
str << (*comment);
XmlTest( "Comment streaming.", "<!-- Somewhat<evil> -->", str.c_str() );
#endif
}
{
// [ 870502 ] White space issues
TiXmlDocument doc;
TiXmlText* text;
TiXmlHandle docH( &doc );
const char* doctype0 = "<element> This has leading and trailing space </element>";
const char* doctype1 = "<element>This has internal space</element>";
const char* doctype2 = "<element> This has leading, trailing, and internal space </element>";
TiXmlBase::SetCondenseWhiteSpace( false );
doc.Clear();
doc.Parse( doctype0 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space kept.", " This has leading and trailing space ", text->Value() );
doc.Clear();
doc.Parse( doctype1 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space kept.", "This has internal space", text->Value() );
doc.Clear();
doc.Parse( doctype2 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space kept.", " This has leading, trailing, and internal space ", text->Value() );
TiXmlBase::SetCondenseWhiteSpace( true );
doc.Clear();
doc.Parse( doctype0 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space condensed.", "This has leading and trailing space", text->Value() );
doc.Clear();
doc.Parse( doctype1 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space condensed.", "This has internal space", text->Value() );
doc.Clear();
doc.Parse( doctype2 );
text = docH.FirstChildElement( "element" ).Child( 0 ).Text();
XmlTest( "White space condensed.", "This has leading, trailing, and internal space", text->Value() );
}
{
// Double attributes
const char* doctype = "<element attr='red' attr='blue' />";
TiXmlDocument doc;
doc.Parse( doctype );
XmlTest( "Parsing repeated attributes.", 0, (int)doc.Error() ); // not an error to tinyxml
XmlTest( "Parsing repeated attributes.", "blue", doc.FirstChildElement( "element" )->Attribute( "attr" ) );
}
{
// Embedded null in stream.
const char* doctype = "<element att\0r='red' attr='blue' />";
TiXmlDocument doc;
doc.Parse( doctype );
XmlTest( "Embedded null throws error.", true, doc.Error() );
#ifdef TIXML_USE_STL
istringstream strm( doctype );
doc.Clear();
doc.ClearError();
strm >> doc;
XmlTest( "Embedded null throws error.", true, doc.Error() );
#endif
}
{
// Legacy mode test. (This test may only pass on a western system)
const char* str =
"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>"
"<ä>"
"CöntäntßäöüÄÖÜ"
"</ä>";
TiXmlDocument doc;
doc.Parse( str );
TiXmlHandle docHandle( &doc );
TiXmlHandle aHandle = docHandle.FirstChildElement( "ä" );
TiXmlHandle tHandle = aHandle.Child( 0 );
assert( aHandle.Element() );
assert( tHandle.Text() );
XmlTest( "ISO-8859-1 Parsing.", "CöntäntßäöüÄÖÜ", tHandle.Text()->Value() );
}
{
// Empty documents should return TIXML_ERROR_PARSING_EMPTY, bug 1070717
const char* str = " ";
TiXmlDocument doc;
doc.Parse( str );
XmlTest( "Empty document error TIXML_ERROR_DOCUMENT_EMPTY", TiXmlBase::TIXML_ERROR_DOCUMENT_EMPTY, doc.ErrorId() );
}
#ifndef TIXML_USE_STL
{
// String equality. [ 1006409 ] string operator==/!= no worky in all cases
TiXmlString temp;
XmlTest( "Empty tinyxml string compare equal", ( temp == "" ), true );
TiXmlString foo;
TiXmlString bar( "" );
XmlTest( "Empty tinyxml string compare equal", ( foo == bar ), true );
}
#endif
{
// Bug [ 1195696 ] from marlonism
TiXmlBase::SetCondenseWhiteSpace(false);
TiXmlDocument xml;
xml.Parse("<text><break/>This hangs</text>");
XmlTest( "Test safe error return.", xml.Error(), false );
}
{
// Bug [ 1243992 ] - another infinite loop
TiXmlDocument doc;
doc.SetCondenseWhiteSpace(false);
doc.Parse("<p><pb></pb>test</p>");
}
{
// Low entities
TiXmlDocument xml;
xml.Parse( "<test></test>" );
const char result[] = { 0x0e, 0 };
XmlTest( "Low entities.", xml.FirstChildElement()->GetText(), result );
xml.Print();
}
{
// Bug [ 1451649 ] Attribute values with trailing quotes not handled correctly
TiXmlDocument xml;
xml.Parse( "<foo attribute=bar\" />" );
XmlTest( "Throw error with bad end quotes.", xml.Error(), true );
}
#ifdef TIXML_USE_STL
{
// Bug [ 1449463 ] Consider generic query
TiXmlDocument xml;
xml.Parse( "<foo bar='3' barStr='a string'/>" );
TiXmlElement* ele = xml.FirstChildElement();
double d;
int i;
float f;
bool b;
//std::string str;
XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &d ), TIXML_SUCCESS );
XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &i ), TIXML_SUCCESS );
XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &f ), TIXML_SUCCESS );
XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &b ), TIXML_WRONG_TYPE );
XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "nobar", &b ), TIXML_NO_ATTRIBUTE );
//XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "barStr", &str ), TIXML_SUCCESS );
XmlTest( "QueryValueAttribute", (d==3.0), true );
XmlTest( "QueryValueAttribute", (i==3), true );
XmlTest( "QueryValueAttribute", (f==3.0f), true );
//XmlTest( "QueryValueAttribute", (str==std::string( "a string" )), true );
}
#endif
#ifdef TIXML_USE_STL
{
// [ 1505267 ] redundant malloc in TiXmlElement::Attribute
TiXmlDocument xml;
xml.Parse( "<foo bar='3' />" );
TiXmlElement* ele = xml.FirstChildElement();
double d;
int i;
std::string bar = "bar";
const std::string* atrrib = ele->Attribute( bar );
ele->Attribute( bar, &d );
ele->Attribute( bar, &i );
XmlTest( "Attribute", atrrib->empty(), false );
XmlTest( "Attribute", (d==3.0), true );
XmlTest( "Attribute", (i==3), true );
}
#endif
{
// [ 1356059 ] Allow TiXMLDocument to only be at the top level
TiXmlDocument xml, xml2;
xml.InsertEndChild( xml2 );
XmlTest( "Document only at top level.", xml.Error(), true );
XmlTest( "Document only at top level.", xml.ErrorId(), TiXmlBase::TIXML_ERROR_DOCUMENT_TOP_ONLY );
}
{
// [ 1663758 ] Failure to report error on bad XML
TiXmlDocument xml;
xml.Parse("<x>");
XmlTest("Missing end tag at end of input", xml.Error(), true);
xml.Parse("<x> ");
XmlTest("Missing end tag with trailing whitespace", xml.Error(), true);
}
{
// [ 1635701 ] fail to parse files with a tag separated into two lines
// I'm not sure this is a bug. Marked 'pending' for feedback.
TiXmlDocument xml;
xml.Parse( "<title><p>text</p\n><title>" );
//xml.Print();
//XmlTest( "Tag split by newline", xml.Error(), false );
}
#ifdef TIXML_USE_STL
{
// [ 1475201 ] TinyXML parses entities in comments
TiXmlDocument xml;
istringstream parse1( "<!-- declarations for <head> & <body> -->"
"<!-- far & away -->" );
parse1 >> xml;
TiXmlNode* e0 = xml.FirstChild();
TiXmlNode* e1 = e0->NextSibling();
TiXmlComment* c0 = e0->ToComment();
TiXmlComment* c1 = e1->ToComment();
XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true );
XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true );
}
#endif
{
// [ 1475201 ] TinyXML parses entities in comments
TiXmlDocument xml;
xml.Parse("<!-- declarations for <head> & <body> -->"
"<!-- far & away -->" );
TiXmlNode* e0 = xml.FirstChild();
TiXmlNode* e1 = e0->NextSibling();
TiXmlComment* c0 = e0->ToComment();
TiXmlComment* c1 = e1->ToComment();
XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true );
XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true );
}
/*
{
TiXmlDocument xml;
xml.Parse( "<tag>/</tag>" );
xml.Print();
xml.FirstChild()->Print( stdout, 0 );
xml.FirstChild()->Type();
}
*/
/* 1417717 experiment
{
TiXmlDocument xml;
xml.Parse("<text>Dan & Tracie</text>");
xml.Print(stdout);
}
{
TiXmlDocument xml;
xml.Parse("<text>Dan &foo; Tracie</text>");
xml.Print(stdout);
}
*/
#if defined( WIN32 ) && defined( TUNE )
_CrtMemCheckpoint( &endMemState );
//_CrtMemDumpStatistics( &endMemState );
_CrtMemState diffMemState;
_CrtMemDifference( &diffMemState, &startMemState, &endMemState );
_CrtMemDumpStatistics( &diffMemState );
#endif
printf ("\nPass %d, Fail %d\n", gPass, gFail);
return gFail;
}
//test GetEntryList. passed
BOOL GDocsAPITest::GetEntryListTest()
{
login();
TiXmlDocument * pXmlDoc = new TiXmlDocument();
//lastest 100 items
//m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full?showfolders=true", pXmlDoc);
//get trashed items
m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full/-/trashed?showfolders=true",pXmlDoc);
//entrylist for aaaa folder
//m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full/folder%3A0B7CmbVXdOi7mYzhlM2NjODgtNzlkZC00ZGZlLWFhN2EtMWJlODA3NmY0YjIy/contents", pXmlDoc);
//get all documetn
//m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full/-/document?max-results=5", pXmlDoc);
//m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full/-/-mine/folder", pXmlDoc);
pXmlDoc->SaveFile("d:/trashed.xml");
if (pXmlDoc)
{
TiXmlElement* pFeedElement = pXmlDoc->FirstChildElement("feed");
for (TiXmlElement* pElement = pFeedElement->FirstChildElement("entry"); pElement; pElement = pElement->NextSiblingElement("entry"))
{
GDocsEntry* pDocsEntry = new GDocsEntry(pElement);
cout<<"The information of the entry" <<endl<<endl;
wcout<<L" GDEtag :" << pDocsEntry->m_pszGDEtag<<endl;
wcout<<L" IDURL :" << pDocsEntry->m_pszIDUrl <<endl;
wcout<<L" Published :" << pDocsEntry->m_pszPublished <<endl;
wcout<<L" Updated :" << pDocsEntry->m_pszUpdated<<endl;
wcout<<L" AppEdited :" << pDocsEntry->m_pszAppEdited<<endl;
wcout<<L" IsStarred :" << pDocsEntry->m_bIsStarred<<endl;
wcout<<L" IsHidden :" << pDocsEntry->m_bIsHidden<<endl;
wcout<<L" IsViewed :" << pDocsEntry->m_bIsViewed<<endl;
wcout<<L" Title :" << pDocsEntry->m_pszTitle<<endl;
wcout<<L" ContentType :" << pDocsEntry->m_pszContentType<<endl;
wcout<<L" Content Src :" << pDocsEntry->m_pszContentSrc<<endl;
wcout<<L" LinkAlternate :" << pDocsEntry->m_pszLinkAlternate<<endl;
wcout<<L" ResumeableEditMedia :" << (pDocsEntry->m_pszLinkResumableEditMedia?pDocsEntry->m_pszLinkResumableEditMedia:L"")<<endl;
wcout<<L" AuthorName :" << pDocsEntry->m_pszAuthorName<<endl;
wcout<<L" AuthorEmail :" << pDocsEntry->m_pszAuthorEmail<<endl;
wcout<<L" ResourceID :" << pDocsEntry->m_pszResourceId<<endl;
wcout<<L" Type :" << pDocsEntry->m_pszType<<endl;
wcout<<L" ID :" << pDocsEntry->m_pszID<<endl;
wcout<<L" LastModifiedName :" << pDocsEntry->m_pszLastModifiedByName<<endl;
wcout<<L" LastModifiedEmail :" << pDocsEntry->m_pszLastModifiedByEmail<<endl;
wcout<<L" QuotaByteUsed :" << (pDocsEntry->m_pszQuotaBytesUsed?pDocsEntry->m_pszQuotaBytesUsed:L"")<<endl;
wcout<<L" QuotaByteUsedFormat :" <<(pDocsEntry->m_pszQuotaBytesUsed? pDocsEntry->m_pszQuotaBytesUsedFormated:L"")<<endl;
wcout<<L" ACL Link :" << pDocsEntry->m_pszFeedLinkACL<<endl;
wcout<<L" Revision Link :" << (pDocsEntry->m_pszFeedLinkRevisions?pDocsEntry->m_pszFeedLinkRevisions:L"")<<endl;
wcout<<L" MD5CheckSum :" << (pDocsEntry->m_pszMD5Checksum? pDocsEntry->m_pszMD5Checksum:L"")<<endl;
wcout<<"................................................................................"<<endl;
}
}
delete pXmlDoc;
return TRUE;
}
void TiXmlElement::operator=( const TiXmlElement& base )
{
ClearThis();
base.CopyTo( this );
}
bool ETHEntityProperties::WriteToXMLFile(TiXmlElement *pHeadRoot) const
{
TiXmlElement *pRoot = new TiXmlElement(GS_L("Entity"));
pHeadRoot->LinkEndChild(pRoot);
TiXmlElement *pElement;
if (emissiveColor != ETH_DEFAULT_EMISSIVE_COLOR)
{
pElement = new TiXmlElement(GS_L("EmissiveColor"));
pRoot->LinkEndChild(pElement);
pElement->SetDoubleAttribute(GS_L("r"), emissiveColor.x);
pElement->SetDoubleAttribute(GS_L("g"), emissiveColor.y);
pElement->SetDoubleAttribute(GS_L("b"), emissiveColor.z);
pElement->SetDoubleAttribute(GS_L("a"), emissiveColor.w);
}
if (spriteCut != ETH_DEFAULT_SPRITE_CUT)
{
pElement = new TiXmlElement(GS_L("SpriteCut"));
pRoot->LinkEndChild(pElement);
pElement->SetDoubleAttribute(GS_L("x"), spriteCut.x);
pElement->SetDoubleAttribute(GS_L("y"), spriteCut.y);
}
if (scale != ETH_DEFAULT_SCALE)
{
pElement = new TiXmlElement(GS_L("Scale"));
pRoot->LinkEndChild(pElement);
pElement->SetDoubleAttribute(GS_L("x"), scale.x);
pElement->SetDoubleAttribute(GS_L("y"), scale.y);
}
if (pivotAdjust != ETH_DEFAULT_PIVOT_ADJUST)
{
pElement = new TiXmlElement(GS_L("PivotAdjust"));
pRoot->LinkEndChild(pElement);
pElement->SetDoubleAttribute(GS_L("x"), pivotAdjust.x);
pElement->SetDoubleAttribute(GS_L("y"), pivotAdjust.y);
}
if (spriteFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Sprite"));
pElement->LinkEndChild(new TiXmlText(spriteFile));
pRoot->LinkEndChild(pElement);
}
if (normalFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Normal"));
pElement->LinkEndChild(new TiXmlText(normalFile));
pRoot->LinkEndChild(pElement);
}
if (glossFile != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Gloss"));
pElement->LinkEndChild(new TiXmlText(glossFile));
pRoot->LinkEndChild(pElement);
}
if (!particleSystems.empty())
{
TiXmlElement *pParticles = new TiXmlElement(GS_L("Particles"));
pRoot->LinkEndChild(pParticles);
for (unsigned int t=0; t<particleSystems.size(); t++)
{
if (particleSystems[t]->nParticles > 0)
particleSystems[t]->WriteToXMLFile(pParticles);
}
}
if (light)
{
light->WriteToXMLFile(pRoot);
}
if (collision)
{
TiXmlElement *pCollisionRoot = collision->WriteToXMLFile(pRoot);
if (pCollisionRoot)
{
// Write polygon data
if (polygon)
{
pElement = new TiXmlElement(GS_L("Polygon"));
TiXmlText* text = new TiXmlText(polygon->GetENMLDeclaration());
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
else if (shape == BS_POLYGON) // it the polygon data is empty, write sample data into it
{
pElement = new TiXmlElement(GS_L("Polygon"));
TiXmlText* text = new TiXmlText(POLYGON_ENML_SAMPLE);
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
// Write compound shape data
if (compoundShape)
{
pElement = new TiXmlElement(GS_L("Compound"));
TiXmlText* text = new TiXmlText(compoundShape->GetENMLDeclaration());
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
else if (shape == BS_COMPOUND) // it the compound data is empty, write sample data into it
{
pElement = new TiXmlElement(GS_L("Compound"));
TiXmlText* text = new TiXmlText(COMPOUND_SHAPE_ENML_SAMPLE);
text->SetCDATA(true);
pElement->LinkEndChild(text);
pCollisionRoot->LinkEndChild(pElement);
}
// Write joint data
if (enmlJointDefinitions != GS_L(""))
{
pElement = new TiXmlElement(GS_L("Joints"));
pElement->LinkEndChild(new TiXmlText(enmlJointDefinitions));
pCollisionRoot->LinkEndChild(pElement);
}
}
}
pRoot->SetAttribute(GS_L("shape"), shape);
if (shape != BS_NONE)
{
pRoot->SetAttribute(GS_L("sensor"), sensor);
pRoot->SetAttribute(GS_L("bullet"), bullet);
pRoot->SetAttribute(GS_L("fixedRotation"), fixedRotation);
pRoot->SetDoubleAttribute(GS_L("friction"), friction);
pRoot->SetDoubleAttribute(GS_L("density"), density);
pRoot->SetDoubleAttribute(GS_L("restitution"), restitution);
pRoot->SetDoubleAttribute(GS_L("gravityScale"), gravityScale);
}
pRoot->SetAttribute(GS_L("applyLight"), applyLight);
if (applyLight)
{
pRoot->SetDoubleAttribute(GS_L("specularPower"), specularPower);
pRoot->SetDoubleAttribute(GS_L("specularBrightness"), specularBrightness);
}
pRoot->SetAttribute(GS_L("castShadow"), castShadow);
if (castShadow)
{
pRoot->SetDoubleAttribute(GS_L("shadowScale"), shadowScale);
pRoot->SetDoubleAttribute(GS_L("shadowLengthScale"), shadowLengthScale);
pRoot->SetDoubleAttribute(GS_L("shadowOpacity"), shadowOpacity);
}
pRoot->SetAttribute(GS_L("type"), type);
if (type == ET_LAYERABLE)
{
pRoot->SetDoubleAttribute(GS_L("layerDepth"), layerDepth);
}
if (soundVolume != ETH_DEFAULT_SOUND_VOLUME)
{
pRoot->SetDoubleAttribute(GS_L("soundVolume"), soundVolume);
}
if (parallaxIntensity != ETH_DEFAULT_PARALLAX_INTENS)
{
pRoot->SetDoubleAttribute(GS_L("parallaxIntensity"), parallaxIntensity);
}
if (hideFromSceneEditor != ETH_FALSE)
{
pRoot->SetAttribute(GS_L("hideFromSceneEditor"), hideFromSceneEditor);
}
pRoot->SetAttribute(GS_L("static"), staticEntity);
pRoot->SetAttribute(GS_L("blendMode"), blendMode);
WriteDataToFile(pRoot);
return true;
}
bool TransFunc1DKeys::loadOsirixCLUT(const std::string& filename) {
LINFO("Opening Osirix CLUT: " << filename);
TiXmlDocument doc(filename.c_str());
//TODO: this loader is much to specific to a certain order of XML tags and will crash if
// anything is missing (#276).
if (doc.LoadFile()) {
// read and check version of plist file
TiXmlNode* currNode = doc.FirstChild("plist");
TiXmlElement* currElement = currNode->ToElement();
currNode = currNode->FirstChild("dict");
currNode = currNode->FirstChild("key");
currElement = currNode->ToElement();
// get reference to red, green and blue channel
TiXmlElement* blueElement = 0;
TiXmlElement* greenElement = 0;
TiXmlElement* redElement = 0;
TiXmlNode* blueNode = currElement->NextSibling();
TiXmlNode* greenNode = ((blueNode->NextSibling())->NextSibling());
TiXmlNode* redNode = ((greenNode->NextSibling())->NextSibling());
blueNode = blueNode->FirstChild("integer");
greenNode = greenNode->FirstChild("integer");
redNode = redNode->FirstChild("integer");
unsigned char* data = new unsigned char[256*4];
for (int i = 0; i < 256; ++i) {
data[4*i + 0] = 0;
data[4*i + 1] = 0;
data[4*i + 2] = 0;
data[4*i + 3] = 0;
blueNode = blueNode->NextSibling("integer");
greenNode = greenNode->NextSibling("integer");
redNode = redNode->NextSibling("integer");
if (blueNode == 0 || greenNode == 0 || redNode == 0)
continue;
blueElement = blueNode->ToElement();
greenElement = greenNode->ToElement();
redElement = redNode->ToElement();
data[4*i + 0] = atoi(redElement->GetText());
data[4*i + 1] = atoi(greenElement->GetText());
data[4*i + 2] = atoi(blueElement->GetText());
data[4*i + 3] = (char)(255);
}
dimensions_ = tgt::ivec3(256, 1, 1);
generateKeys(data);
delete[] data;
return true;
}
else
return false;
}
int main(int argc, char *argv[], char *env[])
{
if (argc < 4)
{
cout
<< "Syntax: mdproject2mardyn <inputfile.cfg> <inputfile.inp> <outputfile.xml>"
<< endl;
exit(1);
}
// define the output filename
string outfile_name = "new-";
outfile_name.append(argv[2]);
TiXmlDocument doc;
TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "UTF-8", "" );
TiXmlElement * root = new TiXmlElement( "mardyncfg" );
TiXmlElement * header = new TiXmlElement( "header" );
TiXmlElement * version = new TiXmlElement( "version" );
// apply the current date instead because we supposedly up to date
time_t rawtime;
struct tm * timeinfo;
char datestr [10];
time( &rawtime);
timeinfo = localtime( &rawtime);
strftime(datestr, 10, "%Y%m%d", timeinfo);
TiXmlText * version_text = new TiXmlText( datestr );
TiXmlElement * required_plugins = new TiXmlElement( "required-plugins" );
TiXmlElement * experiment = new TiXmlElement( "experiment" );
TiXmlElement * timestep_length = new TiXmlElement( "timestep-length" );
TiXmlElement * cutoff_radius = new TiXmlElement( "cutoff-radius" );
TiXmlElement * temperature = new TiXmlElement( "temperature" );
TiXmlElement * current_time = new TiXmlElement( "current-time" );
TiXmlElement * length = new TiXmlElement( "length" );
TiXmlElement * lengthx = new TiXmlElement( "x" );
TiXmlElement * lengthy = new TiXmlElement( "y" );
TiXmlElement * lengthz = new TiXmlElement( "z" );
TiXmlElement * phase_space = new TiXmlElement( "phase-space" );
TiXmlElement * components = new TiXmlElement( "components" );
TiXmlElement * components_data = new TiXmlElement( "data" );
TiXmlElement * data_structure = new TiXmlElement( "data-structure" );
root->LinkEndChild(header);
header->LinkEndChild(version);
version->LinkEndChild(version_text);
header->LinkEndChild(required_plugins);
root->LinkEndChild(experiment);
experiment->LinkEndChild(timestep_length);
experiment->LinkEndChild(cutoff_radius);
experiment->LinkEndChild(temperature);
experiment->LinkEndChild(current_time);
experiment->LinkEndChild(length);
length->LinkEndChild(lengthx);
length->LinkEndChild(lengthy);
length->LinkEndChild(lengthz);
experiment->LinkEndChild(phase_space);
experiment->LinkEndChild(components);
components->LinkEndChild(components_data);
experiment->LinkEndChild(data_structure);
// Frist parse the .cfg file
string token;
fstream inputfstream;
inputfstream.open(argv[1]);
if (!inputfstream.is_open())
{
cout << "Error opening file " << argv[1] << " for reading.";
exit(1);
}
string output_format, output_freq, output_file = "";
while (inputfstream)
{
token.clear();
inputfstream >> token;
if (token.substr(0, 1)=="#")
{
inputfstream.ignore(INT_MAX, '\n');
} else if (token.substr(0, 1)=="")
{
inputfstream.ignore(INT_MAX, '\n');
} else if (token == "MDProjectConfig")
{
inputfstream.ignore(INT_MAX, '\n');
} else if (token == "timestepLength")
{
inputfstream >> token;
TiXmlText * timestep_length_text = new TiXmlText( token.c_str() );
timestep_length->LinkEndChild(timestep_length_text);
} else if (token == "cutoffRadius")
void CScraperParser::ParseExpression(const CStdString& input, CStdString& dest, TiXmlElement* element, bool bAppend)
{
CStdString strOutput = element->Attribute("output");
TiXmlElement* pExpression = element->FirstChildElement("expression");
if (pExpression)
{
bool bInsensitive=true;
const char* sensitive = pExpression->Attribute("cs");
if (sensitive)
if (stricmp(sensitive,"yes") == 0)
bInsensitive=false; // match case sensitive
CRegExp reg(bInsensitive);
CStdString strExpression;
if (pExpression->FirstChild())
strExpression = pExpression->FirstChild()->Value();
else
strExpression = "(.*)";
ReplaceBuffers(strExpression);
ReplaceBuffers(strOutput);
if (!reg.RegComp(strExpression.c_str()))
{
return;
}
bool bRepeat = false;
const char* szRepeat = pExpression->Attribute("repeat");
if (szRepeat)
if (stricmp(szRepeat,"yes") == 0)
bRepeat = true;
const char* szClear = pExpression->Attribute("clear");
if (szClear)
if (stricmp(szClear,"yes") == 0)
dest=""; // clear no matter if regexp fails
bool bClean[MAX_SCRAPER_BUFFERS];
GetBufferParams(bClean,pExpression->Attribute("noclean"),true);
bool bTrim[MAX_SCRAPER_BUFFERS];
GetBufferParams(bTrim,pExpression->Attribute("trim"),false);
bool bFixChars[MAX_SCRAPER_BUFFERS];
GetBufferParams(bFixChars,pExpression->Attribute("fixchars"),false);
bool bEncode[MAX_SCRAPER_BUFFERS];
GetBufferParams(bEncode,pExpression->Attribute("encode"),false);
int iOptional = -1;
pExpression->QueryIntAttribute("optional",&iOptional);
int iCompare = -1;
pExpression->QueryIntAttribute("compare",&iCompare);
if (iCompare > -1)
m_param[iCompare-1].ToLower();
CStdString curInput = input;
for (int iBuf=0;iBuf<MAX_SCRAPER_BUFFERS;++iBuf)
{
if (bClean[iBuf])
InsertToken(strOutput,iBuf+1,"!!!CLEAN!!!");
if (bTrim[iBuf])
InsertToken(strOutput,iBuf+1,"!!!TRIM!!!");
if (bFixChars[iBuf])
InsertToken(strOutput,iBuf+1,"!!!FIXCHARS!!!");
if (bEncode[iBuf])
InsertToken(strOutput,iBuf+1,"!!!ENCODE!!!");
}
int i = reg.RegFind(curInput.c_str());
while (i > -1 && (i < (int)curInput.size() || curInput.size() == 0))
{
if (!bAppend)
{
dest = "";
bAppend = true;
}
CStdString strCurOutput=strOutput;
if (iOptional > -1) // check that required param is there
{
char temp[4];
sprintf(temp,"\\%i",iOptional);
char* szParam = reg.GetReplaceString(temp);
CRegExp reg2;
reg2.RegComp("(.*)(\\\\\\(.*\\\\2.*)\\\\\\)(.*)");
int i2=reg2.RegFind(strCurOutput.c_str());
while (i2 > -1)
{
char* szRemove = reg2.GetReplaceString("\\2");
int iRemove = strlen(szRemove);
int i3 = strCurOutput.find(szRemove);
if (szParam && strcmp(szParam,""))
{
strCurOutput.erase(i3+iRemove,2);
strCurOutput.erase(i3,2);
}
else
strCurOutput.replace(strCurOutput.begin()+i3,strCurOutput.begin()+i3+iRemove+2,"");
free(szRemove);
i2 = reg2.RegFind(strCurOutput.c_str());
}
free(szParam);
}
int iLen = reg.GetFindLen();
// nasty hack #1 - & means \0 in a replace string
strCurOutput.Replace("&","!!!AMPAMP!!!");
char* result = reg.GetReplaceString(strCurOutput.c_str());
if (result && strlen(result))
{
CStdString strResult(result);
strResult.Replace("!!!AMPAMP!!!","&");
Clean(strResult);
ReplaceBuffers(strResult);
if (iCompare > -1)
{
CStdString strResultNoCase = strResult;
strResultNoCase.ToLower();
if (strResultNoCase.Find(m_param[iCompare-1]) != -1)
dest += strResult;
}
else
dest += strResult;
free(result);
}
if (bRepeat && iLen > 0)
{
curInput.erase(0,i+iLen>(int)curInput.size()?curInput.size():i+iLen);
i = reg.RegFind(curInput.c_str());
}
else
i = -1;
}
}
}
void CSlingboxFile::LoadSettings(const CStdString& strHostname)
{
// Load default settings
m_sSlingboxSettings.strHostname = strHostname;
m_sSlingboxSettings.iVideoWidth = 320;
m_sSlingboxSettings.iVideoHeight = 240;
m_sSlingboxSettings.iVideoResolution = (int)CSlingbox::RESOLUTION320X240;
m_sSlingboxSettings.iVideoBitrate = 704;
m_sSlingboxSettings.iVideoFramerate = 30;
m_sSlingboxSettings.iVideoSmoothing = 50;
m_sSlingboxSettings.iAudioBitrate = 64;
m_sSlingboxSettings.iIFrameInterval = 10;
m_sSlingboxSettings.uiCodeChannelUp = 0;
m_sSlingboxSettings.uiCodeChannelDown = 0;
for (unsigned int i = 0; i < 10; i++)
m_sSlingboxSettings.uiCodeNumber[i] = 0;
// Check if a SlingboxSettings.xml file exists
CStdString slingboxXMLFile = CProfilesManager::Get().GetUserDataItem("SlingboxSettings.xml");
if (!CFile::Exists(slingboxXMLFile))
{
CLog::Log(LOGNOTICE, "No SlingboxSettings.xml file (%s) found - using default settings",
slingboxXMLFile.c_str());
return;
}
// Load the XML file
CXBMCTinyXML slingboxXML;
if (!slingboxXML.LoadFile(slingboxXMLFile))
{
CLog::Log(LOGERROR, "%s - Error loading %s - line %d\n%s", __FUNCTION__,
slingboxXMLFile.c_str(), slingboxXML.ErrorRow(), slingboxXML.ErrorDesc());
return;
}
// Check to make sure layout is correct
TiXmlElement * pRootElement = slingboxXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(), "slingboxsettings") != 0)
{
CLog::Log(LOGERROR, "%s - Error loading %s - no <slingboxsettings> node found",
__FUNCTION__, slingboxXMLFile.c_str());
return;
}
// Success so far
CLog::Log(LOGNOTICE, "Loaded SlingboxSettings.xml from %s", slingboxXMLFile.c_str());
// Search for the first settings that specify no hostname or match our hostname
TiXmlElement *pElement;
for (pElement = pRootElement->FirstChildElement("slingbox"); pElement;
pElement = pElement->NextSiblingElement("slingbox"))
{
const char *hostname = pElement->Attribute("hostname");
if (!hostname || StringUtils::EqualsNoCase(m_sSlingboxSettings.strHostname, hostname))
{
// Load setting values
XMLUtils::GetInt(pElement, "width", m_sSlingboxSettings.iVideoWidth, 0, 640);
XMLUtils::GetInt(pElement, "height", m_sSlingboxSettings.iVideoHeight, 0, 480);
XMLUtils::GetInt(pElement, "videobitrate", m_sSlingboxSettings.iVideoBitrate, 50, 8000);
XMLUtils::GetInt(pElement, "framerate", m_sSlingboxSettings.iVideoFramerate, 1, 30);
XMLUtils::GetInt(pElement, "smoothing", m_sSlingboxSettings.iVideoSmoothing, 0, 100);
XMLUtils::GetInt(pElement, "audiobitrate", m_sSlingboxSettings.iAudioBitrate, 16, 96);
XMLUtils::GetInt(pElement, "iframeinterval", m_sSlingboxSettings.iIFrameInterval, 1, 30);
// Load any button code values
TiXmlElement * pCodes = pElement->FirstChildElement("buttons");
if (pCodes)
{
XMLUtils::GetHex(pCodes, "channelup", m_sSlingboxSettings.uiCodeChannelUp);
XMLUtils::GetHex(pCodes, "channeldown", m_sSlingboxSettings.uiCodeChannelDown);
XMLUtils::GetHex(pCodes, "zero", m_sSlingboxSettings.uiCodeNumber[0]);
XMLUtils::GetHex(pCodes, "one", m_sSlingboxSettings.uiCodeNumber[1]);
XMLUtils::GetHex(pCodes, "two", m_sSlingboxSettings.uiCodeNumber[2]);
XMLUtils::GetHex(pCodes, "three", m_sSlingboxSettings.uiCodeNumber[3]);
XMLUtils::GetHex(pCodes, "four", m_sSlingboxSettings.uiCodeNumber[4]);
XMLUtils::GetHex(pCodes, "five", m_sSlingboxSettings.uiCodeNumber[5]);
XMLUtils::GetHex(pCodes, "six", m_sSlingboxSettings.uiCodeNumber[6]);
XMLUtils::GetHex(pCodes, "seven", m_sSlingboxSettings.uiCodeNumber[7]);
XMLUtils::GetHex(pCodes, "eight", m_sSlingboxSettings.uiCodeNumber[8]);
XMLUtils::GetHex(pCodes, "nine", m_sSlingboxSettings.uiCodeNumber[9]);
}
break;
}
}
// Prepare our resolution enum mapping array
const struct
{
unsigned int uiWidth;
unsigned int uiHeight;
CSlingbox::Resolution eEnum;
} m_resolutionMap[11] = {
{0, 0, CSlingbox::NOVIDEO},
{128, 96, CSlingbox::RESOLUTION128X96},
{160, 120, CSlingbox::RESOLUTION160X120},
{176, 120, CSlingbox::RESOLUTION176X120},
{224, 176, CSlingbox::RESOLUTION224X176},
{256, 192, CSlingbox::RESOLUTION256X192},
{320, 240, CSlingbox::RESOLUTION320X240},
{352, 240, CSlingbox::RESOLUTION352X240},
{320, 480, CSlingbox::RESOLUTION320X480},
{640, 240, CSlingbox::RESOLUTION640X240},
{640, 480, CSlingbox::RESOLUTION640X480}
};
// See if the specified resolution matches something in our mapping array and
// setup things accordingly
for (unsigned int i = 0; i < 11; i++)
{
if (m_sSlingboxSettings.iVideoWidth == (int)m_resolutionMap[i].uiWidth &&
m_sSlingboxSettings.iVideoHeight == (int)m_resolutionMap[i].uiHeight)
{
m_sSlingboxSettings.iVideoResolution = (int)m_resolutionMap[i].eEnum;
return;
}
}
// If it didn't match anything setup safe defaults
CLog::Log(LOGERROR, "%s - Defaulting to 320x240 resolution due to invalid "
"resolution specified in SlingboxSettings.xml for Slingbox: %s",
__FUNCTION__, m_sSlingboxSettings.strHostname.c_str());
m_sSlingboxSettings.iVideoWidth = 320;
m_sSlingboxSettings.iVideoHeight = 240;
m_sSlingboxSettings.iVideoResolution = (int)CSlingbox::RESOLUTION320X240;
}
ConfirmationDisputed::ConfirmationDisputed(TiXmlNode* xmlNode)
: ResponseMessage(xmlNode)
{
#ifdef ConsolePrint
std::string initialtap_ = FileManager::instance().tap_;
FileManager::instance().tap_.append(" ");
#endif
//originatingEventNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* originatingEventNode = xmlNode->FirstChildElement("originatingEvent");
if(originatingEventNode){originatingEventIsNull_ = false;}
else{originatingEventIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- originatingEventNode , address : " << originatingEventNode << std::endl;
#endif
if(originatingEventNode)
{
if(originatingEventNode->Attribute("href") || originatingEventNode->Attribute("id"))
{
if(originatingEventNode->Attribute("id"))
{
originatingEventIDRef_ = originatingEventNode->Attribute("id");
originatingEvent_ = boost::shared_ptr<OriginatingEvent>(new OriginatingEvent(originatingEventNode));
originatingEvent_->setID(originatingEventIDRef_);
IDManager::instance().setID(originatingEventIDRef_,originatingEvent_);
}
else if(originatingEventNode->Attribute("href")) { originatingEventIDRef_ = originatingEventNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { originatingEvent_ = boost::shared_ptr<OriginatingEvent>(new OriginatingEvent(originatingEventNode));}
}
//tradeNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* tradeNode = xmlNode->FirstChildElement("trade");
if(tradeNode){tradeIsNull_ = false;}
else{tradeIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- tradeNode , address : " << tradeNode << std::endl;
#endif
if(tradeNode)
{
if(tradeNode->Attribute("href") || tradeNode->Attribute("id"))
{
if(tradeNode->Attribute("id"))
{
tradeIDRef_ = tradeNode->Attribute("id");
trade_ = boost::shared_ptr<Trade>(new Trade(tradeNode));
trade_->setID(tradeIDRef_);
IDManager::instance().setID(tradeIDRef_,trade_);
}
else if(tradeNode->Attribute("href")) { tradeIDRef_ = tradeNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { trade_ = boost::shared_ptr<Trade>(new Trade(tradeNode));}
}
//amendmentNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* amendmentNode = xmlNode->FirstChildElement("amendment");
if(amendmentNode){amendmentIsNull_ = false;}
else{amendmentIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- amendmentNode , address : " << amendmentNode << std::endl;
#endif
if(amendmentNode)
{
if(amendmentNode->Attribute("href") || amendmentNode->Attribute("id"))
{
if(amendmentNode->Attribute("id"))
{
amendmentIDRef_ = amendmentNode->Attribute("id");
amendment_ = boost::shared_ptr<TradeAmendmentContent>(new TradeAmendmentContent(amendmentNode));
amendment_->setID(amendmentIDRef_);
IDManager::instance().setID(amendmentIDRef_,amendment_);
}
else if(amendmentNode->Attribute("href")) { amendmentIDRef_ = amendmentNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { amendment_ = boost::shared_ptr<TradeAmendmentContent>(new TradeAmendmentContent(amendmentNode));}
}
//increaseNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* increaseNode = xmlNode->FirstChildElement("increase");
if(increaseNode){increaseIsNull_ = false;}
else{increaseIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- increaseNode , address : " << increaseNode << std::endl;
#endif
if(increaseNode)
{
if(increaseNode->Attribute("href") || increaseNode->Attribute("id"))
{
if(increaseNode->Attribute("id"))
{
increaseIDRef_ = increaseNode->Attribute("id");
increase_ = boost::shared_ptr<TradeNotionalChange>(new TradeNotionalChange(increaseNode));
increase_->setID(increaseIDRef_);
IDManager::instance().setID(increaseIDRef_,increase_);
}
else if(increaseNode->Attribute("href")) { increaseIDRef_ = increaseNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { increase_ = boost::shared_ptr<TradeNotionalChange>(new TradeNotionalChange(increaseNode));}
}
//terminatingEventNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* terminatingEventNode = xmlNode->FirstChildElement("terminatingEvent");
if(terminatingEventNode){terminatingEventIsNull_ = false;}
else{terminatingEventIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- terminatingEventNode , address : " << terminatingEventNode << std::endl;
#endif
if(terminatingEventNode)
{
if(terminatingEventNode->Attribute("href") || terminatingEventNode->Attribute("id"))
{
if(terminatingEventNode->Attribute("id"))
{
terminatingEventIDRef_ = terminatingEventNode->Attribute("id");
terminatingEvent_ = boost::shared_ptr<TerminatingEvent>(new TerminatingEvent(terminatingEventNode));
terminatingEvent_->setID(terminatingEventIDRef_);
IDManager::instance().setID(terminatingEventIDRef_,terminatingEvent_);
}
else if(terminatingEventNode->Attribute("href")) { terminatingEventIDRef_ = terminatingEventNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { terminatingEvent_ = boost::shared_ptr<TerminatingEvent>(new TerminatingEvent(terminatingEventNode));}
}
//terminationNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* terminationNode = xmlNode->FirstChildElement("termination");
if(terminationNode){terminationIsNull_ = false;}
else{terminationIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- terminationNode , address : " << terminationNode << std::endl;
#endif
if(terminationNode)
{
if(terminationNode->Attribute("href") || terminationNode->Attribute("id"))
{
if(terminationNode->Attribute("id"))
{
terminationIDRef_ = terminationNode->Attribute("id");
termination_ = boost::shared_ptr<TradeNotionalChange>(new TradeNotionalChange(terminationNode));
termination_->setID(terminationIDRef_);
IDManager::instance().setID(terminationIDRef_,termination_);
}
else if(terminationNode->Attribute("href")) { terminationIDRef_ = terminationNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { termination_ = boost::shared_ptr<TradeNotionalChange>(new TradeNotionalChange(terminationNode));}
}
//novationNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* novationNode = xmlNode->FirstChildElement("novation");
if(novationNode){novationIsNull_ = false;}
else{novationIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- novationNode , address : " << novationNode << std::endl;
#endif
if(novationNode)
{
if(novationNode->Attribute("href") || novationNode->Attribute("id"))
{
if(novationNode->Attribute("id"))
{
novationIDRef_ = novationNode->Attribute("id");
novation_ = boost::shared_ptr<TradeNovationContent>(new TradeNovationContent(novationNode));
novation_->setID(novationIDRef_);
IDManager::instance().setID(novationIDRef_,novation_);
}
else if(novationNode->Attribute("href")) { novationIDRef_ = novationNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { novation_ = boost::shared_ptr<TradeNovationContent>(new TradeNovationContent(novationNode));}
}
//optionExerciseNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* optionExerciseNode = xmlNode->FirstChildElement("optionExercise");
if(optionExerciseNode){optionExerciseIsNull_ = false;}
else{optionExerciseIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- optionExerciseNode , address : " << optionExerciseNode << std::endl;
#endif
if(optionExerciseNode)
{
if(optionExerciseNode->Attribute("href") || optionExerciseNode->Attribute("id"))
{
if(optionExerciseNode->Attribute("id"))
{
optionExerciseIDRef_ = optionExerciseNode->Attribute("id");
optionExercise_ = boost::shared_ptr<OptionExercise>(new OptionExercise(optionExerciseNode));
optionExercise_->setID(optionExerciseIDRef_);
IDManager::instance().setID(optionExerciseIDRef_,optionExercise_);
}
else if(optionExerciseNode->Attribute("href")) { optionExerciseIDRef_ = optionExerciseNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { optionExercise_ = boost::shared_ptr<OptionExercise>(new OptionExercise(optionExerciseNode));}
}
//optionExpiryNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* optionExpiryNode = xmlNode->FirstChildElement("optionExpiry");
if(optionExpiryNode){optionExpiryIsNull_ = false;}
else{optionExpiryIsNull_ = true;}
if(optionExpiryNode)
{
for(optionExpiryNode; optionExpiryNode; optionExpiryNode = optionExpiryNode->NextSiblingElement("optionExpiry")){
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- optionExpiryNode , address : " << optionExpiryNode << std::endl;
#endif
if(optionExpiryNode->Attribute("href") || optionExpiryNode->Attribute("id"))
{
if(optionExpiryNode->Attribute("id"))
{
optionExpiryIDRef_ = optionExpiryNode->Attribute("id");
optionExpiry_.push_back(boost::shared_ptr<OptionExpiry>(new OptionExpiry(optionExpiryNode)));
optionExpiry_.back()->setID(optionExpiryIDRef_);
IDManager::instance().setID(optionExpiryIDRef_, optionExpiry_.back());
}
else if(optionExpiryNode->Attribute("href")) { optionExpiryIDRef_ = optionExpiryNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { optionExpiry_.push_back(boost::shared_ptr<OptionExpiry>(new OptionExpiry(optionExpiryNode)));}
}
}
else {
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- optionExpiryNode , address : " << optionExpiryNode << std::endl;
#endif
}
//deClearNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* deClearNode = xmlNode->FirstChildElement("deClear");
if(deClearNode){deClearIsNull_ = false;}
else{deClearIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- deClearNode , address : " << deClearNode << std::endl;
#endif
if(deClearNode)
{
if(deClearNode->Attribute("href") || deClearNode->Attribute("id"))
{
if(deClearNode->Attribute("id"))
{
deClearIDRef_ = deClearNode->Attribute("id");
deClear_ = boost::shared_ptr<DeClear>(new DeClear(deClearNode));
deClear_->setID(deClearIDRef_);
IDManager::instance().setID(deClearIDRef_,deClear_);
}
else if(deClearNode->Attribute("href")) { deClearIDRef_ = deClearNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { deClear_ = boost::shared_ptr<DeClear>(new DeClear(deClearNode));}
}
//withdrawalNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* withdrawalNode = xmlNode->FirstChildElement("withdrawal");
if(withdrawalNode){withdrawalIsNull_ = false;}
else{withdrawalIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- withdrawalNode , address : " << withdrawalNode << std::endl;
#endif
if(withdrawalNode)
{
if(withdrawalNode->Attribute("href") || withdrawalNode->Attribute("id"))
{
if(withdrawalNode->Attribute("id"))
{
withdrawalIDRef_ = withdrawalNode->Attribute("id");
withdrawal_ = boost::shared_ptr<Withdrawal>(new Withdrawal(withdrawalNode));
withdrawal_->setID(withdrawalIDRef_);
IDManager::instance().setID(withdrawalIDRef_,withdrawal_);
}
else if(withdrawalNode->Attribute("href")) { withdrawalIDRef_ = withdrawalNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { withdrawal_ = boost::shared_ptr<Withdrawal>(new Withdrawal(withdrawalNode));}
}
//additionalEventNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* additionalEventNode = xmlNode->FirstChildElement("additionalEvent");
if(additionalEventNode){additionalEventIsNull_ = false;}
else{additionalEventIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- additionalEventNode , address : " << additionalEventNode << std::endl;
#endif
if(additionalEventNode)
{
if(additionalEventNode->Attribute("href") || additionalEventNode->Attribute("id"))
{
if(additionalEventNode->Attribute("id"))
{
additionalEventIDRef_ = additionalEventNode->Attribute("id");
additionalEvent_ = boost::shared_ptr<AdditionalEvent>(new AdditionalEvent(additionalEventNode));
additionalEvent_->setID(additionalEventIDRef_);
IDManager::instance().setID(additionalEventIDRef_,additionalEvent_);
}
else if(additionalEventNode->Attribute("href")) { additionalEventIDRef_ = additionalEventNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { additionalEvent_ = boost::shared_ptr<AdditionalEvent>(new AdditionalEvent(additionalEventNode));}
}
//partyNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* partyNode = xmlNode->FirstChildElement("party");
if(partyNode){partyIsNull_ = false;}
else{partyIsNull_ = true;}
if(partyNode)
{
for(partyNode; partyNode; partyNode = partyNode->NextSiblingElement("party")){
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- partyNode , address : " << partyNode << std::endl;
#endif
if(partyNode->Attribute("href") || partyNode->Attribute("id"))
{
if(partyNode->Attribute("id"))
{
partyIDRef_ = partyNode->Attribute("id");
party_.push_back(boost::shared_ptr<Party>(new Party(partyNode)));
party_.back()->setID(partyIDRef_);
IDManager::instance().setID(partyIDRef_, party_.back());
}
else if(partyNode->Attribute("href")) { partyIDRef_ = partyNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { party_.push_back(boost::shared_ptr<Party>(new Party(partyNode)));}
}
}
else {
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- partyNode , address : " << partyNode << std::endl;
#endif
}
//accountNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* accountNode = xmlNode->FirstChildElement("account");
if(accountNode){accountIsNull_ = false;}
else{accountIsNull_ = true;}
if(accountNode)
{
for(accountNode; accountNode; accountNode = accountNode->NextSiblingElement("account")){
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- accountNode , address : " << accountNode << std::endl;
#endif
if(accountNode->Attribute("href") || accountNode->Attribute("id"))
{
if(accountNode->Attribute("id"))
{
accountIDRef_ = accountNode->Attribute("id");
account_.push_back(boost::shared_ptr<Account>(new Account(accountNode)));
account_.back()->setID(accountIDRef_);
IDManager::instance().setID(accountIDRef_, account_.back());
}
else if(accountNode->Attribute("href")) { accountIDRef_ = accountNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { account_.push_back(boost::shared_ptr<Account>(new Account(accountNode)));}
}
}
else {
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- accountNode , address : " << accountNode << std::endl;
#endif
}
//reasonNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* reasonNode = xmlNode->FirstChildElement("reason");
if(reasonNode){reasonIsNull_ = false;}
else{reasonIsNull_ = true;}
if(reasonNode)
{
for(reasonNode; reasonNode; reasonNode = reasonNode->NextSiblingElement("reason")){
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- reasonNode , address : " << reasonNode << std::endl;
#endif
if(reasonNode->Attribute("href") || reasonNode->Attribute("id"))
{
if(reasonNode->Attribute("id"))
{
reasonIDRef_ = reasonNode->Attribute("id");
reason_.push_back(boost::shared_ptr<Reason>(new Reason(reasonNode)));
reason_.back()->setID(reasonIDRef_);
IDManager::instance().setID(reasonIDRef_, reason_.back());
}
else if(reasonNode->Attribute("href")) { reasonIDRef_ = reasonNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { reason_.push_back(boost::shared_ptr<Reason>(new Reason(reasonNode)));}
}
}
else {
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- reasonNode , address : " << reasonNode << std::endl;
#endif
}
#ifdef ConsolePrint
FileManager::instance().tap_ = initialtap_;
#endif
}
string Edge305Device::getDeviceDescription() const {
if (Log::enabledDbg()) Log::dbg("GpsDevice::getDeviceDescription() "+this->displayName);
/*
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<Device xmlns="http://www.garmin.com/xmlschemas/GarminDevice/v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd">
<Model>
<PartNumber>006-B0450-00</PartNumber>
<SoftwareVersion>320</SoftwareVersion>
<Description>EDGE305 Software Version 3.20</Description>
</Model>
<Id>3305091776</Id>
<DisplayName>Your name</DisplayName>
<MassStorageMode>
<DataType>
<Name>GPSData</Name>
<File>
<Specification>
<Identifier>http://www.topografix.com/GPX/1/1</Identifier>
<Documentation>http://www.topografix.com/GPX/1/1/gpx.xsd</Documentation>
</Specification>
<Location>
<FileExtension>GPX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessHistory</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>OutputFromUnit</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessUserProfile</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<BaseName>UserProfile</BaseName>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessCourses</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<DataType>
<Name>FitnessWorkouts</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
<UpdateFile>
<PartNumber>006-B0450-00</PartNumber>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
</UpdateFile>
<UpdateFile>
<PartNumber>006-B0478-00</PartNumber>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
</UpdateFile>
</MassStorageMode>
<GarminMode>
<Protocols>
<Application Id="918">
<DataType>918</DataType>
</Application>
</Protocols>
<Extensions>
<GarminModeExtension xmlns="http://www.garmin.com/xmlschemas/GarminDeviceExtensions/v3">
<MemoryRegion>
<Id>5</Id>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
<ExpectedPartNumber>006-B0450-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0450-00</CurrentPartNumber>
<IsErased>true</IsErased>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
<MemoryRegion>
<Id>14</Id>
<Version>
<Major>3</Major>
<Minor>20</Minor>
</Version>
<Description>EDGE305</Description>
<ExpectedPartNumber>006-B0450-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0450-00</CurrentPartNumber>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
<MemoryRegion>
<Id>246</Id>
<Version>
<Major>0</Major>
<Minor>0</Minor>
</Version>
<Description>Missing</Description>
<ExpectedPartNumber>006-B0478-00</ExpectedPartNumber>
<CurrentPartNumber>006-B0478-00</CurrentPartNumber>
<IsErased>true</IsErased>
<IsUserUpdateable>true</IsUserUpdateable>
</MemoryRegion>
</GarminModeExtension>
</Extensions>
</GarminMode>
</Device>
*/
garmin_unit garmin;
if ( garmin_init(&garmin,0) != 0 ) {
garmin_close(&garmin);
} else {
Log::err("Opening of garmin device failed. No longer attached!?");
return "";
}
TiXmlDocument doc;
TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0", "UTF-8", "no" );
doc.LinkEndChild( decl );
/*<Device xmlns="http://www.garmin.com/xmlschemas/GarminDevice/v2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd">*/
TiXmlElement * device = new TiXmlElement( "Device" );
device->SetAttribute("xmlns", "http://www.garmin.com/xmlschemas/GarminDevice/v2");
device->SetAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
device->SetAttribute("xsi:schemaLocation", "http://www.garmin.com/xmlschemas/GarminDevice/v2 http://www.garmin.com/xmlschemas/GarminDevicev2.xsd");
doc.LinkEndChild( device );
/*<Model>
<PartNumber>006-B0450-00</PartNumber>
<SoftwareVersion>320</SoftwareVersion>
<Description>EDGE305 Software Version 3.20</Description>
</Model> */
TiXmlElement * model = new TiXmlElement( "Model" );
TiXmlElement * partnumber = new TiXmlElement( "PartNumber" );
partnumber->LinkEndChild(new TiXmlText("006-B0450-00"));
TiXmlElement * version = new TiXmlElement( "SoftwareVersion" );
std::stringstream ss;
ss << garmin.product.software_version;
version->LinkEndChild(new TiXmlText( ss.str() ));
TiXmlElement * descr = new TiXmlElement( "Description" );
descr->LinkEndChild(new TiXmlText(this->displayName));
model->LinkEndChild(partnumber);
model->LinkEndChild(version);
model->LinkEndChild(descr);
device->LinkEndChild( model );
/* <Id>3333333333</Id> */
TiXmlElement * id = new TiXmlElement( "Id" );
ss.str(""); // empty stringstream
ss << garmin.id;
id->LinkEndChild(new TiXmlText(ss.str()));
device->LinkEndChild(id);
/* <DisplayName>Your name</DisplayName>*/
TiXmlElement * dispName = new TiXmlElement( "DisplayName" );
dispName->LinkEndChild(new TiXmlText(this->displayName));
device->LinkEndChild(dispName);
TiXmlElement * massStorage = new TiXmlElement( "MassStorageMode" );
device->LinkEndChild(massStorage);
/*
<DataType>
<Name>GPSData</Name>
<File>
<Specification>
<Identifier>http://www.topografix.com/GPX/1/1</Identifier>
<Documentation>http://www.topografix.com/GPX/1/1/gpx.xsd</Documentation>
</Specification>
<Location>
<FileExtension>GPX</FileExtension>
</Location>
<TransferDirection>InputOutput</TransferDirection>
</File>
</DataType>
*/
TiXmlElement * dataTypes = new TiXmlElement( "DataType" );
massStorage->LinkEndChild(dataTypes);
TiXmlElement * name = new TiXmlElement( "Name" );
name->LinkEndChild(new TiXmlText("GPSData"));
dataTypes->LinkEndChild(name);
TiXmlElement * file = new TiXmlElement( "File" );
dataTypes->LinkEndChild(file);
TiXmlElement * spec = new TiXmlElement( "Specification" );
file->LinkEndChild(spec);
TiXmlElement * identifier = new TiXmlElement( "Identifier" );
identifier->LinkEndChild(new TiXmlText("http://www.topografix.com/GPX/1/1"));
spec->LinkEndChild(identifier);
TiXmlElement * docu = new TiXmlElement( "Documentation" );
docu->LinkEndChild(new TiXmlText("http://www.topografix.com/GPX/1/1/gpx.xsd"));
spec->LinkEndChild(docu);
TiXmlElement * loc = new TiXmlElement( "Location" );
file->LinkEndChild(loc);
TiXmlElement * fileEx = new TiXmlElement( "FileExtension" );
fileEx->LinkEndChild(new TiXmlText("GPX"));
loc->LinkEndChild(fileEx);
TiXmlElement * transferDir = new TiXmlElement( "TransferDirection" );
transferDir->LinkEndChild(new TiXmlText("InputOutput"));
file->LinkEndChild(transferDir);
/*
<DataType>
<Name>FitnessHistory</Name>
<File>
<Specification>
<Identifier>http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2</Identifier>
<Documentation>http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd</Documentation>
</Specification>
<Location>
<FileExtension>TCX</FileExtension>
</Location>
<TransferDirection>OutputFromUnit</TransferDirection>
</File>
</DataType>
*/
dataTypes = new TiXmlElement( "DataType" );
massStorage->LinkEndChild(dataTypes);
name = new TiXmlElement( "Name" );
name->LinkEndChild(new TiXmlText("FitnessHistory"));
dataTypes->LinkEndChild(name);
file = new TiXmlElement( "File" );
dataTypes->LinkEndChild(file);
spec = new TiXmlElement( "Specification" );
file->LinkEndChild(spec);
identifier = new TiXmlElement( "Identifier" );
identifier->LinkEndChild(new TiXmlText("http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2"));
spec->LinkEndChild(identifier);
docu = new TiXmlElement( "Documentation" );
docu->LinkEndChild(new TiXmlText("http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd"));
spec->LinkEndChild(docu);
loc = new TiXmlElement( "Location" );
file->LinkEndChild(loc);
fileEx = new TiXmlElement( "FileExtension" );
fileEx->LinkEndChild(new TiXmlText("TCX"));
loc->LinkEndChild(fileEx);
transferDir = new TiXmlElement( "TransferDirection" );
transferDir->LinkEndChild(new TiXmlText("InputOutput"));
file->LinkEndChild(transferDir);
TiXmlPrinter printer;
printer.SetIndent( "\t" );
doc.Accept( &printer );
string str = printer.Str();
if (Log::enabledDbg()) Log::dbg("GpsDevice::getDeviceDescription() Done: "+this->displayName );
return str;
}
bool final_xml_file(const char* xml_name, cat_items_mgr& mgr)
{
if(xml_name == NULL)return false;
TiXmlDocument* pdoc = new TiXmlDocument;
TiXmlElement* root = new TiXmlElement("Items");
pdoc->LinkEndChild(root);
std::map<int, cat_items>::iterator pItr = mgr.cat_items_map.begin();
for(; pItr != mgr.cat_items_map.end(); ++pItr)
{
cat_items* p_cat = &(pItr->second);
TiXmlElement* pCat = new TiXmlElement("Cat");
pCat->SetAttribute("ID", p_cat->cat_id);
pCat->SetAttribute("DbCatID", p_cat->db_cat_id);
pCat->SetAttribute("Name", p_cat->name);
pCat->SetAttribute("Max", p_cat->max);
map<int, item_attire_data>::iterator pItr2 = p_cat->item_map.begin();
for(; pItr2 != p_cat->item_map.end(); ++pItr2)
{
item_attire_data* p_data= &(pItr2->second);
TiXmlElement* pData = new TiXmlElement("Item");
pData->SetAttribute("ID", p_data->id);
pData->SetAttribute("Name", p_data->name);
pData->SetAttribute("DropLv", p_data->droplv);
pData->SetAttribute("QualityLevel", p_data->quality_level);
pData->SetAttribute("EquipPart", p_data->equip_part);
pData->SetAttribute("Price", p_data->price);
pData->SetAttribute("SellPrice", p_data->sell_price);
pData->SetAttribute("RepairPrice", p_data->repair_price);
pData->SetAttribute("UseLv", p_data->uselv);
pData->SetAttribute("Strength", p_data->strength);
pData->SetAttribute("Agility", p_data->agility);
pData->SetAttribute("BodyQuality", p_data->body_quality);
pData->SetAttribute("Stamina", p_data->stamina);
if(strlen(p_data->atk) > 0)
{
pData->SetAttribute("Atk", p_data->atk);
}
pData->SetAttribute("Def", p_data->def);
pData->SetAttribute("Duration", p_data->duration);
pData->SetAttribute("Hit", p_data->hit);
pData->SetAttribute("Dodge", p_data->dodge);
pData->SetAttribute("Crit", p_data->crit);
pData->SetAttribute("Hp", p_data->hp);
pData->SetAttribute("Mp", p_data->mp);
pData->SetAttribute("AddHp", p_data->add_hp);
pData->SetAttribute("AddMp", p_data->add_mp);
pData->SetAttribute("Slot", p_data->slot);
pData->SetAttribute("Tradability", p_data->trade_ability);
pData->SetAttribute("VipTradability", p_data->vip_trade_ability);
pData->SetAttribute("Tradable", p_data->trade_able);
pData->SetAttribute("ExploitValue", p_data->exploit_value);
pData->SetAttribute("SetID", p_data->setid);
pData->SetAttribute("honorLevel", p_data->honor_level);
pData->SetAttribute("LifeTime", p_data->life_time);
pData->SetAttribute("VipOnly", p_data->vip_only);
pData->SetAttribute("DailyId", p_data->dailyid);
pData->SetAttribute("decompose", p_data->decompose);
pData->SetAttribute("Shop", p_data->shop);
pData->SetAttribute("UnStorage", p_data->un_storage);
pData->SetAttribute("resID", p_data->res_id);
if(strlen(p_data->descipt) > 0)
{
TiXmlElement* pdescipt = new TiXmlElement("descript");
TiXmlText *pText = new TiXmlText(p_data->descipt);
pText->SetCDATA(true);
pdescipt->InsertEndChild(*pText);
pData->InsertEndChild(*pdescipt);
}
pCat->InsertEndChild(*pData);
}
root->InsertEndChild(*pCat);
}
return pdoc->SaveFile(xml_name);
}
xdl_int XdevLFTDI::readInfoFromXMLFile() {
if(getMediator()->getXmlFilename() == nullptr)
return RET_FAILED;
TiXmlDocument xmlDocument;
if(!xmlDocument.LoadFile(getMediator()->getXmlFilename())) {
XDEVL_MODULE_ERROR("Could not parse xml file: " << getMediator()->getXmlFilename() << std::endl);
return RET_FAILED;
}
TiXmlHandle docHandle(&xmlDocument);
TiXmlElement* root = docHandle.FirstChild(XdevLCorePropertiesName.c_str()).FirstChildElement("XdevLSerial").ToElement();
if(!root) {
XDEVL_MODULE_WARNING("<XdevLSerial> section not found. Using default values for the device.\n");
return RET_SUCCESS;
}
while(root != nullptr) {
if(root->Attribute("id")) {
XdevLID id(root->Attribute("id"));
if(getID() == id) {
if(root->Attribute("device")) {
m_deviceName = XdevLString(root->Attribute("device"));
}
if(root->Attribute("usb_in_size")) {
std::istringstream ss(root->Attribute("usb_in_size"));
ss >> m_usbInSize;
}
if(root->Attribute("usb_out_size")) {
std::istringstream ss(root->Attribute("usb_out_size"));
ss >> m_usbOutSize;
}
if(root->Attribute("latency_timer")) {
std::istringstream ss(root->Attribute("latency_timer"));
ss >> m_latencyTimer;
}
AdjustableOrRelativeDates::AdjustableOrRelativeDates(TiXmlNode* xmlNode)
: ISerialized(xmlNode)
{
#ifdef ConsolePrint
std::string initialtap_ = FileManager::instance().tap_;
FileManager::instance().tap_.append(" ");
#endif
//adjustableDatesNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* adjustableDatesNode = xmlNode->FirstChildElement("adjustableDates");
if(adjustableDatesNode){adjustableDatesIsNull_ = false;}
else{adjustableDatesIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- adjustableDatesNode , address : " << adjustableDatesNode << std::endl;
#endif
if(adjustableDatesNode)
{
if(adjustableDatesNode->Attribute("href") || adjustableDatesNode->Attribute("id"))
{
if(adjustableDatesNode->Attribute("id"))
{
adjustableDatesIDRef_ = adjustableDatesNode->Attribute("id");
adjustableDates_ = boost::shared_ptr<AdjustableDates>(new AdjustableDates(adjustableDatesNode));
adjustableDates_->setID(adjustableDatesIDRef_);
IDManager::instance().setID(adjustableDatesIDRef_,adjustableDates_);
}
else if(adjustableDatesNode->Attribute("href")) { adjustableDatesIDRef_ = adjustableDatesNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { adjustableDates_ = boost::shared_ptr<AdjustableDates>(new AdjustableDates(adjustableDatesNode));}
}
//relativeDatesNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* relativeDatesNode = xmlNode->FirstChildElement("relativeDates");
if(relativeDatesNode){relativeDatesIsNull_ = false;}
else{relativeDatesIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- relativeDatesNode , address : " << relativeDatesNode << std::endl;
#endif
if(relativeDatesNode)
{
if(relativeDatesNode->Attribute("href") || relativeDatesNode->Attribute("id"))
{
if(relativeDatesNode->Attribute("id"))
{
relativeDatesIDRef_ = relativeDatesNode->Attribute("id");
relativeDates_ = boost::shared_ptr<RelativeDates>(new RelativeDates(relativeDatesNode));
relativeDates_->setID(relativeDatesIDRef_);
IDManager::instance().setID(relativeDatesIDRef_,relativeDates_);
}
else if(relativeDatesNode->Attribute("href")) { relativeDatesIDRef_ = relativeDatesNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { relativeDates_ = boost::shared_ptr<RelativeDates>(new RelativeDates(relativeDatesNode));}
}
#ifdef ConsolePrint
FileManager::instance().tap_ = initialtap_;
#endif
}
TiXmlElement::TiXmlElement( const TiXmlElement& copy)
: TiXmlNode( TiXmlNode::ELEMENT )
{
firstChild = lastChild = 0;
copy.CopyTo( this );
}
Clearing::Clearing(TiXmlNode* xmlNode)
: ISerialized(xmlNode)
{
#ifdef ConsolePrint
std::string initialtap_ = FileManager::instance().tap_;
FileManager::instance().tap_.append(" ");
#endif
//submittedNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* submittedNode = xmlNode->FirstChildElement("submitted");
if(submittedNode){submittedIsNull_ = false;}
else{submittedIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- submittedNode , address : " << submittedNode << std::endl;
#endif
if(submittedNode)
{
if(submittedNode->Attribute("href") || submittedNode->Attribute("id"))
{
if(submittedNode->Attribute("id"))
{
submittedIDRef_ = submittedNode->Attribute("id");
submitted_ = boost::shared_ptr<TradeWrapper>(new TradeWrapper(submittedNode));
submitted_->setID(submittedIDRef_);
IDManager::instance().setID(submittedIDRef_,submitted_);
}
else if(submittedNode->Attribute("href")) { submittedIDRef_ = submittedNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { submitted_ = boost::shared_ptr<TradeWrapper>(new TradeWrapper(submittedNode));}
}
//clearedNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* clearedNode = xmlNode->FirstChildElement("cleared");
if(clearedNode){clearedIsNull_ = false;}
else{clearedIsNull_ = true;}
if(clearedNode)
{
for(clearedNode; clearedNode; clearedNode = clearedNode->NextSiblingElement("cleared")){
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- clearedNode , address : " << clearedNode << std::endl;
#endif
if(clearedNode->Attribute("href") || clearedNode->Attribute("id"))
{
if(clearedNode->Attribute("id"))
{
clearedIDRef_ = clearedNode->Attribute("id");
cleared_.push_back(boost::shared_ptr<TradeWrapper>(new TradeWrapper(clearedNode)));
cleared_.back()->setID(clearedIDRef_);
IDManager::instance().setID(clearedIDRef_, cleared_.back());
}
else if(clearedNode->Attribute("href")) { clearedIDRef_ = clearedNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { cleared_.push_back(boost::shared_ptr<TradeWrapper>(new TradeWrapper(clearedNode)));}
}
}
else {
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- clearedNode , address : " << clearedNode << std::endl;
#endif
}
#ifdef ConsolePrint
FileManager::instance().tap_ = initialtap_;
#endif
}
bool ETHEntityProperties::ReadFromXMLFile(TiXmlElement *pElement)
{
pElement->QueryIntAttribute(GS_L("type"), (int*)&type);
int nStaticEntity = static_cast<int>(staticEntity);
pElement->QueryIntAttribute(GS_L("static"), &nStaticEntity);
staticEntity = static_cast<ETH_BOOL>(nStaticEntity);
int nApplyLight = static_cast<int>(applyLight);
pElement->QueryIntAttribute(GS_L("applyLight"), &nApplyLight);
applyLight = static_cast<ETH_BOOL>(nApplyLight);
int nCastShadow = static_cast<int>(castShadow);
pElement->QueryIntAttribute(GS_L("castShadow"), &nCastShadow);
castShadow = static_cast<ETH_BOOL>(nCastShadow);
int nHideFromSceneEditor = static_cast<int>(hideFromSceneEditor);
pElement->QueryIntAttribute(GS_L("hideFromSceneEditor"), &nHideFromSceneEditor);
hideFromSceneEditor = static_cast<ETH_BOOL>(nHideFromSceneEditor);
pElement->QueryIntAttribute(GS_L("shape"), (int*)&shape);
pElement->QueryIntAttribute(GS_L("blendMode"), (int*)&blendMode);
pElement->QueryFloatAttribute(GS_L("layerDepth"), &layerDepth);
pElement->QueryFloatAttribute(GS_L("soundVolume"), &soundVolume);
pElement->QueryFloatAttribute(GS_L("parallaxIntensity"), ¶llaxIntensity);
if (applyLight)
{
pElement->QueryFloatAttribute(GS_L("specularPower"), &specularPower);
pElement->QueryFloatAttribute(GS_L("specularBrightness"), &specularBrightness);
}
if (castShadow)
{
pElement->QueryFloatAttribute(GS_L("shadowScale"), &shadowScale);
pElement->QueryFloatAttribute(GS_L("shadowLengthScale"), &shadowLengthScale);
pElement->QueryFloatAttribute(GS_L("shadowOpacity"), &shadowOpacity);
}
if (shape != BS_NONE)
{
int nSensor = static_cast<int>(sensor);
pElement->QueryIntAttribute(GS_L("sensor"), &nSensor);
sensor = static_cast<ETH_BOOL>(nSensor);
int nFixedRotation = static_cast<int>(fixedRotation);
pElement->QueryIntAttribute(GS_L("fixedRotation"), &nFixedRotation);
fixedRotation = static_cast<ETH_BOOL>(nFixedRotation);
int nBullet = static_cast<int>(bullet);
pElement->QueryIntAttribute(GS_L("bullet"), &nBullet);
bullet = static_cast<ETH_BOOL>(nBullet);
pElement->QueryFloatAttribute(GS_L("friction"), &friction);
pElement->QueryFloatAttribute(GS_L("density"), &density);
pElement->QueryFloatAttribute(GS_L("gravityScale"), &gravityScale);
pElement->QueryFloatAttribute(GS_L("restitution"), &restitution);
}
TiXmlElement *pIter;
TiXmlNode *pNode;
pNode = pElement->FirstChild(GS_L("EmissiveColor"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
pIter->QueryFloatAttribute(GS_L("r"), &emissiveColor.x);
pIter->QueryFloatAttribute(GS_L("g"), &emissiveColor.y);
pIter->QueryFloatAttribute(GS_L("b"), &emissiveColor.z);
pIter->QueryFloatAttribute(GS_L("a"), &emissiveColor.w);
}
}
pNode = pElement->FirstChild(GS_L("SpriteCut"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
pIter->QueryIntAttribute(GS_L("x"), &spriteCut.x);
pIter->QueryIntAttribute(GS_L("y"), &spriteCut.y);
}
}
pNode = pElement->FirstChild(GS_L("Scale"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
pIter->QueryFloatAttribute(GS_L("x"), &scale.x);
pIter->QueryFloatAttribute(GS_L("y"), &scale.y);
}
}
pNode = pElement->FirstChild(GS_L("PivotAdjust"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
pIter->QueryFloatAttribute(GS_L("x"), &pivotAdjust.x);
pIter->QueryFloatAttribute(GS_L("y"), &pivotAdjust.y);
}
}
pNode = pElement->FirstChild(GS_L("Sprite"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
spriteFile = pIter->GetText();
}
}
pNode = pElement->FirstChild(GS_L("Normal"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
normalFile = pIter->GetText();
}
}
pNode = pElement->FirstChild(GS_L("Gloss"));
if (pNode)
{
pIter = pNode->ToElement();
if (pIter)
{
glossFile = pIter->GetText();
}
}
pNode = pElement->FirstChild(GS_L("Particles"));
if (pNode)
{
TiXmlElement *pParticles = pNode->ToElement();
if (pParticles)
{
pNode = pParticles->FirstChild(GS_L("ParticleSystem"));
if (pNode)
{
TiXmlElement *pParticleIter = pNode->ToElement();
if (pParticleIter)
{
// TODO: use unlimited amount of systems
for (std::size_t t = 0; t < ETH_MAX_PARTICLE_SYS_PER_ENTITY; t++)
{
if (pParticleIter)
{
boost::shared_ptr<ETHParticleSystem> newSystem = boost::shared_ptr<ETHParticleSystem>(new ETHParticleSystem);
newSystem->ReadFromXMLFile(pParticleIter);
if (newSystem->nParticles > 0)
{
particleSystems.push_back(newSystem);
}
pParticleIter = pParticleIter->NextSiblingElement();
}
}
}
}
}
}
pNode = pElement->FirstChild(GS_L("Light"));
if (pNode)
{
TiXmlElement *pLight = pNode->ToElement();
if (pLight)
{
boost::shared_ptr<ETHLight> newLight = boost::shared_ptr<ETHLight>(new ETHLight(true));
newLight->ReadFromXMLFile(pLight);
if (newLight->IsActive() && newLight->range > 0.0f)
{
light = newLight;
// forces the light 'static' flag to be the same as its owner's
light->staticLight = staticEntity;
}
}
}
{
int nCollidable = 1;
const int r = pElement->QueryIntAttribute(GS_L("collidable"), &nCollidable);
if (nCollidable || r == TIXML_NO_ATTRIBUTE)
{
pNode = pElement->FirstChild(GS_L("Collision"));
if (pNode)
{
collision = boost::shared_ptr<ETHCollisionBox>(new ETHCollisionBox);
TiXmlElement *pCollision = pNode->ToElement();
if (pCollision)
{
collision->ReadFromXMLFile(pCollision);
}
// if it's a legacy entity, it may have a collision body in its XML even though it is not collidable
if (collision->size == Vector3(0, 0, 0))
{
collision.reset();
}
{
TiXmlNode *pPolygonNode = pNode->FirstChild(GS_L("Polygon"));
if (pPolygonNode)
{
pIter = pPolygonNode->ToElement();
if (pIter)
{
polygon = ETHPolygonPtr(new ETHPolygon(pIter->GetText()));
}
}
else
{
TiXmlNode *pCompoundNode = pNode->FirstChild(GS_L("Compound"));
if (pCompoundNode)
{
pIter = pCompoundNode->ToElement();
if (pIter)
{
compoundShape = ETHCompoundShapePtr(new ETHCompoundShape(pIter->GetText()));
}
}
}
}
{
TiXmlNode *pJointsNode = pNode->FirstChild(GS_L("Joints"));
if (pJointsNode)
{
pIter = pJointsNode->ToElement();
if (pIter)
{
enmlJointDefinitions = pIter->GetText();
}
}
}
}
}
}
ReadDataFromXMLFile(pElement);
return true;
}
//*********************************************************************************************
bool CRTVDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CURL url(strPath);
CStdString strRoot = strPath;
URIUtils::AddSlashAtEnd(strRoot);
// Host name is "*" so we try to discover all ReplayTVs. This requires some trickery but works.
if (url.GetHostName() == "*")
{
// Check to see whether the URL's path is blank or "Video"
if (url.GetFileName() == "" || url.GetFileName() == "Video")
{
int iOldSize=items.Size();
struct RTV * rtv = NULL;
int numRTV;
// Request that all ReplayTVs on the LAN identify themselves. Each ReplayTV
// is given 3000ms to respond to the request. rtv_discovery returns an array
// of structs containing the IP and friendly name of all ReplayTVs found on the LAN.
// For some reason, DVArchive doesn't respond to this request (probably only responds
// to requests from an IP address of a real ReplayTV).
numRTV = rtv_discovery(&rtv, 3000);
// Run through the array and add the ReplayTVs found as folders in XBMC.
// We must add the IP of each ReplayTV as if it is a file name at the end of a the
// auto-discover URL--e.g. rtv://*/192.168.1.100--because XBMC does not permit
// dyamically added shares and will not play from them. This little trickery is
// the best workaround I could come up with.
for (int i = 0; i < numRTV; i++)
{
CFileItemPtr pItem(new CFileItem(rtv[i].friendlyName));
// This will keep the /Video or / and allow one to set up an auto ReplayTV
// share of either type--simple file listing or ReplayGuide listing.
pItem->m_strPath = strRoot + rtv[i].hostname;
pItem->m_bIsFolder = true;
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
free(rtv);
return (items.Size()>iOldSize);
// Else the URL's path should be an IP address of the ReplayTV
}
else
{
CStdString strURL, strRTV;
int pos;
// Isolate the IP from the URL and replace the "*" with the real IP
// of the ReplayTV. E.g., rtv://*/Video/192.168.1.100/ becomes
// rtv://192.168.1.100/Video/ . This trickery makes things work.
strURL = strRoot.TrimRight('/');
pos = strURL.ReverseFind('/');
strRTV = strURL.Left(pos + 1);
strRTV.Replace("*", strURL.Mid(pos + 1));
CURL tmpURL(strRTV);
// Force the newly constructed share into the right variables to
// be further processed by the remainder of GetDirectory.
url = tmpURL;
strRoot = strRTV;
}
}
// Allow for ReplayTVs on ports other than 80
CStdString strHostAndPort;
strHostAndPort = url.GetHostName();
if (url.HasPort())
{
char buffer[10];
strHostAndPort += ':';
strHostAndPort += itoa(url.GetPort(), buffer, 10);
}
// No path given, list shows from ReplayGuide
if (url.GetFileName() == "")
{
unsigned char * data = NULL;
// Get the RTV guide data in XML format
rtv_get_guide_xml(&data, strHostAndPort.c_str());
// Begin parsing the XML data
TiXmlDocument xmlDoc;
xmlDoc.Parse( (const char *) data );
if ( xmlDoc.Error() )
{
free(data);
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement)
{
free(data);
return false;
}
const TiXmlNode *pChild = pRootElement->FirstChild();
while (pChild > 0)
{
CStdString strTagName = pChild->Value();
if ( !strcmpi(strTagName.c_str(), "ITEM") )
{
const TiXmlNode *nameNode = pChild->FirstChild("DISPLAYNAME");
const TiXmlNode *qualityNode = pChild->FirstChild("QUALITY");
const TiXmlNode *recordedNode = pChild->FirstChild("RECORDED");
const TiXmlNode *pathNode = pChild->FirstChild("PATH");
const TiXmlNode *durationNode = pChild->FirstChild("DURATION");
const TiXmlNode *sizeNode = pChild->FirstChild("SIZE");
const TiXmlNode *atrbNode = pChild->FirstChild("ATTRIB");
SYSTEMTIME dtDateTime;
DWORD dwFileSize = 0;
memset(&dtDateTime, 0, sizeof(dtDateTime));
// DISPLAYNAME
const char* szName = NULL;
if (nameNode)
{
szName = nameNode->FirstChild()->Value() ;
}
else
{
// Something went wrong, the recording has no name
free(data);
return false;
}
// QUALITY
const char* szQuality = NULL;
if (qualityNode)
{
szQuality = qualityNode->FirstChild()->Value() ;
}
// RECORDED
if (recordedNode)
{
CStdString strRecorded = recordedNode->FirstChild()->Value();
int iYear, iMonth, iDay;
iYear = atoi(strRecorded.Left(4).c_str());
iMonth = atoi(strRecorded.Mid(5, 2).c_str());
iDay = atoi(strRecorded.Mid(8, 2).c_str());
dtDateTime.wYear = iYear;
dtDateTime.wMonth = iMonth;
dtDateTime.wDay = iDay;
int iHour, iMin, iSec;
iHour = atoi(strRecorded.Mid(11, 2).c_str());
iMin = atoi(strRecorded.Mid(14, 2).c_str());
iSec = atoi(strRecorded.Mid(17, 2).c_str());
dtDateTime.wHour = iHour;
dtDateTime.wMinute = iMin;
dtDateTime.wSecond = iSec;
}
// PATH
const char* szPath = NULL;
if (pathNode)
{
szPath = pathNode->FirstChild()->Value() ;
}
else
{
// Something went wrong, the recording has no filename
free(data);
return false;
}
// DURATION
const char* szDuration = NULL;
if (durationNode)
{
szDuration = durationNode->FirstChild()->Value() ;
}
// SIZE
// NOTE: Size here is actually just duration in minutes because
// filesize is not reported by the stripped down GuideParser I use
if (sizeNode)
{
dwFileSize = atol( sizeNode->FirstChild()->Value() );
}
// ATTRIB
// NOTE: Not currently reported in the XML guide data, nor is it particularly
// needed unless someone wants to add the ability to sub-divide the recordings
// into categories, as on a real RTV.
int attrib = 0;
if (atrbNode)
{
attrib = atoi( atrbNode->FirstChild()->Value() );
}
bool bIsFolder(false);
if (attrib & FILE_ATTRIBUTE_DIRECTORY)
bIsFolder = true;
CFileItemPtr pItem(new CFileItem(szName));
pItem->m_dateTime=dtDateTime;
pItem->m_strPath = strRoot + szPath;
// Hack to show duration of show in minutes as KB in XMBC because
// it doesn't currently permit showing duration in minutes.
// E.g., a 30 minute show will show as 29.3 KB in XBMC.
pItem->m_dwSize = dwFileSize * 1000;
pItem->m_bIsFolder = bIsFolder;
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
pChild = pChild->NextSibling();
}
free(data);
// Path given (usually Video), list filenames only
}
else
{
unsigned char * data;
char * p, * q;
unsigned long status;
// Return a listing of all files in the given path
status = rtv_list_files(&data, strHostAndPort.c_str(), url.GetFileName().c_str());
if (status == 0)
{
return false;
}
// Loop through the file list using pointers p and q, where p will point to the current
// filename and q will point to the next filename
p = (char *) data;
while (p)
{
// Look for the end of the current line of the file listing
q = strchr(p, '\n');
// If found, replace the newline character with the NULL terminator
if (q)
{
*q = '\0';
// Increment q so that it points to the next filename
q++;
// *p should be the current null-terminated filename in the list
if (*p)
{
// Only display MPEG files in XBMC (but not circular.mpg, as that is the RTV
// video buffer and XBMC may cause problems if it tries to play it)
if (strstr(p, ".mpg") && !strstr(p, "circular"))
{
CFileItemPtr pItem(new CFileItem(p));
pItem->m_strPath = strRoot + p;
pItem->m_bIsFolder = false;
// The list returned by the RTV doesn't include file sizes, unfortunately
//pItem->m_dwSize = atol(szSize);
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
}
}
// Point p to the next filename in the list and loop
p = q;
}
free(data);
}
return true;
}
bool CPlayerCoreFactory::LoadConfiguration(TiXmlElement* pConfig, bool clear)
{
if (clear)
{
for(std::vector<CPlayerCoreConfig *>::iterator it = s_vecCoreConfigs.begin(); it != s_vecCoreConfigs.end(); it++)
delete *it;
s_vecCoreConfigs.clear();
// Builtin players; hard-coded because re-ordering them would break scripts
CPlayerCoreConfig* dvdplayer = new CPlayerCoreConfig("DVDPlayer", EPC_DVDPLAYER, NULL);
dvdplayer->m_bPlaysAudio = dvdplayer->m_bPlaysVideo = true;
s_vecCoreConfigs.push_back(dvdplayer);
// Don't remove this, its a placeholder for the old MPlayer core, it would break scripts
CPlayerCoreConfig* mplayer = new CPlayerCoreConfig("oldmplayercore", EPC_DVDPLAYER, NULL);
s_vecCoreConfigs.push_back(mplayer);
CPlayerCoreConfig* paplayer = new CPlayerCoreConfig("PAPlayer", EPC_PAPLAYER, NULL);
paplayer->m_bPlaysAudio = true;
s_vecCoreConfigs.push_back(paplayer);
for(std::vector<CPlayerSelectionRule *>::iterator it = s_vecCoreSelectionRules.begin(); it != s_vecCoreSelectionRules.end(); it++)
delete *it;
s_vecCoreSelectionRules.clear();
}
if (!pConfig || strcmpi(pConfig->Value(),"playercorefactory") != 0)
{
CLog::Log(LOGERROR, "Error loading configuration, no <playercorefactory> node");
return false;
}
TiXmlElement *pPlayers = pConfig->FirstChildElement("players");
if (pPlayers)
{
TiXmlElement* pPlayer = pPlayers->FirstChildElement("player");
while (pPlayer)
{
CStdString name = pPlayer->Attribute("name");
CStdString type = pPlayer->Attribute("type");
if (type.length() == 0) type = name;
type.ToLower();
EPLAYERCORES eCore = EPC_NONE;
if (type == "dvdplayer" || type == "mplayer") eCore = EPC_DVDPLAYER;
if (type == "paplayer" ) eCore = EPC_PAPLAYER;
if (type == "externalplayer" ) eCore = EPC_EXTPLAYER;
if (eCore != EPC_NONE)
{
s_vecCoreConfigs.push_back(new CPlayerCoreConfig(name, eCore, pPlayer));
}
pPlayer = pPlayer->NextSiblingElement("player");
}
}
TiXmlElement *pRule = pConfig->FirstChildElement("rules");
while (pRule)
{
const char* szAction = pRule->Attribute("action");
if (szAction)
{
if (stricmp(szAction, "append") == 0)
{
s_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
else if (stricmp(szAction, "prepend") == 0)
{
s_vecCoreSelectionRules.insert(s_vecCoreSelectionRules.begin(), 1, new CPlayerSelectionRule(pRule));
}
else
{
s_vecCoreSelectionRules.clear();
s_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
}
else
{
s_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
pRule = pRule->NextSiblingElement("rules");
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded playercorefactory configuration");
return true;
}
bool MantisBot::CheckForGoogleCodeChanges(const __ConfigProject& conf)
{
char tmp[HTTP_BUFFER_SIZE];
std::string buffer;
ssize_t len;
// Download the feed from the specified Google Code URL
HTTPClient http(m_config.data.googlecode.address, m_httpGoogleCodeAddr, m_httpGoogleCodeBindAddr, false);
http.Connect(conf.path);
http.Send();
if (!http.Ok()) return false;
if (http.ResponseStatus() != 200)
{
printf("Unable to connect to the web page (%s%s): %d %s\n",
m_config.data.googlecode.address, conf.path,
http.ResponseStatus(), http.StatusText());
return false;
}
// Grab the feed data
HTTPStream& stream = http.GetStream();
if (!stream.Ok()) return false;
while (stream.Eof() == false)
{
len = stream.Read(tmp, HTTP_BUFFER_SIZE);
if ( len > 0 )
buffer.append(tmp, len);
}
// We got the feed, now start processing it's XML contents
TiXmlDocument xml;
TiXmlNode *feed, *node;
xml.Parse(buffer.c_str());
if (xml.Error())
{
printf("Unable to parse XML feed in %s: %s\n", xml.Value(), xml.ErrorDesc());
return false;
}
feed = xml.FirstChild("feed");
if (!feed) return false;
node = feed->FirstChild("entry");
// Loop through the entry nodes
size_t index;
int currentId, newestId = -1;
std::string strAuthor, strDescription, strLink;
const char *attr;
while (node)
{
TiXmlNode *data = node->FirstChild("title");
if (!data) return false;
TiXmlElement *elem = data->ToElement ();
if (!elem) return false;
std::string strText = elem->GetText ();
// Revision
index = strText.find("Revision ") + 9;
currentId = atoi(strText.substr(index, strText.find(":",index) - index).c_str());
// Description
index = strText.find(":",index) + 2;
strDescription = strText.substr(index);
TrimSpaces(strDescription);
// Author
data = node->FirstChild("author");
if (!data) return false;
data = data->FirstChild("name");
if (!data) return false;
elem = data->ToElement ();
if (!elem) return false;
strAuthor = elem->GetText ();
// Link
data = node->FirstChild("link");
if (!data) return false;
elem = data->ToElement ();
if (!elem) return false;
attr = elem->Attribute ("href");
if (!attr) return false;
strLink = std::string ( attr );
// First entry will always be the newest
if (newestId == -1) {
newestId = currentId;
// If this is our first run, store the newest entry id
if ( m_lastGoogleCodeId.find(conf.alias) == m_lastGoogleCodeId.end() )
m_lastGoogleCodeId[conf.alias] = newestId;
}
// If this entry is newer than the last stored id
if (currentId > m_lastGoogleCodeId[conf.alias])
{ // This is a new entry
SendTextToChannels(
IRCText(
"[%U%s%U] %C02%Br%d%B%C %C12(%s)%C %C10%s%C %C03-%C "
"%C14%s%C",
conf.alias, currentId, strAuthor.c_str (), strDescription.c_str (),
strLink.c_str ()
)
);
if ( conf.autofix )
CheckForAutofixIssue ( strAuthor, strDescription, strLink );
}
// Advance to next sibling
node = node->NextSiblingElement ();
}
m_lastGoogleCodeId[conf.alias] = newestId;
return true;
}
bool CSettings::LoadSettings(const CStdString& strSettingsFile)
{
// load the xml file
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strSettingsFile))
{
CLog::Log(LOGERROR, "%s, Line %d\n%s", strSettingsFile.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (strcmpi(pRootElement->Value(), "settings") != 0)
{
CLog::Log(LOGERROR, "%s\nDoesn't contain <settings>", strSettingsFile.c_str());
return false;
}
// mymusic settings
TiXmlElement *pElement = pRootElement->FirstChildElement("mymusic");
if (pElement)
{
TiXmlElement *pChild = pElement->FirstChildElement("playlist");
if (pChild)
{
XMLUtils::GetBoolean(pChild, "repeat", m_bMyMusicPlaylistRepeat);
XMLUtils::GetBoolean(pChild, "shuffle", m_bMyMusicPlaylistShuffle);
}
GetInteger(pElement, "startwindow", m_iMyMusicStartWindow, WINDOW_MUSIC_FILES, WINDOW_MUSIC_FILES, WINDOW_MUSIC_NAV); //501; view songs
XMLUtils::GetBoolean(pElement, "songinfoinvis", m_bMyMusicSongInfoInVis);
XMLUtils::GetBoolean(pElement, "songthumbinvis", m_bMyMusicSongThumbInVis);
GetInteger(pElement, "needsupdate", m_musicNeedsUpdate, 0, 0, INT_MAX);
GetPath(pElement, "defaultlibview", m_defaultMusicLibSource);
}
// myvideos settings
pElement = pRootElement->FirstChildElement("myvideos");
if (pElement)
{
GetInteger(pElement, "startwindow", m_iVideoStartWindow, WINDOW_VIDEO_FILES, WINDOW_VIDEO_FILES, WINDOW_VIDEO_NAV);
XMLUtils::GetBoolean(pElement, "stackvideos", m_videoStacking);
XMLUtils::GetBoolean(pElement, "flatten", m_bMyVideoNavFlatten);
GetInteger(pElement, "needsupdate", m_videoNeedsUpdate, 0, 0, INT_MAX);
TiXmlElement *pChild = pElement->FirstChildElement("playlist");
if (pChild)
{ // playlist
XMLUtils::GetBoolean(pChild, "repeat", m_bMyVideoPlaylistRepeat);
XMLUtils::GetBoolean(pChild, "shuffle", m_bMyVideoPlaylistShuffle);
}
}
// general settings
pElement = pRootElement->FirstChildElement("general");
if (pElement)
{
GetInteger(pElement, "systemtotaluptime", m_iSystemTimeTotalUp, 0, 0, INT_MAX);
XMLUtils::GetBoolean(pElement, "addonautoupdate", m_bAddonAutoUpdate);
XMLUtils::GetBoolean(pElement, "addonnotifications", m_bAddonNotifications);
XMLUtils::GetBoolean(pElement, "addonforeignfilter", m_bAddonForeignFilter);
}
// audio settings
pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "mute", m_bMute);
GetFloat(pElement, "fvolumelevel", m_fVolumeLevel, VOLUME_MAXIMUM, VOLUME_MINIMUM, VOLUME_MAXIMUM);
}
LoadCalibration(pRootElement, strSettingsFile);
g_guiSettings.LoadXML(pRootElement);
// load any ISubSettings implementations
return Load(pRootElement);
}
void IPXMenic::getIPXFilteringParams()
{
TiXmlElement *element;
element = filter_params->FirstChildElement("local_mac_address");
if (element != NULL)
SrcMAC = element->GetText();
element = filter_params->FirstChildElement("remote_mac_address");
if (element != NULL)
DstMAC = element->GetText();
element = filter_params->FirstChildElement("transport_control");
if (element != NULL)
transControl = element->GetText();
element = filter_params->FirstChildElement("protocol_type");
if (element != NULL)
type = element->GetText();
element = filter_params->FirstChildElement("remote_net_address");
if (element != NULL)
DstNetwork = element->GetText();
element = filter_params->FirstChildElement("remote_mac_address");
if (element != NULL)
DstNode = element->GetText();
element = filter_params->FirstChildElement("remote_socket_address");
if (element != NULL)
DstSocket = element->GetText();
/*********************************************************************/
element = filter_params->FirstChildElement("local_net_address");
if (element != NULL)
SrcNetwork = element->GetText();
element = filter_params->FirstChildElement("local_mac_address");
if (element != NULL)
SrcNode = element->GetText();
element = filter_params->FirstChildElement("local_socket_address");
if (element != NULL)
SrcSocket = element->GetText();
}
BOOL GDocsAPITest::CopyConstructorTest()
{
login();
GDocsEntry* ppp ;
TiXmlDocument * pXmlDoc = new TiXmlDocument();
m_pGDocsApi->GetEntryList("https://docs.google.com/feeds/default/private/full/", pXmlDoc);
TiXmlElement* pFeedElement = pXmlDoc->FirstChildElement("feed");
TiXmlElement* pElement = pFeedElement->FirstChildElement("entry");
// pElement = pElement->NextSiblingElement("entry");
GDocsEntry* docsEntry= new GDocsEntry(pElement);
{
GDocsEntry* copyEntry = new GDocsEntry(*docsEntry);
ppp= copyEntry;
if ( wcscmp(copyEntry->m_pszGDEtag, docsEntry->m_pszGDEtag) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszIDUrl, docsEntry->m_pszIDUrl) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszPublished, docsEntry->m_pszPublished) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszUpdated, docsEntry->m_pszUpdated) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszAppEdited, docsEntry->m_pszAppEdited) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (copyEntry->m_bIsStarred != docsEntry->m_bIsStarred)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (copyEntry->m_bIsHidden != docsEntry->m_bIsHidden)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (copyEntry->m_bIsViewed != docsEntry->m_bIsViewed)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszTitle, docsEntry->m_pszTitle) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszContentType, docsEntry->m_pszContentType) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszContentSrc, docsEntry->m_pszContentSrc) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (copyEntry->m_vecParents.size() != docsEntry->m_vecParents.size() )
{
cout<< "Wrong!!!!!!"<<endl;
}
vector<LinkParent>::const_iterator iter1 = docsEntry->m_vecParents.begin();
for (vector<LinkParent>::const_iterator iter2 = copyEntry->m_vecParents.begin(); iter2 != copyEntry->m_vecParents.end(); iter2++)
{
if (wcscmp(iter1->lpszParentHref, iter2->lpszParentHref) != 0)
cout<< "Wrong!!!!!!"<<endl;
if (wcscmp(iter1->lpszParentTitle, iter2->lpszParentTitle) != 0)
cout<< "Wrong!!!!!!"<<endl;
iter1++;
}
if (wcscmp(copyEntry->m_pszLinkAlternate, docsEntry->m_pszLinkAlternate) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszLinkSelf, docsEntry->m_pszLinkSelf) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszLinkEdit, docsEntry->m_pszLinkEdit) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszLinkResumableEditMedia, docsEntry->m_pszLinkResumableEditMedia) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (docsEntry->m_pszLinkThumbNail)
{
if (wcscmp(copyEntry->m_pszLinkThumbNail, docsEntry->m_pszLinkThumbNail) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
}
if (wcscmp(copyEntry->m_pszAuthorName, docsEntry->m_pszAuthorName) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszAuthorEmail, docsEntry->m_pszAuthorEmail) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszResourceId, docsEntry->m_pszResourceId) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszType, docsEntry->m_pszType) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszID, docsEntry->m_pszID) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszLastModifiedByName, docsEntry->m_pszLastModifiedByName) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszLastModifiedByEmail, docsEntry->m_pszLastModifiedByEmail) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszQuotaBytesUsed, docsEntry->m_pszQuotaBytesUsed) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszQuotaBytesUsedFormated, docsEntry->m_pszQuotaBytesUsedFormated) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if ( copyEntry->m_bIsWritersCanInvite != docsEntry->m_bIsWritersCanInvite)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszFeedLinkACL, docsEntry->m_pszFeedLinkACL) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
if (wcscmp(copyEntry->m_pszFeedLinkRevisions, docsEntry->m_pszFeedLinkRevisions) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
cout<<"done"<<endl;
if (docsEntry->m_pszMD5Checksum)
{
if (wcscmp(copyEntry->m_pszMD5Checksum, docsEntry->m_pszMD5Checksum) != 0)
{
cout<< "Wrong!!!!!!"<<endl;
}
}
delete docsEntry;
}
/*pElement = pElement->NextSiblingElement("entry");
docsEntry(pElement);
*/
int i=0;
return TRUE;
}
void KeyboardShortcuts::importFile(TiXmlElement* rootElement, KeySource source)
{
// <keyboard><commands><key>
TiXmlHandle handle(rootElement);
TiXmlElement* xmlKey = handle
.FirstChild("commands")
.FirstChild("key").ToElement();
while (xmlKey) {
const char* command_name = xmlKey->Attribute("command");
const char* command_key = get_shortcut(xmlKey);
bool removed = bool_attr_is_true(xmlKey, "removed");
if (command_name) {
Command* command = CommandsModule::instance()->getCommandByName(command_name);
if (command) {
// Read context
KeyContext keycontext = KeyContext::Any;
const char* keycontextstr = xmlKey->Attribute("context");
if (keycontextstr) {
if (strcmp(keycontextstr, "Selection") == 0)
keycontext = KeyContext::SelectionTool;
else if (strcmp(keycontextstr, "Normal") == 0)
keycontext = KeyContext::Normal;
}
// Read params
Params params;
TiXmlElement* xmlParam = xmlKey->FirstChildElement("param");
while (xmlParam) {
const char* param_name = xmlParam->Attribute("name");
const char* param_value = xmlParam->Attribute("value");
if (param_name && param_value)
params.set(param_name, param_value);
xmlParam = xmlParam->NextSiblingElement();
}
// add the keyboard shortcut to the command
Key* key = this->command(command_name, params, keycontext);
if (key && command_key) {
Accelerator accel(command_key);
if (!removed) {
key->add(accel, source);
// Add the shortcut to the menuitems with this command
// (this is only visual, the
// "CustomizedGuiManager::onProcessMessage" is the only
// one that process keyboard shortcuts)
if (key->accels().size() == 1) {
AppMenus::instance()->applyShortcutToMenuitemsWithCommand(
command, params, key);
}
}
else
key->disableAccel(accel);
}
}
}
xmlKey = xmlKey->NextSiblingElement();
}
// Load keyboard shortcuts for tools
// <gui><keyboard><tools><key>
xmlKey = handle
.FirstChild("tools")
.FirstChild("key").ToElement();
while (xmlKey) {
const char* tool_id = xmlKey->Attribute("tool");
const char* tool_key = get_shortcut(xmlKey);
bool removed = bool_attr_is_true(xmlKey, "removed");
if (tool_id) {
tools::Tool* tool = App::instance()->getToolBox()->getToolById(tool_id);
if (tool) {
Key* key = this->tool(tool);
if (key && tool_key) {
LOG(" - Shortcut for tool `%s': <%s>\n", tool_id, tool_key);
Accelerator accel(tool_key);
if (!removed)
key->add(accel, source);
else
key->disableAccel(accel);
}
}
}
xmlKey = xmlKey->NextSiblingElement();
}
// Load keyboard shortcuts for quicktools
// <gui><keyboard><quicktools><key>
xmlKey = handle
.FirstChild("quicktools")
.FirstChild("key").ToElement();
while (xmlKey) {
const char* tool_id = xmlKey->Attribute("tool");
const char* tool_key = get_shortcut(xmlKey);
bool removed = bool_attr_is_true(xmlKey, "removed");
if (tool_id) {
tools::Tool* tool = App::instance()->getToolBox()->getToolById(tool_id);
if (tool) {
Key* key = this->quicktool(tool);
if (key && tool_key) {
LOG(" - Shortcut for quicktool `%s': <%s>\n", tool_id, tool_key);
Accelerator accel(tool_key);
if (!removed)
key->add(accel, source);
else
key->disableAccel(accel);
}
}
}
xmlKey = xmlKey->NextSiblingElement();
}
// Load special keyboard shortcuts for sprite editor customization
// <gui><keyboard><spriteeditor>
xmlKey = handle
.FirstChild("actions")
.FirstChild("key").ToElement();
while (xmlKey) {
const char* tool_action = xmlKey->Attribute("action");
const char* tool_key = get_shortcut(xmlKey);
bool removed = bool_attr_is_true(xmlKey, "removed");
if (tool_action) {
KeyAction action = base::convert_to<KeyAction, std::string>(tool_action);
if (action != KeyAction::None) {
Key* key = this->action(action);
if (key && tool_key) {
LOG(" - Shortcut for action '%s': <%s>\n", tool_action, tool_key);
Accelerator accel(tool_key);
if (!removed)
key->add(accel, source);
else
key->disableAccel(accel);
}
}
}
xmlKey = xmlKey->NextSiblingElement();
}
}
void OnlineSearchState::doSearchServers()
{
// Get the serverlist
try
{
BlobNet::Layer::Http http("blobby.sourceforge.net", 80);
std::stringstream serverListXml;
http.request("server.php", serverListXml);
// this trows an exception if the file could not be opened for writing
FileWrite file("onlineserver.xml");
file.write(serverListXml.str());
file.close();
} catch (std::exception& e) {
std::cout << "Can't get onlineserver.xml: " << e.what() << std::endl;
} catch (...) {
std::cout << "Can't get onlineserver.xml. Unknown error." << std::endl;
}
std::vector< std::pair<std::string, int> > serverList;
// Get the serverlist
try {
boost::shared_ptr<TiXmlDocument> serverListXml = FileRead::readXMLDocument("onlineserver.xml");
if (serverListXml->Error())
{
std::cerr << "Warning: Parse error in " << "onlineserver.xml";
std::cerr << "!" << std::endl;
}
TiXmlElement* onlineserverElem = serverListXml->FirstChildElement("onlineserver");
if (onlineserverElem == NULL)
{
std::cout << "Can't read onlineserver.xml" << std::endl;
return;
}
for (TiXmlElement* serverElem = onlineserverElem->FirstChildElement("server");
serverElem != NULL;
serverElem = serverElem->NextSiblingElement("server"))
{
std::string host;
int port;
for (TiXmlElement* varElem = serverElem->FirstChildElement("var");
varElem != NULL;
varElem = varElem->NextSiblingElement("var"))
{
const char* tmp;
tmp = varElem->Attribute("host");
if(tmp)
{
host = tmp;
continue;
}
tmp = varElem->Attribute("port");
if(tmp)
{
try
{
port = boost::lexical_cast<int>(tmp);
}
catch (boost::bad_lexical_cast)
{
port = BLOBBY_PORT;
}
if ((port <= 0) || (port > 65535))
{
port = BLOBBY_PORT;
}
continue;
}
}
std::pair<std::string, int> pairs(host, port);
serverList.push_back(pairs);
}
} catch (...) {
std::cout << "Can't read onlineserver.xml" << std::endl;
}
/// \todo check if we already try to connect to this one!
std::string address = IUserConfigReader::createUserConfigReader("config.xml")->getString("additional_network_server");
std::string server = address;
int port = BLOBBY_PORT;
std::size_t found = address.find(':');
if (found != std::string::npos)
{
server = address.substr(0, found);
try
{
port = boost::lexical_cast<int>(address.substr(found+1));
}
catch (boost::bad_lexical_cast)
{
/// \todo inform the user that default port was selected
}
if ((port <= 0) || (port > 65535))
port = BLOBBY_PORT;
}
std::pair<std::string, int> pairs(server.c_str(), port);
serverList.push_back(pairs);
mScannedServers.clear();
mPingClient->Initialize( serverList.size() + 2, 0, 10 );
for( auto& server : serverList )
{
// if we receive the cancel signal from the main thread, we leave as soon as possible
if(mCancelPing)
break;
std::cout << "ping" << server.first << "\n";
mPingClient->Ping(server.first.c_str(), server.second, true);
}
}
void KeyboardShortcuts::exportAccel(TiXmlElement& parent, Key* key, const ui::Accelerator& accel, bool removed)
{
TiXmlElement elem("key");
switch (key->type()) {
case KeyType::Command: {
const char* keycontextStr = NULL;
elem.SetAttribute("command", key->command()->id().c_str());
switch (key->keycontext()) {
case KeyContext::Any:
// Without "context" attribute
break;
case KeyContext::Normal:
keycontextStr = "Normal";
break;
case KeyContext::SelectionTool:
keycontextStr = "Selection";
break;
case KeyContext::TranslatingSelection:
keycontextStr = "TranslatingSelection";
break;
case KeyContext::ScalingSelection:
keycontextStr = "ScalingSelection";
break;
case KeyContext::RotatingSelection:
keycontextStr = "RotatingSelection";
break;
case KeyContext::MoveTool:
keycontextStr = "MoveTool";
break;
case KeyContext::FreehandTool:
keycontextStr = "FreehandTool";
break;
case KeyContext::ShapeTool:
keycontextStr = "ShapeTool";
break;
}
if (keycontextStr)
elem.SetAttribute("context", keycontextStr);
for (const auto& param : key->params()) {
if (param.second.empty())
continue;
TiXmlElement paramElem("param");
paramElem.SetAttribute("name", param.first.c_str());
paramElem.SetAttribute("value", param.second.c_str());
elem.InsertEndChild(paramElem);
}
break;
}
case KeyType::Tool:
case KeyType::Quicktool:
elem.SetAttribute("tool", key->tool()->getId().c_str());
break;
case KeyType::Action:
elem.SetAttribute("action",
base::convert_to<std::string>(key->action()).c_str());
break;
}
elem.SetAttribute("shortcut", accel.toString().c_str());
if (removed)
elem.SetAttribute("removed", "true");
parent.InsertEndChild(elem);
}
PayoffBase::PayoffBase(TiXmlNode* xmlNode)
: ISerialized(xmlNode)
{
#ifdef ConsolePrint
std::string initialtap_ = FileManager::instance().tap_;
FileManager::instance().tap_.append(" ");
#endif
//payoffDateNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* payoffDateNode = xmlNode->FirstChildElement("payoffDate");
if(payoffDateNode){payoffDateIsNull_ = false;}
else{payoffDateIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- payoffDateNode , address : " << payoffDateNode << std::endl;
#endif
if(payoffDateNode)
{
if(payoffDateNode->Attribute("href") || payoffDateNode->Attribute("id"))
{
if(payoffDateNode->Attribute("id"))
{
payoffDateIDRef_ = payoffDateNode->Attribute("id");
payoffDate_ = boost::shared_ptr<XsdTypeToken>(new XsdTypeToken(payoffDateNode));
payoffDate_->setID(payoffDateIDRef_);
IDManager::instance().setID(payoffDateIDRef_,payoffDate_);
}
else if(payoffDateNode->Attribute("href")) { payoffDateIDRef_ = payoffDateNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { payoffDate_ = boost::shared_ptr<XsdTypeToken>(new XsdTypeToken(payoffDateNode));}
}
//constPayoffNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* constPayoffNode = xmlNode->FirstChildElement("constPayoff");
if(constPayoffNode){constPayoffIsNull_ = false;}
else{constPayoffIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- constPayoffNode , address : " << constPayoffNode << std::endl;
#endif
if(constPayoffNode)
{
if(constPayoffNode->Attribute("href") || constPayoffNode->Attribute("id"))
{
if(constPayoffNode->Attribute("id"))
{
constPayoffIDRef_ = constPayoffNode->Attribute("id");
constPayoff_ = boost::shared_ptr<ConstPayoff>(new ConstPayoff(constPayoffNode));
constPayoff_->setID(constPayoffIDRef_);
IDManager::instance().setID(constPayoffIDRef_,constPayoff_);
}
else if(constPayoffNode->Attribute("href")) { constPayoffIDRef_ = constPayoffNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { constPayoff_ = boost::shared_ptr<ConstPayoff>(new ConstPayoff(constPayoffNode));}
}
//nullPayoffNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* nullPayoffNode = xmlNode->FirstChildElement("nullPayoff");
if(nullPayoffNode){nullPayoffIsNull_ = false;}
else{nullPayoffIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- nullPayoffNode , address : " << nullPayoffNode << std::endl;
#endif
if(nullPayoffNode)
{
if(nullPayoffNode->Attribute("href") || nullPayoffNode->Attribute("id"))
{
if(nullPayoffNode->Attribute("id"))
{
nullPayoffIDRef_ = nullPayoffNode->Attribute("id");
nullPayoff_ = boost::shared_ptr<NullPayoff>(new NullPayoff(nullPayoffNode));
nullPayoff_->setID(nullPayoffIDRef_);
IDManager::instance().setID(nullPayoffIDRef_,nullPayoff_);
}
else if(nullPayoffNode->Attribute("href")) { nullPayoffIDRef_ = nullPayoffNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { nullPayoff_ = boost::shared_ptr<NullPayoff>(new NullPayoff(nullPayoffNode));}
}
//averPayoffNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* averPayoffNode = xmlNode->FirstChildElement("averPayoff");
if(averPayoffNode){averPayoffIsNull_ = false;}
else{averPayoffIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- averPayoffNode , address : " << averPayoffNode << std::endl;
#endif
if(averPayoffNode)
{
if(averPayoffNode->Attribute("href") || averPayoffNode->Attribute("id"))
{
if(averPayoffNode->Attribute("id"))
{
averPayoffIDRef_ = averPayoffNode->Attribute("id");
averPayoff_ = boost::shared_ptr<AverPayoff>(new AverPayoff(averPayoffNode));
averPayoff_->setID(averPayoffIDRef_);
IDManager::instance().setID(averPayoffIDRef_,averPayoff_);
}
else if(averPayoffNode->Attribute("href")) { averPayoffIDRef_ = averPayoffNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { averPayoff_ = boost::shared_ptr<AverPayoff>(new AverPayoff(averPayoffNode));}
}
//exprPayoffNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* exprPayoffNode = xmlNode->FirstChildElement("exprPayoff");
if(exprPayoffNode){exprPayoffIsNull_ = false;}
else{exprPayoffIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- exprPayoffNode , address : " << exprPayoffNode << std::endl;
#endif
if(exprPayoffNode)
{
if(exprPayoffNode->Attribute("href") || exprPayoffNode->Attribute("id"))
{
if(exprPayoffNode->Attribute("id"))
{
exprPayoffIDRef_ = exprPayoffNode->Attribute("id");
exprPayoff_ = boost::shared_ptr<ExprPayoff>(new ExprPayoff(exprPayoffNode));
exprPayoff_->setID(exprPayoffIDRef_);
IDManager::instance().setID(exprPayoffIDRef_,exprPayoff_);
}
else if(exprPayoffNode->Attribute("href")) { exprPayoffIDRef_ = exprPayoffNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { exprPayoff_ = boost::shared_ptr<ExprPayoff>(new ExprPayoff(exprPayoffNode));}
}
//preFixPayoffNode ----------------------------------------------------------------------------------------------------------------------
TiXmlElement* preFixPayoffNode = xmlNode->FirstChildElement("preFixPayoff");
if(preFixPayoffNode){preFixPayoffIsNull_ = false;}
else{preFixPayoffIsNull_ = true;}
#ifdef ConsolePrint
FileManager::instance().outFile_ << FileManager::instance().tap_.c_str() << "- preFixPayoffNode , address : " << preFixPayoffNode << std::endl;
#endif
if(preFixPayoffNode)
{
if(preFixPayoffNode->Attribute("href") || preFixPayoffNode->Attribute("id"))
{
if(preFixPayoffNode->Attribute("id"))
{
preFixPayoffIDRef_ = preFixPayoffNode->Attribute("id");
preFixPayoff_ = boost::shared_ptr<PreFixPayoff>(new PreFixPayoff(preFixPayoffNode));
preFixPayoff_->setID(preFixPayoffIDRef_);
IDManager::instance().setID(preFixPayoffIDRef_,preFixPayoff_);
}
else if(preFixPayoffNode->Attribute("href")) { preFixPayoffIDRef_ = preFixPayoffNode->Attribute("href");}
else { QL_FAIL("id or href error"); }
}
else { preFixPayoff_ = boost::shared_ptr<PreFixPayoff>(new PreFixPayoff(preFixPayoffNode));}
}
#ifdef ConsolePrint
FileManager::instance().tap_ = initialtap_;
#endif
}
ReaclibVer::ReaclibVer(TiXmlElement *pElement){
// set the default values
m_Q = 0;
m_pstrModified = NULL;
m_bCurrent = false;
m_version = 1;
m_id = 0;
// keep track of this
m_pVer = pElement;
// loop through all the elements children
for(TiXmlNode *pNode = m_pVer->FirstChild(); pNode; pNode=pNode->NextSibling()){
// check to see if this is another node
if(pNode->Type() == TiXmlNode::ELEMENT){
// convert this to a type
TiXmlElement *pElement = pNode->ToElement();
// check to see if this is a known type
if(strcmp(pElement->Value(),"set") ==0){
// create the new version
ReaclibSet* newSet = new ReaclibSet(pElement);
// add the version to the listing
addSet(newSet, true);
}
}
}
// load the attributes
// the modified date
const char *pstrValue;
if((pstrValue = m_pVer->Attribute("modified"))){
setModified(pstrValue);
}
// the id value
if(m_pVer->Attribute("id")){
// try to convert the id to the new value
if(EOF == sscanf(m_pVer->Attribute("id"), "%d", &m_id)){
cerr << "Unable to convert id " << m_pVer->Attribute("id") << " to an integer." << endl;
return;
}
}
// the version number
if(m_pVer->Attribute("num")){
if(EOF == sscanf(m_pVer->Attribute("num"), "%d", &m_version)){
cerr << "Unable to convert version number " << m_pVer->Attribute("num") << " to an integer." << endl;
}
}
// the Q value
if(m_pVer->Attribute("q")){
if(EOF == sscanf(m_pVer->Attribute("q"), "%e", &m_Q)){
cerr << "Unable to convert version Q " << m_pVer->Attribute("q") << " to a float." << endl;
}
}
// the current value
if(m_pVer->Attribute("current")){
// check to see if this is the current value
if(strcmp(m_pVer->Attribute("current"), "1") == 0){
m_bCurrent = true;
}
}
return;
}
