Slightly confused about using normalize-space.
If I have the following XML instance document (notice the spaces) :-
<compare>
<compareWith> A</compareWith>
<comparisonValues>
<value>B</value>
<value> A </value>
<value>A </value>
</comparisonValues>
</compare>
and I use this expression :-
normalize-space(/compare/comparisonValues/value[3]) =
normalize-space(/compare/compareWith)
the result is true.
If I remove [3] it is an error ('too many items')
if I remove normalize-space and [3] from the LHS, the result is false.
and if I remove spaces from the final comparisonValues/value in the XML, the
result is true
This seems OK (although it would be nice if I *could* use normalize-space on
all of the nodes returned)
What I'm trying to do here to to compare the value in 1 node (compareWith)
with all of the nodes within another node-set (comparisonValues/value) and,
in the real example the node values I'm comparing will also be a >1, that
is, I want to compare each value in node-set 1 to see it it matches any of
the values in node set 2 and continue on until all of the nodes in node-set
1 have been checked (the real example is also comparing across 2 documents
but I wanted to keep the example simple).
The catch is, I can't use a for-each !!! (so can it be done using
apply/call-template ?)
Why not, well I'm implementing this in XSLT schemaTron 1.5 and I don't think
its possible to express what I want using the rule (turns into template
match='') and assertions (turn into 'choose'). The reference schemaTron only
really uses call-template (and apply-templates). I suppose I could re-write
the implementation but I'd rather not.
I like schemaTron, and I especially like the way that I can express the
rules and assertions in an implementation neutral (ish) way. So I don't want
to start extending the schemaTron vocabulary too much and loose that
abstraction (that is, I *could* extend schemaTron (in places where it is
allowed) to provide a pseudo for-each, but I really don't want to go there
for a whole bunch of reasons not least of which that the portability of my
rules would then be severely constrained).
I have also tried (successfully) using xsl:key + the key() function to
create a set of the values in 1 document and then, using key(), check
whether the value of a node in the other document exists in that set. This
worked and I was able to do the compare using normalized-space values, but I
am a bit wary of whether this approach is costly in terms of performance -
can anyone comment ??
Anyway, having seem what I'm trying to acheive and what technologies I
hoping to use, can anyone suggest some ideas that might move me on to the
next stage.
Thanks
Fraser.
--~------------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
To unsubscribe, go to: http://lists.mulberrytech.com/xsl-list/
or e-mail: <mailto:xsl-list-unsubscribe(_at_)lists(_dot_)mulberrytech(_dot_)com>
--~--