Working with XML and JSON Formats in FastScript

Currently, XML and JSON formats have emerged as the primary standards for data storage and information exchange between computer systems. At the request of users, classes for handling XML and JSON have been added to FastScript. In this article, we’ll take a closer look at how to work with these classes, explore their properties and methods, and also create reports from code using scripts.

XML Format

To work with XML in scripts, 2 classes are used. These classes are focused on maximum speed and low memory consumption.

TfrXMLDocument – a class that encapsulates the functionality of an XML document. The following properties and methods are available in it.

TfrXMLNode – a class that encapsulates the properties of an XML document node.

You cannot create an object of this type directly. It is created by calling the Add() method of the element to which you want to add a child element. Let’s take a closer look at the properties and methods of the TfrXMLNode class.

Let’s try to build a report using classes for working with XML. For example, we will display data from the "country.xml" file in the report, but we will not use TClientDataSet, and will use direct access to the XML file. We create a new report, go to the editing mode, put MasterData on the report. And add several Memo on top to display the data. We will also create an OnBeforePrint event for the MasterData object.

The final report script code will look like this:

var doc: TfrXMLDocument;
 item: TfrXMLItem;
 IIndex: Integer;
 
procedure MasterData1OnBeforePrint(Sender: TfrxComponent);
var cur: TfrXMLItem;
 S: string;
begin
 cur := item[IIndex];
 mmNum.Text := cur.Prop['Code'];
 mmName.Text := cur.Prop['Name'];
 mmCapital.Text := cur.Prop['Capital'];
 mmArea.Text := cur.Prop['Area'];
 mmPopulation.Text := cur.Prop['Population'];
 mmContinent.Text := cur.Prop['Continent'];
 Inc(IIndex);
end;
 
begin
 Doc := TfrXMLDocument.Create;
 Doc.LoadFromFile('..\..\Data\country.xml');
 item := Doc.Root[1];
 IIndex := 0;
 MasterData1.RowCount := item.count;
end.

Let’s go ahead and run the report. To make it easier to read, we’ve also added column headers.

JSON Format

Let’s smoothly transition from XML to JSON format. To work with it in FastReport, 2 classes are also used—TfrJSON and TfrJSONArray. In this case, these classes are simply a wrapper around classes from System.JSON in the Delphi platform or similar classes in Lazarus.

TfrJSONObject — a class that encapsulates functions for working with JSON objects.

The properties below allow you to retrieve the values of the JSON object in one form or another. In all these properties, indexing is performed either by the property number in the list of properties or by its name. Note that AsString[‘1’] <> AsString[1]. Also, if you try to get the value of a property using an inappropriate method, errors may occur and incorrect property values may be returned. For example, if a property has the type "Object" or "Array", then when you try to get its value using the AsString property, you will get an empty string. In other cases, AsString will return the string representation of the property’s value.

To return a field of type null, you’ll have to put in a little effort. There isn’t a dedicated method for that. However, you can use the ValueType property, which returns jsNull for a field of type null, or use the AsString property, which returns the string ‘null’.

Let’s take a closer look at the methods for manipulating object properties.

The methods return an integer, which is the index of the added element in the list of all fields.

All methods that add fields to the object do not control the presence of existing fields with the same names. This procedure is the responsibility of the programmer using this class. Such control is necessary to prevent the appearance of multiple fields with the same names in the output JSON. The behavior of the system in this case is undefined—it depends on the parser that will further parse the received JSON. This means that any of the values with the same names may be used!

The TJSONArray class encapsulates methods and properties for working with JSON arrays. In principle, the main properties are the same, but you can only access them by index. Only operations to access any element, get its value, or delete any element are supported. You cannot move elements in the array or change their type. Let’s consider the properties and methods for obtaining the values of elements in this class.

When dealing with arrays, like with objects, you need to carefully approach extracting the values of elements. Depending on the type of the value, you should use the appropriate method to retrieve it.

The methods for manipulating elements of a JSON array are described below.

All of these methods return the position of the element added to the array. You cannot insert an element into the middle of the array; this is a limitation of the base classes in System.JSON.

Specifics of Using Classes to Access JSON

When using objects, it’s important to remember that after using wrapper objects, you must remove all of them from the code.

Note that if you want to get a child object or array, but instead there’s a scalar value or no value at all, the property will return nil, and an exception will occur when accessing that property further. Avoid using methods that are not intended to work with values of specific types stored in an element to retrieve those values.

It’s important to note that property names of objects are case-sensitive, meaning "Item1" and "item1" are considered different names!

You can only set values for object elements if the type of those values matches the type that is defined for the element. If you need to redefine the type of an element, delete it and add a new one with the same name and the type you want. Entering new values for array elements is not possible. You need to delete the JSON array and then recreate it with the values you want.

Let’s use the classes from the description above and write a script that extracts data (without type information) from an XML file and puts it into a JSON object.

procedure XMLToJSON;
var XML: TfrXMLDocument;
 xi, xi1: TfrXMLItem;
 I, J: Integer;
 JO: TfrJSONObject;
 JA, JA1: TfrJSONArray;
 SL: TStringList;
begin
 XML:=TfrXMLDocument.Create;
 XML.LoadFromFile('.\..\..\data\country.xml'); 
 JO:=TfrJSONObject.Create('{}');
 JO.AddArray('data');
 JA:=JO.AsArray['data'];
 xi:=X.Root[1];
 xi1:=xi.Items[0];
 SL:=TStringList.Create;
 xi1.GetParamNames(SL);
 for I:=0 to xi.Count - 1 do begin
 xi1:=xi.Items[I];
 JA1:=JA.AsArray[JA.AddArray];
 for J:=0 to SL.Count-1 do 
 JA1.AddString(xi1.Prop[SL[J]]);
 JA1.Free;
 end;
 JA.Free;
 JO.SaveToFile('.\..\..\data\country.json');
 JO.Free;
 SL.Free; 
end; 

And let’s try to build a report based on the obtained data (first, place the appropriate MasterData and Memo components on the report page):

var J:TfrJSONObject;
 A:TfrJSONArray;
 curr:Integer;
 
procedure MasterData1OnBeforePrint(Sender: TfrxComponent);
var A1:TfrJSONArray;
begin
 A1:=A.AsArray(curr);
 Memo1.Memo.Text:=A1.AsString[0];
 Memo2.Memo.Text:=A1.AsString[1];
 Memo3.Memo.Text:=A1.AsString[2];
 Memo4.Memo.Text:=A1.AsString[3];
 Memo5.Memo.Text:=A1.AsString[4];
 Memo6.Memo.Text:=A1.AsString[5];
 A1.Free;
 curr := curr + 1;
end;
 
begin
 J:=TfrJSONObject.Create('');
 J.LoadFromFile('.\..\..\data\country.json');
 A:=J.AsArray[0];
 MasterData1.RowCount:=A.Count;
 curr:=0;
end.

You can also use these objects in Delphi code—simply include the frXML and frJSON modules in the uses statement.

Conclusion

In this article, we explored the use of classes for working with JSON and XML in FastReport. If you’re a developer working not just with reports but also with Delphi and Lazarus, utilizing these classes will help minimize issues when switching between environments—your experience will be consistent across both IDEs.

For your convenience, we’ve included two examples in this article demonstrating report generation using XML and JSON. You can open and run these examples directly in FastReportDemo, which comes with the FastReport distribution. You might need to configure the reports before running them—just make sure to specify the correct path to the data file "country.xml," which can be found both in the DemoCenter and in the folder with the examples.

Download Examples