How to point at things discretely

XML processing often requires a pattern in which an identical operation is performed to several equivalent parts of a document. Sometimes we wish to store those intermediate values and use them later. However these patterns often require the processing of resources whose URI value we don't yet know or is dynamically generated. To create this type of process we need some level of indirection.

View the application here
Try the application here

This application is processing a set of sections of a document in turn. The applied process is simply placing the section into a table with a blue background - nobody said this was a real application. Each intermediate result is being written to a temporary store. Finally all the results are pulled together into one document for presentation.

This example is contrived and makes a vase full of artificial plastic flowers seem tasteful, but it illustrates the point and we refuse to apologize. Oh OK then. Sorry.

Marks for Artistic Impression - Nil Point

This application consists of two loops. The first loop processes each of the fragments and stores the result. But since we are looping round we need to create a new dynamic URI at which to store the result for each iteration of the loop. This is being created with the following instruction:

Which creates a document with an incrementing value provided from the var:counter.

This document is a canonical URI. Like the canonical boolean we met previously, a canonical URI is simply a URI expressed as an XML document. In this case inside a <uri> root element. You'll already have guessed that having a URI as an XML processible form is going to be useful.

It's value comes in to play in the actual processing part of the first loop, although first the dynamically generated canonical URI is appended to the var:results list which holds a list of all the URI's created in the first loop. We can now look at the real processing instructions:

Here we see a lock, unlock pair of instructions wrapping an execution of a sub-idoc process to actually process the current data. The interesting part is that we are using a new URI prefix curi: before the variable var:target which is holding the canonical URI.

Join The CURI Club

It is very useful in DPML to be able to treat a canonical URI document as though it were just another URI. We do this by using the curi: scheme prior to the uri of the resource which is a canonical URI. This says the resource is a canonical URI so use it's content as though it is a URI and not an XML document.

In our example we have the uri of the target as a canonical URI, which actually contains something like

So curi:var:target is actually the equivalent of using the URI temp/example1.xml directly.

Whilst we're on the subject of canonical URI's. A useful accessor that frequently complements the use of curi: is the xpur accessor. XPUR stands for XPath URI Reference. We haven't needed it in the current application but xpur isused to extract as a canonical URI a URI contained at an Xpath location in the operand document.

It sounds complicated but it's not. Basically we often have URI's inside a document. It's great to be able to grab a URI from a document using an Xpath and turn it into a canonical that we can then use in our processes, usually by simply prepending curi: to a variable.

xpur and the curi: scheme allow URI's to be processed as documents but treated as URI's. They're very convenient in dynamic applications.

Returning to the application. The first loop iterates until all sections have been processed. A record of the URI's of the intermediate results is held in var:results. The second loop iterates over var:results, obtaining the processed resources and stiches them into an HTML template. We'll leave it to you to examine the second loop to make sure we're not making it up. Needless to say the second loop makes extensive use of curi: and canonical URI's.

Aspirin and Complete Bed Rest

This section has some relatively advanced issues. Indirection is a little tricky but very useful when it comes to serious processing.

That concludes DPML by Example for now. You should now know more than enough to write pretty sophisticated XML applications. Please read the other NetKernel documentation for guides to creating XAR modules, configuring modules into applications and general system configuration. Experiment with the URA's that are provided and try creating some custom accessors.

Look out for 'In Depth DPML', 'DPML for Managers', 'Surviving, My Learn DPML in 24 Hours, Hell' and all the other DPML franchises that we're sure to want to hawk after this ;-)

Pete Rodgers - June 2003