my desk, where I spend all my time.

The current object supports the majority of the expat libraries standard callbacks, with the exception of it’s Schema/DTD callbacks, as well as the ability to parse both a full file and a string (obtained from network resources such as SOAP and XML-RPC requests).

Additional features, demos and examples of use for the XMLObject will be released in time, these examples include integrating my existing HighScores object as an XML document, as well as retrieving the HighScores object from a network resource.

For more details, and a download link, please drop by and read the GG .plan.

• onElementStart(%this, %name, %attributes)
• onElementEnd(%this, %name)
• onCharacterData(%this, %name, %data) // %name is a reference to the last element started
• onProcessingInstruction(%this, %target, %data)
• onComment(%this, %data)
• onCdataSectionStart(%this)
• onCdataSectionEnd(%this)
• onDefault(%this, %data, %len)

Not all of the callbacks have been thoroughly tested, but the following callbacks have been tested and found to be in full working order so far;

OnElementStart, onElementEnd, onCharacterData and onComment.

It looks like I’m getting nearer and nearer to having my saveXml() and loadXml() methods fully functioning, and as seen in my previous post, I’ve already got the makings of a TorqueScript-based object/level loader.

[js]
function sceneObjectParser::onElementStart(%this, %name, %atts)
{
switch$(%name)
{
case “objects”: %this.objectBlock = true;
default:
if(%this.objectBlock)
{
%obj = new (%name)()
{
class = getAttribute(%atts, “class”);
superClass = getAttribute(%atts, “superClass”);
};
%obj.dump();
}
}
}

function sceneObjectParser::onElementEnd(%this, %name)
{
switch$(%name)
{
case “objects”: %this.objectBlock = false;
}
}

function sceneObjectParser::onCharacterData(%this, %name, %data, %len)
{
echo(“CDATA: —” @ %name @ ” – ” @ %data @ “—”);
}

function getAttribute(%atts, %name)
{
for(%x = 0; %x < %atts.getCount(); %x++)
{
if(%atts.getObject(%x).AttributeName $= %name) return %atts.getObject(%x).AttributeValue;
}
return "";
}

$xml = new XMLObject() { class = "sceneObjectParser"; objectBlock = false; };
$xml.parseDocument("XMLTestFile.xml");
[/js]

This will actually create instances of the objects identified by the xml elements inside of an "objects" node, for example, the following XML document was parsed for testing;
[xml]

[/xml]

I’ve not yet thoroughly tested it, but once I find a useful and reusable XML format for Objects and Levels, I’ll start working on the saveXml and loadXml functions respectively, and add them as either ConsoleFunctions which take in any SimObject, or add them as addon functions to the base SimObject within the XMLObject.cc itself (little to no engine code should need to be updated for this resource to work effectively)

So far, I’ve managed to create and expose the XMLObject class to TorqueScript, as well as added a ‘parseDocument’ method to the object, which is exposed to TorqueScript and takes in a Filename as it’s only parameter. This then makes numerous calls to the startElement and endElement C++ methods (there’s a static and non-static version of each, something to do with the function pointers that expat uses since its written in C). These C++ methods then call there TorqueScript equivalents, onStartElement and onEndElement, which allows a script developer to very simply use the SAX parser functionality of Expat within TorqueScript by doing the following:

[js]
function MySax::onStartElement(%this, %name, %atts)
{
echo(“ElementStart: ” @ %name);
for(%x = 0; %x < %atts.getCount(); %x++)
{
echo(” Name: ” @ %atts.getObject(%x).AttributeName);
echo(” Value: ” @ %atts.getObject(%x).AttributeValue);
}
}

function MySax::onElementEnd(%this, %name)
{
echo(“TS ElementEnd: ” @ %name);
}

%sax = new XMLObject()
{
class = “MySax”;
};

%sax.parseDocument(“XMLFile.xml”);
[/js]

I am intending to release the XMLObject code, along with any other TGB engine hacks I make that use the code, as a resource on GG’s site. I’ll post my progress here, and when I get a more completed version, I’ll post a .plan on GG’s site.

So far, all I’ve managed to cover is the Start and End element handlers, and the CDATA handler for the XML, my plans include to add the following:

1. SimObject.saveXml() — save SimObjects as XML Files rather then TorqueScript
2. SimObject.loadXml() — load SimObjects from XML Files, rather then exec()ing the TorqueScript
3. Full list of SAX Methods, as made available through Expat
4. Possibility of adding a DOM to the Code (Adding a DOM may require using yet another library, other then SAX, or a replacement to SAX that supports DOM — but I’m going to take a look at implementing a very simple DOM using my own code, and my own XPath implementation — just cause I wanna see how hard it’ll be to do ;p)