Hey everyone,

Been spending two days trying to figure this one out, and thought I'd ask here to see if anyone could give me a definite answer on this one.

I am not sure, if this can be done in XSLT (I'm not that experienced with it), but here is my problem :

I want to call a template that may or may not have been included, if it hasn't it should resolve to another template (that is always there).

As there are no proper way of doing exception handling in XSLT, I thought maybe there was a work around or a way to emulate that kind of behaviour.

I'm using XSLT 1.0 (Sablotron).

Any feedback will be highly appreciated.

Thanks

I suspect that you're making a classic and easy mistake, which is to have a general-purpose module that includes/imports special purpose modules (conditionally). That's the wrong way around for XSLT: the special purpose module (say S) should import the general-purpose code (say G). Then G can do a call-template on a named template N; if S contains an implementation of N this will be the one chosen, otherwise it can fall back to another version of N provided by G. Because S imports G, the version in S has higher import precedence and will be chosen in preference.

Michael Kay
http://www.saxonica.com/
Author, XSLT Programmer's Reference and XPath 2.0 Programmer's Reference

Hey Michael,
Thank you for your reply.

I understand what you mean, and I did encounter that very problem at the very beginning. I suppose if I explain the issue, it might shed light on what I am really trying to do.

XSL I am trying to do is serving to be templating engine for a framework, I am currently working on.

So far this is how it works:

(S) contains 2 templates "frontend" and "admin" templates which are defined by name without a matching pattern. S also includes a "run.xsl" (R), which has a template with a matching pattern to everything.
(R) also includes 2 skins. a Frontend skin and a Backend skin.
Based on the XML structure (R) can determine which skin to call.

In the skin which is a template and renders out, there is a call-template tag that will call either Frontend or Admin (depending on which skin, backend will call admin).

Now all of this works nicely, until I realised that I had to add an additional template in (S) a "superadmin" template. Some of the modules in the framework may or may not have a superadmin function, which enables them to see more information than a normal admin would, and therefore the visual layout would be different.
However, a superadmin may also run a module as an admin, because that particular module may not have a superadmin function and will represent the information equally for admins and superadmins.

In the XML root tag you have an attribute called "user" and a value saying if its admin or superadmin. Based on that I imagined that I could do something like this

(pseudocode)

Try to call template with match pattern [@user='superadmin']
if it doesnt exist call template with match pattern [@user='admin' or @user='superadmin']

I hope this sheds more light on what I am trying to do, and I might have approached this from a bad angle. I am open to any suggestions.

Thanks.

>Try to call template with match pattern [@user='superadmin'] if it doesnt exist call template with match pattern [@user='admin']

This sounds like something that could be achieved fairly easily using apply-templates and template rules. R should do apply-templates select="/rootelement/@user", and S determines what happens when this is done. The basic principle is that your first choice template [@user='superadmin'] must have a higher import precedence or priority than your fallback template [@user='admin], and you need to arrange the import precedence (or priorities) to achieve this.

Michael Kay
http://www.saxonica.com/
Author, XSLT Programmer's Reference and XPath 2.0 Programmer's Reference