Java

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.

Chilkat2 Java

import com.chilkatsoft.chilkat2.StringBuilder;
import com.chilkatsoft.chilkat2.Xml;

public class ChilkatExample {

    public static void main(String[] args) {
        // Note: This example requires Chilkat v9.5.0.64 or later.

        Xml xml = new Xml();

        xml.setTag("tripleNested");

        int i = 0;
        int j = 0;
        int k = 0;

        StringBuilder sbValue = new StringBuilder();
        boolean bAutoCreate = true;

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

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

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

                j = j + 1;
            }

            i = i + 1;
        }

        System.out.println(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;
        int aCount = xml.getNumChildren();
        while (i < aCount) {
            xml.setI(i);
            j = 0;
            int bCount = xml.numChildrenAt("a[i]");
            while (j < bCount) {
                xml.setJ(j);
                k = 0;
                int cCount = xml.numChildrenAt("a[i]|b[j]");
                while (k < cCount) {
                    xml.setK(k);
                    System.out.println(i + ", " + j + ", " + k + ": " + xml.getChildIntValue("a[i]|b[j]|c[k]"));
                    k = k + 1;
                }

                j = j + 1;
            }

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