Working with JSON

JSON is a format close to GreyCat objects and arrays. It is therefore quite easy to manipulate JSON files.

Read

This section presents how to get a JSON representation from String or File, and how to read the contents. To be noted, in contrast with other types of files, the JSON format only partially allows streaming the content (reading byte by byte). Indeed, JSON Objects and Arrays are blocks that need to be loaded at once.
The JsonReader however allows to read, in sequence, several JSON elements that have been serialized in a file, with or without new lines to separate them. We therefore recommend concatenating several small JSON elements in a single file such as the ndjson format for better performances, rather than one huge element, or several small files.

Read File

The JsonReader will provide the tools to read through the JSON file. The read() function will read the content of the file, element by element. That is, if the first element in your JSON file is an array, it will read and return this array. Likewise, if the first element is an object, it will read the object fully and return it.

fn run() {
    var reader = JsonReader{ path:"data/myData.json" };
    while(reader.available()>0) {
        var parsedArray = reader.read(); // whill be a Map with key-value pairs from json file
    }
}

Files are automatically closed when leaving the function where they were opened. If files are written then read in the same function, setting the Writer or Reader to null closes and flushes the contents to disk.

If your file contains several elements concatenated, you can use a loop to read the contents until available() returns 0 (i.e. no more bytes to read).

GreyCat will load the content of JSON with the correct types (int, float, Object, Array, bool, null, String). The result of the read(): any? function can therefore be casted to the expected type, provided that the data in your file conforms to the specifications consistently.
The cast will otherwise throw an exception that you can deal with.

Parse String

In a quite similar way, it is possible to parse a String, obtained for instance as a result of an API HTTP call.

var reader = Json {};
var parsedResult = reader.parse(contentFromAPI as String);

Read arrays

To read a JSON array, you can simply use a for loop as follows. Here again, the arrayElement will have a type any, but you can safely cast to int if you expect an array of integers, etc.

for(position, arrayElement in parsedArray) {
    //Do some with arrayElement
}

Read objects

Since greycat does not have the notion of non typed objects, all json objects will be converted to a GreyCat Map that behaves very similar to an Object, because of this you have access to all methods provided by the native Map type

• object.get(key) Will return the value
• object.values() Will return all values in an array

var firstName = jsonObject.get("first_name") as String;

Read typed objects

While by default, json objects will be converted to a Map, it is also possible to indicate that you want to read a specific typed object. It is even possible to use inheritance within the types objects to be read. See the following example:

type Feature {
    geometry: Geometry;
}

abstract type Geometry {}

type Point extends Geometry {
    coordinates: Tuple<float, float>;
}

type LineString extends Geometry {
    coordinates: Array<Tuple<float, float>>;
}

type Polygon extends Geometry {
    coordinates: Array<Array<Tuple<float, float>>>;
}



fn main() {
    var reader = JsonReader<Feature> { path: "data.json" };
    while (reader.can_read())
    {
        pprint(reader.read());
    }
}

with example data.json like:

{
  "type": "Feature",
  "geometry": {
    "type": "Point",
    "coordinates": [-73.935242, 40.73061]
  }
}
{
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [
      [-73.9847, 40.7484],
      [-73.9851, 40.7479],
      [-73.9854, 40.7476]
    ]
  }
}
{
  "type": "Feature",
  "geometry": {
    "type": "Polygon",
    "coordinates": [
      [
        [-73.981, 40.752],
        [-73.982, 40.753],
        [-73.983, 40.751],
        [-73.981, 40.752]
      ]
    ]
  }
}

Above, we used jsonline format, but it would also be possible to have an overarching collection type. The drawback would be that the reader has to read the whole (potentially large) object in memory instead of reading object by object.

Write

The JsonWriter will help you serialize GreyCat elements into a JSON formatted file.

You first need to create a JsonWriter and give it the path of the file you want to write into as parameter.
Two versions of the JsonWriter are available. One that will override any existing file; the second that will append to the content of an existing file.

fn run() {
    //Overriding writer
    var writer = JsonWriter { path:"./myFile.json" };

    //Appending writer
    var writer = JsonWriter { path:"./myFile.json", append: true };
}

You can then use write(elem: any?) or writeln(elem: any?) to write a GreyCat element into the file as JSON format. You can write Arrays, Objects, and primitive types.

fn run() {
    [...]
    //Without new line
    writer.write(Foo {name: "John", age: 42});

    //With new line
    writer.writeln([true, false, null]);
}

Writing typed objects

Same as for reading, we can also write using Greycat types.

fn main() {
    var writer = JsonWriter<Feature> {path:"out.json"};

    var feature = Feature{
        geometry: Point{
            coordinates: Tuple<float,float>{x:0.0,y:1.0},
        }
    };

    writer.write(feature);
}