(Visual FoxPro) Demonstrate the XML I, J, and K Properties

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.

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

LOCAL loXml
LOCAL i
LOCAL j
LOCAL k
LOCAL loSbValue
LOCAL lnBAutoCreate
LOCAL n
LOCAL lnACount
LOCAL lnBCount
LOCAL lnCCount

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

* For versions of Chilkat < 10.0.0, use CreateObject('Chilkat_9_5_0.Xml')
loXml = CreateObject('Chilkat.Xml')

loXml.Tag = "tripleNested"

i = 0
j = 0
k = 0

* For versions of Chilkat < 10.0.0, use CreateObject('Chilkat_9_5_0.StringBuilder')
loSbValue = CreateObject('Chilkat.StringBuilder')
lnBAutoCreate = 1

DO WHILE i < 3
    loXml.I = i
    j = 0
    DO WHILE j < 4
        loXml.J = j
        k = 0
        DO WHILE k < 2
            loXml.K = k

            n = i * 100 + j * 10 + k
            loSbValue.Clear()
            loSbValue.AppendInt(n)

            loXml.UpdateAt("a[i]|b[j]|c[k]",lnBAutoCreate,loSbValue.GetAsString())
            k = k + 1
        ENDDO
        j = j + 1
    ENDDO
    i = i + 1
ENDDO

? loXml.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
lnACount = loXml.NumChildren
DO WHILE i < lnACount
    loXml.I = i
    j = 0
    lnBCount = loXml.NumChildrenAt("a[i]")
    DO WHILE j < lnBCount
        loXml.J = j
        k = 0
        lnCCount = loXml.NumChildrenAt("a[i]|b[j]")
        DO WHILE k < lnCCount
            loXml.K = k
            ? STR(i) + ", " + STR(j) + ", " + STR(k) + ": " + STR(loXml.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
* 

RELEASE loXml
RELEASE loSbValue