Flattens all the nuances of Haxe's Xml implementation into an enum, where it's much easier to capture data.

FlatXML.hx

import Xml;

/* Flattens all the nuances of Haxe's Xml implementation
into an enum, where it's much easier to capture data. */

enum FlatXMLNode {
	Element(
		name : String, 
		attribute : Map<String,String>, 
		children : Array<FlatXMLNode>);
	PCData(s : String);
	CData(s : String);
	Comment(s : String);
	ProcessingInstruction(s : String);
	Document(
		children : Array<FlatXMLNode>);
}

class FlatXML {

	public static function toFlat(x : Xml) : FlatXMLNode {
		switch(x.nodeType) {
			case Element:
				var am = new Map<String,String>();
				for (k in x.attributes())
					am.set(k,x.get(k));
				return Element(
					x.nodeName,
					am,
					[for (n in x) toFlat(n)]
				);
			default:
				throw 'help, i am unequipped for nodeType ${x.nodeType}';
			case PCData:
				return PCData(x.nodeValue);
			case CData:
				return CData(x.nodeValue);
			case Comment:
				return Comment(x.nodeValue);
			case ProcessingInstruction:
				return ProcessingInstruction(x.nodeValue);
			case Document:
				return Document([for (n in x) toFlat(n)]);
		}
	}

	public static function fromFlat(f : FlatXMLNode) : Xml {
		switch(f) {
			case Element(name, attribute, children):
				var x = Xml.createElement(name);
				for (a in attribute.keys()) {
					x.set(a, attribute.get(a));
				}
				for (c in children)
					x.addChild(fromFlat(c));
				return x;
			case PCData(s):
				return Xml.createPCData(s);
			case CData(s):
				return Xml.createCData(s);
			case Comment(s):
				return Xml.createComment(s);
			case ProcessingInstruction(s):
				return Xml.createProcessingInstruction(s);
			case Document(children):
				var x = Xml.createDocument();
				for (c in children)
					x.addChild(fromFlat(c));
				return x;
		}
	}

}