What I am having trouble to do is adding a container around a specific
(fixed-order) sequence of those 'p' elements, say,
'p[style="a"]' and 'p[style="b"]', where the first of these
may not always occur.
Michael Kay wrote:
If you can identify a comparison between two adjacent siblings which, if
true, means that they go in different containers, then you can use
group-starting-with. For example, in this case the condition might be that
the element is not immediately preceded by an element with a value for
@style that is alphabetically less than the current element's @style:
group-starting-with="p[not(preceding-sibling::p[1][(_at_)style lt
current()/@style])]"
Thank you for your useful explanations. Actually, I am faced with
grouping in a situation which is a bit more complex. I would like to
expose it on behalf of elements with distinct GIs, dropping the above
example of "p" elements with "style" attributes to make it easier.
Among the child elements of my "root" element, some adjacent children
need to go into some container, and this occurs repeatedly. I can make
out two issues when trying to use xsl:for-each-group in this case:
1) The names of those children that should get together are very
dissimilar, so functions that analyze the name like in the example above
won't help much. Let's say I have "abc" and "xyz" that I want to group:
how can I select the first instance of either of them, in order to add
the container only once?
2) I fail to see how I can repeatedly group some children, when in
between are some children that are not to be grouped. Do I need to apply
recursion when working my way through the children?
Abel proposed using modes, along these lines (modified by me, so errors
are mine):
> <xsl:template match="*[starts-with(name(), 'b')][1]">
> <container>
> <xsl:apply-templates
> select="self::* | following-sibling::*"
> mode="within_container"/>
> </container>
> </xsl:template>
>
> <xsl:template match="*[starts-with(name(), 'b')]"
> mode="within_container">
> <xsl:copy>
> <xsl:apply-templates select="node() | @*"
> mode="#current"/>
> </xsl:copy>
> </xsl:template>
>
> <xsl:template match="*[not(starts-with(name(), 'b'))]">
> <xsl:copy>
> <xsl:apply-templates select="node() | @*" />
> </xsl:copy>
> </xsl:template>
This looks even more promising: I suspect taking out several groups of
children is easier to do this way than with xsl:for-each-group. Is this
true?
But using modes I face the same problem concerning the identification of
the nodes to group (which in the above example all had names starting
with "b", which isn't real) and of selecting the very first instance of
them.
So how could I proceed?
Yves
--~------------------------------------------------------------------
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>
--~--