Dart

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.

Dart

import 'package:chilkat/chilkat.dart';

void main() {
  // Note: This example requires Chilkat v9.5.0.64 or later.

  final xml = CkXml();

  xml.tag = 'tripleNested';

  var i = 0;
  var j = 0;
  var k = 0;

  final sbValue = CkStringBuilder();
  final bAutoCreate = true;

  while (i < 3) {
    xml.i = i;
    j = 0;
    while (j < 4) {
      xml.j = j;
      k = 0;
      while (k < 2) {
        xml.k = k;

        final n = i * 100 + j * 10 + k;
        sbValue.clear();
        sbValue.appendInt(n);

        xml.updateAt('a[i]|b[j]|c[k]', bAutoCreate, sbValue.getAsString());
        k++;
      }

      j++;
    }

    i++;
  }

  print(xml.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;
  final aCount = xml.numChildren;
  while (i < aCount) {
    xml.i = i;
    j = 0;
    final bCount = xml.numChildrenAt('a[i]');
    while (j < bCount) {
      xml.j = j;
      k = 0;
      final cCount = xml.numChildrenAt('a[i]|b[j]');
      while (k < cCount) {
        xml.k = k;
        print('$i, $j, $k: ${xml.getChildIntValue('a[i]|b[j]|c[k]')}');
        k++;
      }

      j++;
    }

    i++;
  }

  // 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
  // 
}