RXS_ParseJson()

*--------------------------------------------------------------
* This example parses a simple JSON structure stored in the
* field 'JSON' and stores the data contained in fields 'id',
* 'name', and 'price' in the corresponding global fields.
*
* This example differs from Example 1 in that instead of
* returning all values as character data, values will be
* returned using the RPG equivalents of the JSON data types.
*
* Doing this is somewhat more complicated, and may not be useful
* in many JSON parsing situations, so this is not the default
* behavior of RXS_ParseJson().
*--------------------------------------------------------------
H DFTACTGRP(*NO) BNDDIR('RXSBND') ACTGRP(*CALLER)

 /copy QRPGLECPY,RXSCB

D JsonHandler     PR              N
D  pType                         5I 0 Const
D  pPath                              Const Like(RXS_Var64Kv_t)
D  pIndex                       10U 0 Const
D  pData                          *   Const
D  pDataLen                     10U 0 Const

D ParseJsonDS     DS                  LikeDS(RXS_ParseJsonDS_t)
D JSON            S                   Like(RXS_Var64Kv_t)

D id              S             20I 0
D name            S                   Like(RXS_Var1Kv_t)
D price           S              6P 2
D sale            S               N

 /free
   // JSON structure looks like this:
   // {
   //    "item": {
   //      "id": 7,
   //      "name": "headlight fluid",
   //      "price": 12.50,
   //      "sale": true
   //    }
   // }
   JSON = '{ "item": { "id": 7, "name": "headlight fluid",' +
    '"price": 12.50, "sale": true } }';

   RXS_ResetDS( ParseJsonDS : RXS_DS_TYPE_PARSEJSON );
   ParseJsonDS.Handler = %Paddr( JsonHandler );
   // By default this value is RXS_YES, meaning that all data
   //  returned will be converted into character data before
   //  it is available inside JsonHandler. Setting this to RXS_NO
   //  means that JsonHandler will instead be receiving RPG data
   //  types beyond character fields, such as integers, indicators,
   //  and floating point numbers.
   ParseJsonDS.ConvertDataToString = RXS_NO;
   RXS_ParseJson( JSON : ParseJsonDS );

   RXS_JobLog( 'id: %s' : %Char(id) );
   RXS_JobLog( 'name: %s' : name );
   RXS_JobLog( 'price: %s' : %Char(price) );
   if sale;
     RXS_JobLog( 'sale: %s' : 'true' );
   else;
     RXS_JobLog( 'sale: %s' : 'false' );
   endif;

   *INLR = *ON;
 /end-free


P JsonHandler     B                   Export
D                 PI              N
D  pType                         5I 0 Const
D  pPath                              Const Like(RXS_Var64Kv_t)
D  pIndex                       10U 0 Const
D  pData                          *   Const
D  pDataLen                     10U 0 Const
 * To return native JSON types, we have to make use of Basing pointers
 *  and pay careful attention to the pType parameter. Please note that
 *  JSON has two types of numbers - integer and float. Floating point
 *  numbers are not precise, and values returned by RXS_ParseJson
 *  for floating-point numbers may differ slighltly from how they
 *  appear in the JSON. If your JSON data is going to contain
 *  decimal values it is advised to parse JSON using the default
 *  behavior where all parsed data is converted to character data
 *  before being returned to avoid a loss of precision.
D BoolVal         S               N   Based(pData)
D IntVal          S             20I 0 Based(pData)
D FloatVal        S              8F   Based(pData)
 /free

  select;
    when pPath = '/item/id';
      // We know that the 'id' field is an integer, so we can simply
      //  do the following:
      id = IntVal;
      // Note that integers are always going to be returned as 8 byte
      //  integers, e.g. 20I 0. Using 3I 0, 5I 0, or 10I 0 will not work.

    when pPath = '/item/name';
      // 'name' is character data, and should be handled the same way
      name = RXS_STR( pData : pDataLen );

    when pPath = '/item/price';
      // 'price' is stored in the JSON as a decimal. We know from context
      //  that price is denoting a monetary value, which is a situation
      //  where the loss of precision using a floating point number brings
      //  is completely unacceptable. For example, instead of returning
      //  12.50 as we would expect, we might get 12.501 or 12.499. This
      //  would make a large difference to a business! However, as this
      //  is example code, below demonstrates returning floating point
      //  numbers:
      price = FloatVal;

    when pPath = '/item/sale';
      // We know that the 'id' field is a boolean value. It's important to
      //  know that a JSON character data value of 'true' is different from
      //  the JSON boolean data value of true. The two items below are not
      //  equivalent:
      //
      //  {
      //    "item1": 'true',
      //    "item2" : true
      //  }
      //  The RPG equivalent of a boolean data type is an indicator field.
      sale = BoolVal;
  endsl;
  return *On;
 /end-free
P                 E