Zig

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.

Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

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

    const xml = try chilkat.Xml.init();
    defer xml.deinit();

    xml.setTag("tripleNested");

    var i: i32 = 0;
    var j: i32 = 0;
    var k: i32 = 0;

    const sb_value = try chilkat.StringBuilder.init();
    defer sb_value.deinit();
    const b_auto_create = true;

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

                const n = i * 100 + j * 10 + k;
                sb_value.clear();
                sb_value.appendInt(n) catch {};

                xml.updateAt("a[i]|b[j]|c[k]", b_auto_create, try sb_value.getAsString(alloc)) catch {};
                k = k + 1;
            }

            j = j + 1;
        }

        i = i + 1;
    }

    std.debug.print("{s}\n", .{try xml.getXml(alloc)});

    // 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;
    const a_count = xml.getNumChildren();
    while (i < a_count) {
        xml.setI(i);
        j = 0;
        const b_count = xml.numChildrenAt("a[i]");
        while (j < b_count) {
            xml.setJ(j);
            k = 0;
            const c_count = xml.numChildrenAt("a[i]|b[j]");
            while (k < c_count) {
                xml.setK(k);
                std.debug.print("{d}, {d}, {d}: {d}\n", .{ 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
    //
}