xsl-list
[Top] [All Lists]

Re: paths not working...

2003-07-14 17:26:39
How do i put the path to objects who's depth is greater than 1.

Contract Name: myWebservice
ID: 25_610_15006485306
Start Date: Jun-23-2003

Inputs
        textField_1                               <--------------------
        integerField_1                                  |
        decimalField_1                                  |            all these 
non bold fields are links to the
bottom
        dateField_1                                     |        descriptions 
below (respectively)
        binaryField_1                   <-------------------
        trueFalseField_1
        DataContainer_1_1
                textField_1_1
                integerField_1_1
                DataContainer_1_1_1
                        textField_1_1_1
                        integerField_1_1_1

Outputs
        NoValueRestrictions
                required
                optional_NoDefault
                optional_withDefault              <-----------------------
        TextValueRestrictions                                   |
                restrictByValue                                 | all these non 
bold fields
                restrictByRange                                 | are links to 
the bottom(respect.)
restrictByRangeNoMIN                        <---------
                restrictByRangeNoMAX
                restrictByPattern
        NumberValueRestrictions
                restrictByValue
                restrictByRange
                restrictByPattern
        OtherRestrictions
                dateHasAllRestrictions
                booleanHasValueRestrictionOnly
                trueFalseField_1
        BinaryRestrictions
                base64Encoding
                hexEncoding

Short Description:

This is an example of a complex set of inputs.

Long Description:

My way or the highway. My way or the highway. My way or the highway.

Description

textField_1
Description: textField_1_Documentation
Required: No
Default Value: hello
The value must match the following pattern: None

integerField_1
Description: None
Required: Yes
Value Restrictions: None

decimalField_1
Description: None
Required: Yes
Value Restrictions: None

dateField_1
Description: None
Required: Yes
Value Restrictions: None

binaryField_1
Description: None
Required: Yes
Binary Encoding: base64

trueFalseField_1
Description: None
Required: Yes
Value Restrictions: None

textField_1_1
Description: None
Required: Yes
Value Restrictions: None

integerField_1_1
Description: None
Required: Yes
Value Restrictions: None

textField_1_1_1
Description: None
Required: Yes
Value Restrictions: None

integerField_1_1_1
Description: None
Required: Yes
Value Restrictions: None

required
Description: None
Required: Yes
Value Restrictions: None

optional_NoDefault
Description: None
Required: No
Default Value: None
Value Restrictions: None

optional_withDefault
Description: None
Required: No
Default Value: This is the default value
Value Restrictions: None

restrictByValue
Description: None
Required: Yes
Only the following values are allowed: CA; WA; VA;

restrictByRange
Description: None
Required: Yes
Max Number of Characters: 0
Max Number of Characters: 100

restrictByRangeNoMIN
Description: None
Required: Yes
Min Number of Characters: None
Max Number of Characters: 500

restrictByRangeNoMAX
Description: None
Required: Yes
Max Number of Characters: 40
Min Number of Characters: None

restrictByPattern
Description: None
Required: Yes
The value must match the following pattern: ^Pattern

restrictByValue
Description: None
Required: Yes
Only the following values are allowed: 10; 20; 30;

restrictByRange
Description: None
Required: Yes
The value must match the following pattern: None

restrictByPattern
Description: None
Required: Yes
The value must match the following pattern: $1234

dateHasAllRestrictions
Description: None
Required: Yes
Max Value Allowed: Aug-05-2003
Max Value Allowed: Aug-27-2003

booleanHasValueRestrictionOnly
Description: None
Required: Yes
Only the following values are allowed: true;

trueFalseField_1
Description: None
Required: No
Default Value: false
Only the following values are allowed: false;

base64Encoding
Description: None
Required: Yes
Binary Encoding: base64

hexEncoding
Description: None
Required: Yes
Binary Encoding: Hex


This is how the output looks like right now. Instead of putting just names
and linking them up to the top, i would like to put the path to that field.
E.g hexEncoding (look up a few lines) should be replaced with
"Outputs/BinaryRestrictions/hexEncoding". Another example, "textField_1" (at
the very top of Descriptions) should be replaced by "Inputs/textField_1" etc
etc for all fields besides data containers.


Here is the XSL i wrote:

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform";>
  <xsl:template match="HSContract">
    <html>
      <head>
        <title/>
      </head>
      <body>
        <!--<p><a href="#desc"><b>Contract Name: </b><xsl:value-of
select="@contractName"/><br /></a>-->
                <p><b>Contract Name: </b><xsl:value-of 
select="@contractName"/><br />
                <b>ID: </b><xsl:value-of select="@id"/><br />
                <b>Start Date: </b><xsl:value-of select="@startDate"/><br /></p>

                <xsl:apply-templates select="HSDataContainerType"/>
                <xsl:apply-templates select="HSDocumentation"/>
                <!-- processes all the nodes with either of the 6 names -->
                <xsl:apply-templates select="//HSString|//HSDouble
|//HSInteger|//HSBinary|//HSBoolean|//HSDate" mode="target" />
          </body>
    </html>
  </xsl:template>

  <xsl:template match="HSDataContainerType">
    <b><img src="dcopenicon.gif">
    <xsl:value-of select="@name"/></img><br /></b>
    <div style="margin-left: 3em;">
    <xsl:apply-templates select="*"/></div>
  </xsl:template>

  <xsl:template match="*">
        <div><xsl:apply-templates select="HSLinkString" /></div>
        <div><xsl:apply-templates select="HSLinkDouble"/></div>
        <div><xsl:apply-templates select="HSLinkInteger"/></div>
        <div><xsl:apply-templates select="HSLinkDate"/></div>
        <div><xsl:apply-templates select="HSLinkBinary"/></div>
        <div><xsl:apply-templates select="HSLinkBoolean"/></div>
  </xsl:template>

  <xsl:template name="HSLinkString" match="//HSString">
                <img src="texticon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerString" match="HSString" mode="target">
                <img src="texticon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Number of 
Characters: <xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Number of 
Characters: <xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->

                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>

                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>
                        Value Restrictions: None<br />
                </xsl:otherwise>

        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSLinkDouble" match="//HSDouble">
                <img src="decimalicon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerDouble" match="HSDouble" mode="target">
                <img src="decimalicon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Value Allowed: 
<xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Value Allowed: 
<xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                        </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->
                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>
                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>
                        Value Restrictions: None<br />
                </xsl:otherwise>

        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSLinkInteger" match="//HSInteger">
                <img src="integericon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerInteger" match="HSInteger" mode="target">
                <img src="integericon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Value Allowed: 
<xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Value Allowed: 
<xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->
                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>
                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>
                        Value Restrictions: None<br />
                </xsl:otherwise>
        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSLinkBinary" match="//HSBinary">
                <img src="binaryicon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerBinary" match="HSBinary" mode="target">
                <img src="binaryicon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Value Allowed: 
<xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Value Allowed: 
<xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->
                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>
                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>Binary Encoding:
                        <xsl:choose>
                                <xsl:when test="contains(@binaryEncoding, '0')">
                                        base64<br />
                                </xsl:when>
                                <xsl:otherwise>
                                        Hex <br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:otherwise>
        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSLinkDate" match="//HSDate">
                <img src="dateicon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerDate" match="HSDate" mode="target">
                <img src="dateicon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Value Allowed: 
<xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Value Allowed: 
<xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->
                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>
                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>
                        Value Restrictions: None<br />
                </xsl:otherwise>

        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSLinkBoolean" match="//HSBoolean">
                <img src="truefalseicon.gif"><a href="#{generate-id(.)}">
                <xsl:value-of select="@name" /></a><br /></img>
  </xsl:template>

  <xsl:template name="HSLinkerBoolean" match="HSBoolean" mode="target">
                <img src="truefalseicon.gif"><a name="{generate-id(.)}">
                <b><xsl:value-of select="@name" /></b></a></img>
                <br />
                <!-- Handle HSDocumentation in here -->
                <xsl:text>Description: </xsl:text>
                <xsl:choose>
                        <xsl:when test="normalize-space(HSDocumentation) = ''">
                                None<br />
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:value-of select="HSDocumentation" /><br />
                        </xsl:otherwise>
                </xsl:choose>

                Required:
                <xsl:choose>
                        <xsl:when test="contains(@required, 'true')">
                                Yes<br />
                        </xsl:when>
        <!-- if optional, then default value exists or doesn't exist-->
                        <xsl:otherwise>No<br />
                                Default Value:
                        <!--if default tag has some value, display otherwise 
say "No Default
Value"-->
                                <xsl:choose>
                                        <xsl:when 
test="normalize-space(DefaultValue) = ''">
                                                None<br />
                                        </xsl:when>
                                        <xsl:otherwise>
                                                <xsl:value-of 
select="DefaultValue" /><br />
                                        </xsl:otherwise>
                                </xsl:choose>
                        </xsl:otherwise>
                </xsl:choose>

                <xsl:choose>
                        <xsl:when test="contains(@restrictType, '1')">
                        <!-- if restrictType = 1 then display restrictions-->
                                Only the following values are allowed:
                                <xsl:for-each select="restrictedValue">
                                        <xsl:value-of select="text()" />;
                                </xsl:for-each><br />
                        </xsl:when>

                        <xsl:when test="contains(@restrictType, '2')">
                                <xsl:for-each select="restrictedValue">
                                        <xsl:choose>
                                                <xsl:when 
test="normalize-space( text() ) = ''">
                                                        Min Value Allowed: 
<xsl:text>None</xsl:text><br />
                                                </xsl:when>
                                                <xsl:otherwise>
                                                        Max Value Allowed: 
<xsl:value-of select="text()" /><br/>
                                                </xsl:otherwise>
                                        </xsl:choose>
                                </xsl:for-each>
                </xsl:when>

                <xsl:when test="contains(@restrictType, '3')">
                        <!-- if restrictType = 3 then say 'Pattern Allowed:' 
value-->
                        <xsl:text>The value must match the following pattern: 
</xsl:text>
                        <xsl:choose>
                                <!-- <xsl:when test="normalize-space(text()) = 
''"> -->
                                <xsl:when test="restrictedValue[.='']">
                                        <xsl:text>None</xsl:text><br />
                                </xsl:when>
                                <xsl:otherwise>
                                        <xsl:value-of select="restrictedValue" 
/><br />
                                </xsl:otherwise>
                        </xsl:choose>
                </xsl:when>

                <xsl:otherwise>
                        Value Restrictions: None<br />
                </xsl:otherwise>

        </xsl:choose>
        <br />
  </xsl:template>

  <xsl:template name="HSDoc" match="HSDocumentation">
        <!--<p><a name="desc"><b>Short Description:</b><br /><br /></a>-->
        <p><b>Short Description:</b><br /><br />
        <xsl:apply-templates select="shortDescription" /><br /><br />
        <b>Long Description:</b><br /><br />
        <xsl:apply-templates select="descriptionSection" /></p>
  </xsl:template>

  <xsl:template name="shortDescription" match="//shortDescription">
        <xsl:value-of select="text()"/>
  </xsl:template>

  <xsl:template name= "descriptionSection" match="//descriptionSection">
        <xsl:value-of select="text()"/><br /><br /><p><b>Description</b></p>
  </xsl:template>

</xsl:stylesheet>

Here is teh XMLi am working with:



<HSContract contractCategory="2" contractName="myWebservice"
contractType="3" expirationDate="Jun-23-2013" id="25_610_15006485306"
limitMaxConcurrentThreads="false" logEnabled="true" maxConcurrentThreads="2"
revision="25_33" runBatchInParallel="false" startDate="Jun-23-2003">
        <imagePath />
        <HSDataContainerType list="true" name="Inputs" required="true" 
revision=""
systype="true">
                <HSString name="textField_1" restrictType="3" xmlNodeType="1">
                        <DefaultValue>hello</DefaultValue>
                        <HSDocumentation>
                                <shortDescription><![CDATA[
textField_1_Documentation]]></shortDescription>
                        </HSDocumentation>
                        <restrictedValue />
                </HSString>
                <HSInteger name="integerField_1" required="true" 
xmlNodeType="1" />
                <HSDouble name="decimalField_1" required="true" xmlNodeType="1" 
/>
                <HSDate isCacheKey="false" name="dateField_1" required="true"
xmlNodeType="1" />
                <HSBinary binaryEncoding="0" name="binaryField_1" 
required="true"
xmlNodeType="1" />
                <HSBoolean name="trueFalseField_1" required="true" 
xmlNodeType="1">
                        <DefaultValue>false</DefaultValue>
                </HSBoolean>
                <HSDataContainerType name="DataContainer_1_1" required="true" 
revision="">
                        <HSString name="textField_1_1" required="true" 
xmlNodeType="1" />
                        <HSInteger name="integerField_1_1" required="true" 
xmlNodeType="1" />
                        <HSDataContainerType name="DataContainer_1_1_1" 
required="true"
revision="">
                                <HSString name="textField_1_1_1" 
required="true" xmlNodeType="1" />
                                <HSInteger name="integerField_1_1_1" 
required="true" xmlNodeType="1" />
                        </HSDataContainerType>
                </HSDataContainerType>
        </HSDataContainerType>
        <HSDataContainerType list="true" name="Outputs" required="true" 
revision=""
systype="true">
                <HSDataContainerType name="NoValueRestrictions" required="true"
revision="">
                        <HSString name="required" required="true" 
xmlNodeType="1" />
                        <HSString name="optional_NoDefault" xmlNodeType="1">
                                <DefaultValue />
                        </HSString>
                        <HSString name="optional_withDefault" xmlNodeType="1">
                                <DefaultValue>This is the default 
value</DefaultValue>
                        </HSString>
                </HSDataContainerType>
                <HSDataContainerType name="TextValueRestrictions" 
required="true"
revision="">
                        <HSString name="restrictByValue" required="true" 
restrictType="1"
xmlNodeType="1">
                                <restrictedValue>CA</restrictedValue>
                                <restrictedValue>WA</restrictedValue>
                                <restrictedValue>VA</restrictedValue>
                        </HSString>
                        <HSString name="restrictByRange" required="true" 
restrictType="2"
xmlNodeType="1">
                                <restrictedValue>0</restrictedValue>
                                <restrictedValue>100</restrictedValue>
                        </HSString>
                        <HSString name="restrictByRangeNoMIN" required="true" 
restrictType="2"
xmlNodeType="1">
                                <restrictedValue />
                                <restrictedValue>500</restrictedValue>
                        </HSString>
                        <HSString name="restrictByRangeNoMAX" required="true" 
restrictType="2"
xmlNodeType="1">
                                <restrictedValue>40</restrictedValue>
                                <restrictedValue />
                        </HSString>
                        <HSString name="restrictByPattern" required="true" 
restrictType="3"
xmlNodeType="1">
                                <restrictedValue>^Pattern</restrictedValue>
                        </HSString>
                </HSDataContainerType>
                <HSDataContainerType name="NumberValueRestrictions" 
required="true"
revision="">
                        <HSInteger name="restrictByValue" required="true" 
restrictType="1"
xmlNodeType="1">
                                <restrictedValue>10</restrictedValue>
                                <restrictedValue>20</restrictedValue>
                                <restrictedValue>30</restrictedValue>
                        </HSInteger>
                        <HSInteger name="restrictByRange" required="true" 
restrictType="3"
xmlNodeType="1">
                                <restrictedValue />
                        </HSInteger>
                        <HSInteger name="restrictByPattern" required="true" 
restrictType="3"
xmlNodeType="1">
                                <restrictedValue>$1234</restrictedValue>
                        </HSInteger>
                </HSDataContainerType>
                <HSDataContainerType name="OtherRestrictions" required="true" 
revision="">
                        <HSDate isCacheKey="false" 
name="dateHasAllRestrictions" required="true"
restrictType="2" xmlNodeType="1">
                                <restrictedValue>Aug-05-2003</restrictedValue>
                                <restrictedValue>Aug-27-2003</restrictedValue>
                        </HSDate>
                        <HSBoolean name="booleanHasValueRestrictionOnly" 
required="true"
restrictType="1" xmlNodeType="1">
                                <DefaultValue>false</DefaultValue>
                                <restrictedValue>true</restrictedValue>
                        </HSBoolean>
                        <HSBoolean name="trueFalseField_1" restrictType="1" 
xmlNodeType="1">
                                <DefaultValue>false</DefaultValue>
                                <restrictedValue>false</restrictedValue>
                        </HSBoolean>
                </HSDataContainerType>
                <HSDataContainerType name="BinaryRestrictions" required="true"
revision="">
                        <HSBinary binaryEncoding="0" name="base64Encoding" 
required="true"
xmlNodeType="1">
                                <DefaultValue />
                        </HSBinary>
                        <HSBinary binaryEncoding="1" name="hexEncoding" 
required="true"
xmlNodeType="1">
                                <DefaultValue />
                        </HSBinary>
                </HSDataContainerType>
        </HSDataContainerType>
        <HSDataContainerType name="Settings" required="true" revision=""
systype="true">
                <HSString name="HSUserId" systype="true" xmlNodeType="1">
                        <DefaultValue />
                </HSString>
                <HSDataContainerType name="ServiceParameters" 
optionalOrigin="true"
revision="" systype="true" />
                <HSString name="HSLibName" systype="true" xmlNodeType="1">
                        <DefaultValue />
                </HSString>
                <HSBoolean name="batchStopOnError" systype="true" 
xmlNodeType="1">
                        <DefaultValue>true</DefaultValue>
                </HSBoolean>
                <HSDouble name="cost" systype="true" xmlNodeType="1">
                        <DefaultValue>0.0</DefaultValue>
                </HSDouble>
                <HSInteger name="timeout" systype="true" xmlNodeType="1">
                        <DefaultValue>0</DefaultValue>
                </HSInteger>
                <HSString name="locale" systype="true" xmlNodeType="1">
                        <DefaultValue />
                </HSString>
                <HSString name="languageCode" systype="true" xmlNodeType="1">
                        <DefaultValue />
                </HSString>
                <HSDataContainerType name="LibURIs" optionalOrigin="true" 
revision=""
systype="true">
                        <HSString name="location" required="true" 
systype="true" xmlNodeType="1">
                                <DefaultValue />
                        </HSString>
                        <HSBoolean name="enableAlternateLocations" 
required="true" systype="true"
xmlNodeType="1">
                                <DefaultValue>false</DefaultValue>
                        </HSBoolean>
                </HSDataContainerType>
        </HSDataContainerType>
        <HSDocumentation>
                <shortDescription><![CDATA[ This is an example of a complex set 
of inputs.
  ]]></shortDescription>
                <descriptionSection title="myWebserviceDesc"><![CDATA[ My way 
or the
highway. My way or the highway. My way or the highway. My way or the
highway. My way or the highway. My way or the highway. My way or the
highway.
  ]]></descriptionSection>
                <returnCodeDescription code="" />
        </HSDocumentation>
</HSContract>


Any hints/suggestions would be greatly appreciated.

John L.


 XSL-List info and archive:  http://www.mulberrytech.com/xsl/xsl-list



<Prev in Thread] Current Thread [Next in Thread>
  • Re: paths not working..., John Liebermann <=