(C) 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 C/C++ Library Downloads
MS Visual C/C++ Linux/CentOS C/C++ Alpine Linux C/C++ MAC OS X C/C++	armhf/aarch64 C/C++ C++ Builder iOS C/C++ Android C/C++	Solaris C/C++ MinGW C/C++

#include <C_CkXml.h>
#include <C_CkStringBuilder.h>

void ChilkatSample(void)
    {
    HCkXml xml;
    int i;
    int j;
    int k;
    HCkStringBuilder sbValue;
    BOOL bAutoCreate;
    int n;
    int aCount;
    int bCount;
    int cCount;

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

    xml = CkXml_Create();

    CkXml_putTag(xml,"tripleNested");

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

    sbValue = CkStringBuilder_Create();
    bAutoCreate = TRUE;

    while (i < 3) {
        CkXml_putI(xml,i);
        j = 0;
        while (j < 4) {
            CkXml_putJ(xml,j);
            k = 0;
            while (k < 2) {
                CkXml_putK(xml,k);

                n = i * 100 + j * 10 + k;
                CkStringBuilder_Clear(sbValue);
                CkStringBuilder_AppendInt(sbValue,n);

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

            j = j + 1;
        }

        i = i + 1;
    }

    printf("%s\n",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.

    i = 0;
    aCount = CkXml_getNumChildren(xml);
    while (i < aCount) {
        CkXml_putI(xml,i);
        j = 0;
        bCount = CkXml_NumChildrenAt(xml,"a[i]");
        while (j < bCount) {
            CkXml_putJ(xml,j);
            k = 0;
            cCount = CkXml_NumChildrenAt(xml,"a[i]|b[j]");
            while (k < cCount) {
                CkXml_putK(xml,k);
                printf("%d, %d, %d: %d\n",i,j,k,CkXml_GetChildIntValue(xml,"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
    // 


    CkXml_Dispose(xml);
    CkStringBuilder_Dispose(sbValue);

    }