Xbase++

Demonstrate the XML I, J, and K Properties

See more XML Examples

Demonstrates the XML I, J, and K properties. These properties can be used in paths to access the I'th, J'th, or K'th child in a path. Three indexing properties are provided to allow for triple-nested loops using this feature.

Note: This example requires Chilkat v9.5.0.64 or later.

Xbase++

LOCAL oXml
LOCAL i
LOCAL j
LOCAL k
LOCAL oSbValue
LOCAL nBAutoCreate
LOCAL n
LOCAL nACount
LOCAL nBCount
LOCAL nCCount

//  Note: This example requires Chilkat v9.5.0.64 or later.

oXml := CreateObject("Chilkat.Xml")

oXml:Tag := "tripleNested"

i := 0
j := 0
k := 0

oSbValue := CreateObject("Chilkat.StringBuilder")
nBAutoCreate := 1

DO WHILE i < 3
    oXml:I := i
    j := 0
    DO WHILE j < 4
        oXml:J := j
        k := 0
        DO WHILE k < 2
            oXml:K := k

            n := i * 100 + j * 10 + k
            oSbValue:Clear()
            oSbValue:AppendInt(n)

            oXml:UpdateAt("a[i]|b[j]|c[k]", nBAutoCreate, oSbValue:GetAsString())
            k := k + 1
        ENDDO
        j := j + 1
    ENDDO
    i := i + 1
ENDDO

? oXml:GetXml()

//  This is the XML
//  See below for code showing how to parse it..

//  	<?xml version="1.0" encoding="utf-8" ?>
//  	<tripleNested>
//  	    <a>
//  	        <b>
//  	            <c>0</c>
//  	            <c>1</c>
//  	        </b>
//  	        <b>
//  	            <c>10</c>
//  	            <c>11</c>
//  	        </b>
//  	        <b>
//  	            <c>20</c>
//  	            <c>21</c>
//  	        </b>
//  	        <b>
//  	            <c>30</c>
//  	            <c>31</c>
//  	        </b>
//  	    </a>
//  	    <a>
//  	        <b>
//  	            <c>100</c>
//  	            <c>101</c>
//  	        </b>
//  	        <b>
//  	            <c>110</c>
//  	            <c>111</c>
//  	        </b>
//  	        <b>
//  	            <c>120</c>
//  	            <c>121</c>
//  	        </b>
//  	        <b>
//  	            <c>130</c>
//  	            <c>131</c>
//  	        </b>
//  	    </a>
//  	    <a>
//  	        <b>
//  	            <c>200</c>
//  	            <c>201</c>
//  	        </b>
//  	        <b>
//  	            <c>210</c>
//  	            <c>211</c>
//  	        </b>
//  	        <b>
//  	            <c>220</c>
//  	            <c>221</c>
//  	        </b>
//  	        <b>
//  	            <c>230</c>
//  	            <c>231</c>
//  	        </b>
//  	    </a>
//  	</tripleNested>
//  

//  Parse the XML, without needing to know the number of children.
//  That can be discovered with the NumChildrenAt method.

i := 0
nACount := oXml:NumChildren
DO WHILE i < nACount
    oXml:I := i
    j := 0
    nBCount := oXml:NumChildrenAt("a[i]")
    DO WHILE j < nBCount
        oXml:J := j
        k := 0
        nCCount := oXml:NumChildrenAt("a[i]|b[j]")
        DO WHILE k < nCCount
            oXml:K := k
            ? Str(i) + ", " + Str(j) + ", " + Str(k) + ": " + Str(oXml:GetChildIntValue("a[i]|b[j]|c[k]"))
            k := k + 1
        ENDDO
        j := j + 1
    ENDDO
    i := i + 1
ENDDO

//  Output:

//  	0, 0, 0: 0
//  	0, 0, 1: 1
//  	0, 1, 0: 10
//  	0, 1, 1: 11
//  	0, 2, 0: 20
//  	0, 2, 1: 21
//  	0, 3, 0: 30
//  	0, 3, 1: 31
//  	1, 0, 0: 100
//  	1, 0, 1: 101
//  	1, 1, 0: 110
//  	1, 1, 1: 111
//  	1, 2, 0: 120
//  	1, 2, 1: 121
//  	1, 3, 0: 130
//  	1, 3, 1: 131
//  	2, 0, 0: 200
//  	2, 0, 1: 201
//  	2, 1, 0: 210
//  	2, 1, 1: 211
//  	2, 2, 0: 220
//  	2, 2, 1: 221
//  	2, 3, 0: 230
//  	2, 3, 1: 231
//

oXml:destroy()
oSbValue:destroy()