Report writers, iText and XML...

As you can see, the interface is a little busy. There are quite a few comments, but I decided that the user could, when they created their own xml spec, delete the more obvious comments.

That was the easy part.... My biggest issue is that I know just about nothing about XML. You would think that you could do a google search and find a plethora of code examples that would let you read the kind of structure you see above.

But no... the truth is that XML, despite being a widely-known standard and being a relatively non-rocket-science data structure, is already a confusing mire of "specifications" with implementations that render their own versions of how the spec should be read in. In fact, if you know nothing about XML, it would be better to write your own parser. You could probably knock the job off in a good night, whereas if you venture into XML parsing, you'll probably take quick a few nights of research and following false trails.

I spent several nights tracking down info in DOM and JDOM and SAX and every other flavour until I found a book by Elliote Rusty Harold called Processing XML with Java at http://www.ibiblio.org/xml/books/xmljava/. This site has the full text version of Harold's book. I feel I need to digress here... I really think the future of books on Java is this kind of site instead of my basement collection which seems outdated after two weeks. In terms of trees killed and the amount of real estate my collection requires, I wonder why the concept of on-line books hasn't taken off better than it has. Anyway, you can read the entire contents of the Processing XML with Java on-line and Harold hopes you will like it enough to buy a copy.

From my point of view, it is an excellent introduction and serves to weed through the entire history of specification and implementation in a readable manner. It also contained a chapter called "Reading XML" which doesn't seem to be covered anywhere on the net. You would think that the topic of how to read an XML structure after parsing it would be a popularone. However, most sites show you how to create one, how to traverse a DOM tree and put it in a Swing tree, how to deal with whitespace, how to write from Java objects to XML, but almost nothing on reading in XML.

Processing XML has a wonderful chapter on that topic. Harold takes you through the varieties of XML parser implementation -- SAX, DOM, JAXP, JDOM, dom4j, electricXML and XMLPULL. For me, it was a little lengthy, but clarified a great of confusion. And helped me decide that JAXP, created from the Apache Crimson project and now supported in Java JDK 1.4 was a no-brainer, largely because it seems to be the simplest means of reading in the structure I need to created the report specification.

Not that it is all that simple or error-prone. My first discovery was that you cannot simply create a collection structure like columns and expect the parser to read in your Column structure. What JAXP will do is read each of the variables in a column in sequential fashion. The trick is to make sure that a variable of Column (say.. sqlName) isn't read in from a another variable in another structure (say Band, which is a column-like structure that also has a sqlName variable because it needs to access an SQL column.)

You must make sure that the parser can differentiate between Band variables and Column variables. The only way I could figure to do it was to make sure there were no name collisions between Band and Column. Therefore, you'll note that Band has a field called bandSqlName and Summary has a summarySqlColumn field. When I thought about it it was obvious that I had better preceed all the Band fields with a "band" identifier. In a way, this kind of sucks, but that's XML.

When it all came down to it, reading the XML required very little code. In fact, there are two steps in reading the XML files

Step 1. Parse the document.

private String getValueForElement(
	String element,
	int index,
	Document document) {
	Node node;
	Text result;
	String value;
	node = document.getElementsByTagName(element).item(index);
	result = (Text) node.getFirstChild();
	if (result == null) return "";
           return result.getNodeValue();
	}
}

private Column[] buildColumns(Document document){
   Column thisColumn ;
   int size = document.getElementsByTagName("column").getLength();
   Column[] columns  = new Column[size];
		
   for (int i = 0; i < size; i++){
 	thisColumn = new Column(); 
        thisColumn.setTitle(getValueForElement("coltitle", i, document));
	thisColumn.setWidthPercent( this.getInteger(
		getValueForElement("widthPercent", i, document)));
	thisColumn.setAlignment(
		getValueForElement("alignment", i, document));
	thisColumn.setSqlName(getValueForElement("sqlName", i, document));
	columns[i] = thisColumn; 
	}
		
		
	return columns;
    }
}