(Tcl) 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 Tcl Extension Downloads Chilkat Tcl Extension Downloads

load ./chilkat.dll

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

set xml [new_CkXml]

CkXml_put_Tag $xml "tripleNested"

set i 0
set j 0
set k 0

set sbValue [new_CkStringBuilder]

set bAutoCreate 1

while {$i < 3} {
    CkXml_put_I $xml $i
    set j 0
    while {$j < 4} {
        CkXml_put_J $xml $j
        set k 0
        while {$k < 2} {
            CkXml_put_K $xml $k

            set n [expr [expr $i * 100] + [expr [expr $j * 10] + $k]]
            CkStringBuilder_Clear $sbValue
            CkStringBuilder_AppendInt $sbValue $n

            CkXml_UpdateAt $xml "a[i]|b[j]|c[k]" $bAutoCreate [CkStringBuilder_getAsString $sbValue]
            set k [expr $k + 1]
        }
        set j [expr $j + 1]
    }
    set i [expr $i + 1]
}

puts [CkXml_getXml $xml]

# 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.

set i 0
set aCount [CkXml_get_NumChildren $xml]
while {$i < $aCount} {
    CkXml_put_I $xml $i
    set j 0
    set bCount [CkXml_NumChildrenAt $xml "a[i]"]
    while {$j < $bCount} {
        CkXml_put_J $xml $j
        set k 0
        set cCount [CkXml_NumChildrenAt $xml "a[i]|b[j]"]
        while {$k < $cCount} {
            CkXml_put_K $xml $k
            puts "$i, $j, $k: [CkXml_GetChildIntValue $xml {a[i]|b[j]|c[k]}]"
            set k [expr $k + 1]
        }
        set j [expr $j + 1]
    }
    set i [expr $i + 1]
}

# 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
# 

delete_CkXml $xml
delete_CkStringBuilder $sbValue