JSON RTTI Mapper with Delphi

One of the patterns that I have observed a lot during the time I have been playing with JSON streams is that I create my object based on the JSON stream and then I set the properties of that particular object manually so I can work with it rather than with the JSON object itself. 

Let's observe the following example. Imagine that we have the following JSON stream:

	{
	"employees": [
	{
	"name": "John",
	"surname": "Snow",
	"age": 34,
	"address": "my house"
	},
	{
	"name": "John",
	"surname": "Smith",
	"age": 35,
	"address": "my house"
	},
	{
	"name": "John",
	"surname": "Travolta",
	"age": 36,
	"address": "my house"
	}
	]
	}

view raw examplejson.json hosted with ❤ by GitHub

As you can see this JSON represents a list of Employees and each employee has the properties Name, Surname, Age and Address. So if we want to hold this in a TList<T> then we will have to create a class TEmployee with those properties and then manually assign each JSON parameter to each property like the example below:

	//The MIT License (MIT)
	//Copyright (c) 2017 Jordi Corbilla
	//Permission is hereby granted, free of charge, to any person obtaining a copy
	//of this software and associated documentation files (the "Software"), to deal
	//in the Software without restriction, including without limitation the rights
	//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	//copies of the Software, and to permit persons to whom the Software is
	//furnished to do so, subject to the following conditions:
	//The above copyright notice and this permission notice shall be included in
	//all copies or substantial portions of the Software.
	//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	//THE SOFTWARE.
	//Arguments:
	//list: list that will hold the employees.
	//json array: stream that comes from TJSONObject.
	procedure LoadEmployees(list: TList<TEmployee>; json: TJSONArray);
	var
	i : integer;
	temp: TJSONObject;
	employee : TEmployee;
	begin
	for i := 0 to json.Count - 1 do
	begin
	temp := json.Items[i] as TJSONObject;
	employee := TEmployee.Create();
	employee.Name := (temp.Get('name').JsonValue as TJSONString).Value;
	employee.Surname := (temp.Get('surname').JsonValue as TJSONString).Value;
	employee.Age := (temp.Get('age').JsonValue as TJSONNumber).AsInt64;
	employee.Address := (temp.Get('address').JsonValue as TJSONString).Value;
	list.Add(employee);
	end;
	end;

view raw examplejson.pas hosted with ❤ by GitHub

The code is quite straight forward. We need to loop through the JSON array and populate the list.

If you look closely, you will see that basically we are mapping a field in the JSON object that it's called "name" to an object property called "Name". So to make it simpler this would literally be something like this:

	//The MIT License (MIT)
	//Copyright (c) 2017 Jordi Corbilla
	//Permission is hereby granted, free of charge, to any person obtaining a copy
	//of this software and associated documentation files (the "Software"), to deal
	//in the Software without restriction, including without limitation the rights
	//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	//copies of the Software, and to permit persons to whom the Software is
	//furnished to do so, subject to the following conditions:
	//The above copyright notice and this permission notice shall be included in
	//all copies or substantial portions of the Software.
	//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	//THE SOFTWARE.
	//Arguments:
	//list: list that will hold the employees.
	//json array: stream that comes from TJSONObject.
	procedure LoadEmployees(list: TList<TEmployee>; json: TJSONArray);
	var
	i : integer;
	temp: TJSONObject;
	employee : TEmployee;
	jsonMapper : IJSONMapper;
	begin
	for i := 0 to json.Count - 1 do
	begin
	temp := json.Items[i] as TJSONObject;
	employee := TEmployee.Create();
	//Mapping magic
	jsonMapper := TJsonMapper.New();
	jsonMapper.Map(employee, temp);
	//*************
	list.Add(employee);
	end;
	end;

view raw examplemappingjson.pas hosted with ❤ by GitHub

Any mapper out there does one simple job and it's the job of mapping one field from one source to another.

So the question here is how to achieve this in a more clever way? Easy, let's use RTTI to map those properties!

Using the methods TypInfo.SetStrProp and TypInfo.GetPropList you can easily explore and the list of published properties of your class and set the value of them. To make use of the RTTI capabilities, you will have to move those properties to the published section of the class so they are visible through the RTTI.

	// Copyright (c) 2017, Jordi Corbilla
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// - Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	// - Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	// - Neither the name of this library nor the names of its contributors may be
	// used to endorse or promote products derived from this software without
	// specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	// POSSIBILITY OF SUCH DAMAGE.
	procedure TJsonMapper.Map(const refObject: TObject; const refJson: TJSONObject);
	var
	propertyIndex: Integer;
	propertyCount: Integer;
	propertyList: PPropList;
	propertyInfo: PPropInfo;
	value : string;
	valueInt : integer;
	function GetPropertyName(value: string): string;
	var
	lowerText : string;
	restText : string;
	begin
	if length(value) > 0 then
	begin
	lowerText := AnsiLeftStr(value, 1);
	lowerText := AnsiLowerCase(lowerText);
	restText := AnsiRightStr(value, length(value)-1);
	result := lowerText + restText;
	end
	else
	result := value;
	end;
	const
	TypeKinds: TTypeKinds = [tkString, tkInteger];
	begin
	propertyCount := GetPropList(refObject.ClassInfo, TypeKinds, nil);
	GetMem(propertyList, propertyCount * SizeOf(PPropInfo));
	try
	GetPropList(refObject.ClassInfo, TypeKinds, propertyList);
	for propertyIndex := 0 to propertyCount - 1 do
	begin
	propertyInfo := propertyList^[propertyIndex];
	if Assigned(propertyInfo^.SetProc) then
	begin
	value := GetPropertyName(propertyInfo.Name);
	if (refJson.Get(value) <> nil) then
	begin
	case propertyInfo^.PropType^.Kind of
	tkString:
	begin
	value := (refJson.Get(value).JsonValue as TJSONString).Value;
	SetStrProp(refObject, propertyInfo, value);
	end;
	tkInteger:
	begin
	valueInt := (refJson.Get(value).JsonValue as TJSONNumber).AsInt;
	SetOrdProp(refObject, propertyInfo, valueInt);
	end;
	end;
	end;
	end;
	end;
	finally
	FreeMem(propertyList);
	end;
	end;

view raw jsonmapper.pas hosted with ❤ by GitHub

Now you know how to use the RTTI to read the list of published properties and set them to a specific value. These examples have been coded with Delphi 10.2 Tokyo and you can find part of the mapper in one of the projects I'm currently working on: COCAnalytics.

There are many libraries out there that do amazing things with JSON so it's up to you to explore them. At least now you know how to map using the RTTI.

Happy coding!.

Jordi

Delphi MVP.