This example program demonstrates the basic structure of an RPG program utilizing RPG-XML Suite to compose a JSON string with repeating elements.

D PutStmfDS       DS                  LikeDS(RXS_PutStmfDS_t)
D CreateDS        DS                  LikeDS(RXS_CreateJsonDS_t)
D RootDS          DS                  LikeDS(RXS_JsonStructureDS_t)
D UsersArrayDS    DS                  LikeDS(RXS_JsonStructureDS_t)
D UserObjectDS    DS                  LikeDS(RXS_JsonStructureDS_t)
D GenericArrayDS  DS                  LikeDS(RXS_JsonStructureDS_t)
D i               S              3U 0 Inz(0)
D Json            S                   Like(RXS_Var64Kv_t)
D dateVal         S             10A


    // Use RXS_ResetDS to ensure that RXS templated data structures are 
    //  properly configured

    // Create root JSON Object
    CreateDS.Prettify = RXS_JSON_TRUE;
    CreateDS.JsonStructureType = RXS_JSON_STRUCTURE_OBJECT;
    RootDS = RXS_CreateJson( CreateDS );

    // Create JSON Array named users & attach to RootDS
    UsersArrayDS = RXS_ComposeJsonArray( 'users' : RootDS );

    // Loop through and add multiple objects to the JSON Array named
    //  "users". Typically you'd want to use a normal RPG database
    //  read loop here instead of a 'for' loop.
    for i = 1 to 3;

      // Create object for a customer, attach to array
      UserObjectDS = RXS_ComposeJsonObject( *OMIT : UsersArrayDS );

      // Add specific string fields & data to the User object we just
      //  created.
      RXS_ComposeJsonString( 'firstName' : 'First Name' : UserObjectDS );
      RXS_ComposeJsonString( 'lastName' : 'Last Name' : UserObjectDS );
      RXS_ComposeJsonString( 'email' : 'Email Address' : UserObjectDS );
      RXS_ComposeJsonString( 'username' : 'Username' : UserObjectDS );
      RXS_ComposeJsonString( 'password' : 'Password' : UserObjectDS );

    // The next few parts of this JSON structure are a series of arrays.
    //  We could define D spec data structure for each if we wanted to,
    //  but it's not required. We still need to ensure we're attaching
    //  them to our root object RootDS though.
    // requiredCourseIds[] - Mindflash says optional
    GenericArrayDS =
      RXS_ComposeJsonArray( 'requiredCourseIds' : RootDS );

    // Again, you'd probably be reading one or more child records out of
    //  a physical file here with an RPG read loop instead of a
    //  'for' loop.
    for i = 1 to 10;

      // Note that the key difference between a JSON Object and a
      //  JSON Array is that a JSON Object can contain one or more
      //  name/value pairs (and the values can be of any type - a child
      //  JSON Object, a JSON Array, or just a plain string/int/etc value)
      // A JSON Array can hold one or more values ONLY. The values a JSON
      //  Array holds must all be of the same type (e.g. all JSON Object,
      //  all plain string/int/etc values, or even another JSON Array),
      //  and cannot have a name associated with them.
      // The easiest way to think about these two is that a JSON Object
      //  is like an RPG data structure, whereas a JSON Array is like
      //  an RPG data structure or normal field but with the Dim keyword
      //  used.
      // Because we can't name the values we're putting in our array, the
      //  second parm for RXS_ComposeJsonNumber() must be *OMIT.
      // We're using RXS_ComposeJsonNumber() to ensure that in the JSON
      //  the values we're passing show up as numeric (e.g. not wrapped
      //  in double quotes)
      // To handle large numbers effectively, RXS_ComposeJsonNumber()
      //  actually accepts a character representation of a number as
      //  opposed to an RPG numeric field type.
      RXS_ComposeJsonNumber( *OMIT : %Char(i) : GenericArrayDS );

    // We're re-using the GenericArrayDS structure for the next few arrays
    //  as they are very simple arrays but the whole process is otherwise
    //  the same as for requiredCourseIds[]
    GenericArrayDS = RXS_ComposeJsonArray( 'courseIds' : RootDS );

    for i = 1 to 10;
      RXS_ComposeJsonNumber( *OMIT : %Char(i * 2) : GenericArrayDS );

    GenericArrayDS = RXS_ComposeJsonArray( 'seriesIds' : RootDS );

    for i = 1 to 10;
      RXS_ComposeJsonNumber( *OMIT : %Char(i * 3) : GenericArrayDS );

    GenericArrayDS = RXS_ComposeJsonArray( 'groupIds' : RootDS );

    for i = 1 to 10;
      RXS_ComposeJsonNumber( *OMIT : %Char(i * 4) : GenericArrayDS );

    // Next, we need to add a date named clientDatestamp to our RootDS.
    //  JSON doesn't have a 'date' data type, so we add this as a
    //  string and do whatever formatting the API we're calling requires.
    // In this case we're using a YYYY-MM-DD date format
    dateVal = %Char( %Date() : *ISO );
    RXS_ComposeJsonString( 'datestamp' : dateVal : RootDS );
    // Next we're going to add JSON boolean and null values
    RXS_ComposeJsonBoolean( 'processed' : RXS_JSON_TRUE : RootDS );
    RXS_ComposeJsonNull( 'referenceId' : RootDS );
    // Now that we've added all of the data fields to our JSON object,
    //  let's generate our JSON string
    Json = RXS_GetJsonString( CreateDS );
    // Always call RXS_JsonDestroy() to free up the memory we used.
    // This must be called AFTER we retrieve our string0
    //  with RXS_JsonGetString(), or there will be nothing to retrieve!
    // It is enough to just call RXS_JsonDestroy() on the CreateDS data
    //  structure - it will free the memory used by all of the child
    //  data structures that were linked to it as well.
    RXS_DestroyJson( CreateDS );
    // Dump JSON to file
    PutStmfDS.Stmf = '/tmp/json_excompose1.txt';
    RXS_PutStmf( Json : PutStmfDS );


    RXS_DestroyJson( CreateDS );
  RXS_DestroyJson( CreateDS );
  *INLR = *ON;