json_core Derived Type

type, public :: json_core

To access the core routines for manipulation of json_value pointer variables. This class allows for thread safe use of the module.

Usage

    program test
     use json_module
     implicit none
     type(json_core) :: json     !<--have to declare this
     type(json_value),pointer :: p
     call json%create_object(p,'')   !create the root
     call json%add(p,'year',1805)    !add some data
     call json%add(p,'value',1.0_RK) !add some data
     call json%print(p,'test.json')  !write it to a file
     call json%destroy(p)            !cleanup
    end program test

Inherited By

type~~json_core~~InheritedByGraph type~json_core json_core type~json_file json_file type~json_core->type~json_file core
Help
add add_by_path annotate_invalid_json check_children_for_duplicate_keys check_for_duplicate_keys check_for_errors clear_exceptions clone convert count create create_array create_double create_integer create_logical create_null create_object create_string destroy destroy_json_core failed get get_child get_current_line_from_file_sequential get_current_line_from_file_stream get_next get_parent get_path get_previous get_tail info initialize insert_after is_child_of json_add_double_by_path json_add_double_vec_by_path json_add_integer_by_path json_add_integer_vec_by_path json_add_logical_by_path json_add_logical_vec_by_path json_add_member_by_path json_add_string_by_path json_add_string_vec_by_path json_create_by_path json_get_alloc_string_vec json_get_alloc_string_vec_by_path json_get_array json_get_array_by_path json_get_by_path json_get_by_path_default json_get_by_path_jsonpath_bracket json_get_by_path_rfc6901 json_get_double json_get_double_by_path json_get_double_vec json_get_double_vec_by_path json_get_integer json_get_integer_by_path json_get_integer_vec json_get_integer_vec_by_path json_get_logical json_get_logical_by_path json_get_logical_vec json_get_logical_vec_by_path json_get_path json_get_string json_get_string_by_path json_get_string_vec json_get_string_vec_by_path json_info json_info_by_path json_matrix_info json_matrix_info_by_path json_parse_file json_parse_string json_print_1 json_print_2 json_string_info json_throw_exception json_update_double json_update_integer json_update_logical json_update_string json_value_add_double json_value_add_double_vec json_value_add_integer json_value_add_integer_vec json_value_add_logical json_value_add_logical_vec json_value_add_member json_value_add_null json_value_add_string json_value_add_string_vec json_value_create_array json_value_create_double json_value_create_integer json_value_create_logical json_value_create_null json_value_create_object json_value_create_string json_value_destroy json_value_get_child json_value_get_child_by_index json_value_get_child_by_name json_value_insert_after json_value_insert_after_child_by_index json_value_print json_value_remove_if_present json_value_rename matrix_info name_equal name_strings_equal parse parse_array parse_for_chars parse_number parse_object parse_string parse_value pop_char print print_error_message print_to_string push_char remove remove_if_present rename replace reverse string_info string_to_dble string_to_int swap throw_exception traverse update validate

Source Code


Components

TypeVisibility AttributesNameInitial
logical(kind=LK), private :: allow_comments =.true.

if true, any comments will be ignored when parsing a file. The comment token is defined by the comment_char character variable.

logical(kind=LK), private :: allow_duplicate_keys =.true.

If False, then after parsing, if any duplicate keys are found, an error is thrown. A call to json_value_validate will also check for duplicates. If True [default] then no special checks are done

logical(kind=LK), private :: case_sensitive_keys =.true.

if name and path comparisons are case sensitive.

integer(kind=IK), private :: char_count =0

character position in the current line

character(kind=CK,len=1), private :: comment_char =CK_'!'

comment token when allow_comments is true. Examples: '!' or '#'.

logical(kind=LK), private :: compact_real =.true.

to use the "compact" form of real numbers for output

logical(kind=LK), private :: compress_vectors =.false.

If true, then arrays of integers, nulls, doubles, & logicals are printed all on one line. [Note: no_whitespace will override this option if necessary]

character(kind=CK,len=:), private, allocatable:: err_message

the error message

logical(kind=LK), private :: escape_solidus =.false.

If True then the solidus "/" is always escaped ("\/") when serializing JSON. If False [default], then it is not escaped. Note that this option does not affect parsing (both escaped and unescaped versions are still valid in all cases).

logical(kind=LK), private :: exception_thrown =.false.

The error flag. Will be set to true when an error is thrown in the class. Many of the methods will check this and return immediately if it is true.

integer(kind=IK), private :: ipos =1

for allocatable strings: next character to read

logical(kind=LK), private :: is_verbose =.false.

if true, all exceptions are immediately printed to console.

integer(kind=IK), private :: line_count =1

lines read counter

logical(kind=LK), private :: no_whitespace =.false.

when printing a JSON string, don't include non-significant spaces or line breaks. If true, the entire structure will be printed on one line.

integer(kind=IK), private :: path_mode =1_IK

How the path strings are interpreted in the get_by_path routines:

character(kind=CK,len=1), private :: path_separator =dot

The path separator to use in the "default" mode for the paths in the various get_by_path routines. Note: if path_mode/=1 then this is ignored.

character(kind=CK,len=pushed_char_size), private :: pushed_char =CK_''

used when parsing lines in file

integer(kind=IK), private :: pushed_index =0

used when parsing lines in file

character(kind=CDK,len=:), private, allocatable:: real_fmt

the format string to use for converting real numbers to strings. It can be set in json_initialize, and used in json_value_print If not set, then default_real_fmt is used instead.

integer(kind=IK), private :: spaces_per_tab =2

number of spaces for indenting

logical(kind=LK), private :: strict_type_checking =.false.

if true, then no type conversions are done in the get routines if the actual variable type is different from the return type (for example, integer to double).

logical(kind=LK), private :: trailing_spaces_significant =.false.

for name and path comparisons, if trailing space is to be considered significant.

logical(kind=LK), private :: unescaped_strings =.true.

If false, then the escaped string is returned from json_get_string and similar routines. If true [default], then the string is returned unescaped.


Constructor

public interface json_core

Structure constructor to initialize a json_core object

  • private function initialize_json_core(verbose, compact_reals, print_signs, real_format, spaces_per_tab, strict_type_checking, trailing_spaces_significant, case_sensitive_keys, no_whitespace, unescape_strings, comment_char, path_mode, path_separator, compress_vectors, allow_duplicate_keys, escape_solidus) result(json_core_object)

    Author
    Jacob Williams
    Date
    4/26/2016

    Function constructor for a json_core. This is just a wrapper for json_initialize.

    Arguments

    Type IntentOptional AttributesName
    logical(kind=LK), intent(in), optional :: verbose

    mainly useful for debugging (default is false)

    logical(kind=LK), intent(in), optional :: compact_reals

    to compact the real number strings for output (default is true)

    logical(kind=LK), intent(in), optional :: print_signs

    always print numeric sign (default is false)

    character(kind=CDK,len=*), intent(in), optional :: real_format

    Real number format: 'E' [default], '*', 'G', 'EN', or 'ES'

    integer(kind=IK), intent(in), optional :: spaces_per_tab

    number of spaces per tab for indenting (default is 2)

    logical(kind=LK), intent(in), optional :: strict_type_checking

    if true, no integer, double, or logical type conversions are done for the get routines (default is false)

    logical(kind=LK), intent(in), optional :: trailing_spaces_significant

    for name and path comparisons, is trailing space to be considered significant. (default is false)

    logical(kind=LK), intent(in), optional :: case_sensitive_keys

    for name and path comparisons, are they case sensitive. (default is true)

    logical(kind=LK), intent(in), optional :: no_whitespace

    if true, printing the JSON structure is done without adding any non-significant spaces or linebreaks (default is false)

    logical(kind=LK), intent(in), optional :: unescape_strings

    If false, then the raw escaped string is returned from json_get_string and similar routines. If true [default], then the string is returned unescaped.

    character(kind=CK,len=1), intent(in), optional :: comment_char

    If present, this character is used to denote comments in the JSON file, which will be ignored if present. Example: ! or #. Setting this to a blank string disables the ignoring of comments. (Default is !).

    integer(kind=IK), intent(in), optional :: path_mode

    How the path strings are interpreted in the get_by_path routines: * 1 – Default way (see json_get_by_path_default) [Default] * 2 – as RFC 6901 "JSON Pointer" paths (see json_get_by_path_rfc6901)

    character(kind=CK,len=1), intent(in), optional :: path_separator

    The path separator to use in the "default" mode for the paths in the various get_by_path routines. Example: . [default] or %. Note: if path_mode/=1 then this is ignored.

    logical(kind=LK), intent(in), optional :: compress_vectors

    If true, then arrays of integers, nulls, doubles, and logicals are printed all on one line. [Note: no_whitespace will override this option if necessary]. (Default is False).

    logical(kind=LK), intent(in), optional :: allow_duplicate_keys
    logical(kind=LK), intent(in), optional :: escape_solidus

    Return Value type(json_core)


Type-Bound Procedures

Add objects to a linked list of json_values.

  • private subroutine json_value_add_member(json, p, member)

    Adds member as a child of p.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    type(json_value), pointer:: member

    the child member to add to p

  • private subroutine json_value_add_null(json, p, name)

    Add a NULL value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name
  • private subroutine json_value_add_integer(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add an integer value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name
    integer(kind=IK), intent(in) :: val
  • private subroutine json_value_add_integer_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add an integer vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    integer(kind=IK), intent(in), dimension(:):: val

    value

  • private subroutine json_value_add_double(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add a real value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    variable name

    real(kind=RK), intent(in) :: val

    real value

  • private subroutine json_value_add_double_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a real vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name
    real(kind=RK), intent(in), dimension(:):: val
  • private subroutine json_value_add_logical(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a logical value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    logical(kind=LK), intent(in) :: val

    value

  • private subroutine json_value_add_logical_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a logical vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the vector

    logical(kind=LK), intent(in), dimension(:):: val

    value

  • private subroutine json_value_add_string(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add a character string child to the json_value variable.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    character(kind=CK,len=*), intent(in) :: val

    value

  • private subroutine json_value_add_string_vec(json, p, name, val, trim_str, adjustl_str)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add an array of character strings to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    variable name

    character(kind=CK,len=*), intent(in), dimension(:):: val

    array of strings

    logical(kind=LK), intent(in), optional :: trim_str

    if TRIM() should be called for each element

    logical(kind=LK), intent(in), optional :: adjustl_str

    if ADJUSTL() should be called for each element

Add variables to a json_value linked list by specifying their paths.

Example

    use, intrinsic :: iso_fortran_env, only: output_unit, wp=>real64
    use json_module
    type(json_core) :: json
    type(json_value) :: p
    call json%create_object(p,'root') ! create the root
    ! now add some variables using the paths:
    call json%add_by_path(p,'inputs.t',    0.0_wp  )
    call json%add_by_path(p,'inputs.x(1)', 100.0_wp)
    call json%add_by_path(p,'inputs.x(2)', 200.0_wp)
    call json%print(p,output_unit)  ! now print to console

Notes

See also

  • private subroutine json_add_member_by_path(json, me, path, p, found, was_created)

    Add a new member (json_value pointer) to a JSON structure, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    type(json_value), intent(in), pointer:: p

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_integer_by_path(json, me, path, value, found, was_created)

    Add an integer value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    integer(kind=IK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_double_by_path(json, me, path, value, found, was_created)

    Add an double value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    real(kind=RK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_logical_by_path(json, me, path, value, found, was_created)

    Add a logical value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    logical(kind=LK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_string_by_path(json, me, path, value, found, was_created)

    Add a string value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    character(kind=CK,len=*), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_integer_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_integer_by_path for adding an integer vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    integer(kind=IK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_double_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_double_by_path for adding a double vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    real(kind=RK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_logical_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_logical_by_path for adding a logical vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    logical(kind=LK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

  • private subroutine json_add_string_vec_by_path(json, me, path, value, found, was_created, ilen)

    Wrapper to json_add_string_by_path for adding a string vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    character(kind=CK,len=*), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

    integer(kind=IK), intent(in), optional dimension(:):: ilen

    the string lengths of each element in value. If not present, the full len(value) string is added for each element.

procedure, private :: annotate_invalid_json

  • private subroutine annotate_invalid_json(json, iunit, str)

    Generate a warning message if there was an error parsing a JSON file or string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: iunit

    file unit number

    character(kind=CK,len=*), intent(in) :: str

    string with JSON data

procedure, public :: check_children_for_duplicate_keys => json_check_children_for_duplicate_keys

Check a json_value object's children for duplicate keys

  • private subroutine json_check_children_for_duplicate_keys(json, p, has_duplicate, name, path)

    Author
    Jacob Williams
    Date
    8/25/2017

    Checks a JSON object for duplicate child names.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    the object to search. If p is not a json_object, then has_duplicate will be false.

    logical(kind=LK), intent(out) :: has_duplicate

    true if there is at least two children have duplicate name values.

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    the duplicate name (unallocated if no duplicate was found)

    character(kind=CK,len=:), intent(out), optional allocatable:: path

    the full path to the duplicate name (unallocated if no duplicate was found)

procedure, public :: check_for_duplicate_keys => json_check_all_for_duplicate_keys

Check entire JSON structure for duplicate keys (recursively)

  • private subroutine json_check_all_for_duplicate_keys(json, p, has_duplicate, name, path)

    Author
    Jacob Williams
    Date
    8/25/2017

    Checks a JSON structure for duplicate child names. This one recursively traverses the entire structure (calling json_check_children_for_duplicate_keys recursively for each element).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    the object to search. If p is not a json_object, then has_duplicate will be false.

    logical(kind=LK), intent(out) :: has_duplicate

    true if there is at least one duplicate name key anywhere in the structure.

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    the duplicate name (unallocated if no duplicates were found)

    character(kind=CK,len=:), intent(out), optional allocatable:: path

    the full path to the duplicate name (unallocated if no duplicate was found)

procedure, public :: check_for_errors => json_check_for_errors

check for error and get error message

  • private subroutine json_check_for_errors(json, status_ok, error_msg)

    Author
    Jacob Williams
    Date
    12/4/2013

    Retrieve error code from the json_core. This should be called after parse to check for errors. If an error is thrown, before using the class again, json_initialize should be called to clean up before it is used again.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    logical(kind=LK), intent(out) :: status_ok

    true if there were no errors

    character(kind=CK,len=:), intent(out), allocatable:: error_msg

    the error message (if there were errors)

procedure, public :: clear_exceptions => json_clear_exceptions

clear exceptions

  • private pure subroutine json_clear_exceptions(json)

    Author
    Jacob Williams
    Date
    12/4/2013

    Clear exceptions in the json_core.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json

procedure, public :: clone => json_clone

clone a JSON structure (deep copy)

  • private subroutine json_clone(json, from, to)

    Author
    Jacob Williams
    Date
    10/31/2015

    Create a deep copy of a json_value linked-list structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: from

    this is the structure to clone

    type(json_value), pointer:: to

    the clone is put here (it must not already be associated)

procedure, private :: convert

  • private subroutine convert(json, p, var_type)

    Convert an existing JSON variable p to a different variable type. The existing variable (and its children) is destroyed. It is replaced in the structure by a new variable of type var_type (which can be a json_null, json_object or json_array).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    the variable to convert

    integer(kind=IK), intent(in) :: var_type

    the variable type to convert p to

procedure, public :: count => json_count

count the number of children

  • private function json_count(json, p) result(count)

    Count the number of children.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    Return Value integer(kind=IK)

    number of children

generic, public :: create => json_create_by_path

Create a json_value linked list using the path to the variables. Optionally return a pointer to the variable.

(This will create a null variable)

See also

  • private subroutine json_create_by_path(json, me, path, p, found, was_created)

    Returns the json_value pointer given the path string, If necessary, by creating the variables as needed.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    type(json_value), intent(out), optional pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if there were no errors (variable found or created)

    logical(kind=LK), intent(out), optional :: was_created

    true if it was actually created (as opposed to already being there)

generic, public :: create_array => json_value_create_array

Allocate a json_value pointer and make it an array variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_array(p,'arrayname')
  • private subroutine json_value_create_array(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an array variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

generic, public :: create_double => json_value_create_double

Allocate a json_value pointer and make it a double variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_double(p,'value',1.0_RK)
  • private subroutine json_value_create_double(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a real(RK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    real(kind=RK), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

generic, public :: create_integer => json_value_create_integer

Allocate a json_value pointer and make it an integer variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_integer(p,42,'value')
  • private subroutine json_value_create_integer(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an integer(IK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

generic, public :: create_logical => json_value_create_logical

Allocate a json_value pointer and make it a logical variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_logical(p,'value',.true.)
  • private subroutine json_value_create_logical(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a logical(LK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    logical(kind=LK), intent(in) :: val

    variable value

    character(kind=CK,len=*), intent(in) :: name

    variable name

generic, public :: create_null => json_value_create_null

Allocate a json_value pointer and make it a null variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_null(p,'value')
  • private subroutine json_value_create_null(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a null variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

generic, public :: create_object => json_value_create_object

Allocate a json_value pointer and make it an object variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_object(p,'objectname')

  • private subroutine json_value_create_object(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an object variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

generic, public :: create_string => json_value_create_string

Allocate a json_value pointer and make it a string variable. The pointer should not already be allocated.

Example

    type(json_core) :: json
    type(json_value),pointer :: p
    call json%create_string(p,'value','foobar')
  • private subroutine json_value_create_string(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a string variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

generic, public :: destroy => json_value_destroy, destroy_json_core

Destructor routine for a json_value pointer. This must be called explicitly if it is no longer needed, before it goes out of scope. Otherwise, a memory leak will result.

Example

Destroy the json_value pointer before the variable goes out of scope:

     subroutine example1()
     type(json_core) :: json
     type(json_value),pointer :: p
     call json%create_object(p,'')
     call json%add(p,'year',2015)
     call json%print(p)
     call json%destroy(p)
     end subroutine example1

Note: it should NOT be called for a json_value pointer than has already been added to another json_value structure, since doing so may render the other structure invalid. Consider the following example:

     subroutine example2(p)
     type(json_core) :: json
     type(json_value),pointer,intent(out) :: p
     type(json_value),pointer :: q
     call json%create_object(p,'')
     call json%add(p,'year',2015)
     call json%create_object(q,'q')
     call json%add(q,'val',1)
     call json%add(p, q)  !add q to p structure
     ! do NOT call json%destroy(q) here, because q is
     ! now part of the output structure p.  p should be destroyed
     ! somewhere upstream by the caller of this routine.
     nullify(q) !OK, but not strictly necessary
     end subroutine example2
  • private recursive subroutine json_value_destroy(json, p, destroy_next)

    Author
    Jacob Williams
    Date
    1/22/2014

    Destroy a json_value linked-list structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    variable to destroy

    logical(kind=LK), intent(in), optional :: destroy_next

    if true, then p%next is also destroyed (default is true)

  • private subroutine destroy_json_core(me)

    Author
    Jacob Williams
    Date
    4/17/2016

    Destructor for the json_core type.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(out) :: me

procedure, private :: destroy_json_core

  • private subroutine destroy_json_core(me)

    Author
    Jacob Williams
    Date
    4/17/2016

    Destructor for the json_core type.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(out) :: me

procedure, public :: failed => json_failed

check for error

  • private pure function json_failed(json) result(failed)

    Author
    Jacob Williams
    Date
    12/5/2013

    Logical function to indicate if an exception has been thrown in a json_core.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(in) :: json

    Return Value logical(kind=LK)

    will be true if an exception has been thrown.

Get data from a json_value linked list.

  • private subroutine json_get_by_path(json, me, path, p, found)

    Returns the json_value pointer given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    type(json_value), intent(out), pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if it was found

  • private subroutine json_get_integer(json, me, value)

    Get an integer value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    integer(kind=IK), intent(out) :: value
  • private subroutine json_get_integer_by_path(json, me, path, value, found)

    Get an integer value from a json_value, given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_integer_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get an integer vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    integer(kind=IK), intent(out), dimension(:), allocatable:: vec
  • private subroutine json_get_integer_vec_by_path(json, me, path, vec, found)

    Get an integer vector from a json_value, given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_double(json, me, value)

    Get a double value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    real(kind=RK), intent(out) :: value
  • private subroutine json_get_double_by_path(json, me, path, value, found)

    Get a double value from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_double_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a double vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    real(kind=RK), intent(out), dimension(:), allocatable:: vec
  • private subroutine json_get_double_vec_by_path(json, me, path, vec, found)

    Get a double vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_logical(json, me, value)

    Get a logical value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    logical(kind=LK), intent(out) :: value
  • private subroutine json_get_logical_by_path(json, me, path, value, found)

    Get a logical value from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_logical_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a logical vector from json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    logical(kind=LK), intent(out), dimension(:), allocatable:: vec
  • private subroutine json_get_logical_vec_by_path(json, me, path, vec, found)

    Get a logical vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_string(json, me, value)

    Get a character string from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=:), intent(out), allocatable:: value
  • private subroutine json_get_string_by_path(json, me, path, value, found)

    Get a character string from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=:), intent(out), allocatable:: value
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_string_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a string vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(out), dimension(:), allocatable:: vec
  • private subroutine json_get_string_vec_by_path(json, me, path, vec, found)

    Get a string vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=*), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_alloc_string_vec(json, me, vec, ilen)

    Author
    Jacob Williams
    Date
    12/16/2016

    Get a string vector from a json_value. This is an alternate version of json_get_string_vec. This one returns an allocatable length character (where the string length is the maximum length of any element in the array). It also returns an integer array of the actual sizes of the strings in the JSON structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=:), intent(out), dimension(:), allocatable:: vec
    integer(kind=IK), intent(out), dimension(:), allocatable:: ilen

    the actual length of each character string in the array

  • private subroutine json_get_alloc_string_vec_by_path(json, me, path, vec, ilen, found)

    Alternate version of json_get_alloc_string_vec where input is the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=:), intent(out), dimension(:), allocatable:: vec
    integer(kind=IK), intent(out), dimension(:), allocatable:: ilen

    the actual length of each character string in the array

    logical(kind=LK), intent(out), optional :: found
  • private subroutine json_get_array(json, me, array_callback)

    This routine calls the user-supplied json_array_callback_func subroutine for each element in the array.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    procedure(json_array_callback_func) :: array_callback
  • private subroutine json_get_array_by_path(json, me, path, array_callback, found)

    This routine calls the user-supplied array_callback subroutine for each element in the array (specified by the path).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    procedure(json_array_callback_func) :: array_callback
    logical(kind=LK), intent(out), optional :: found

Return a child of a json_value structure.

  • private subroutine json_value_get_child_by_index(json, p, idx, child, found)

    Returns a child in the object or array given the index.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    object or array JSON data

    integer(kind=IK), intent(in) :: idx

    index of the child (this is a 1-based Fortran style array index).

    type(json_value), pointer:: child

    pointer to the child

    logical(kind=LK), intent(out), optional :: found

    true if the value was found (if not present, an exception will be thrown if it was not found. If present and not found, no exception will be thrown).

  • private subroutine json_value_get_child(json, p, child)

    Returns pointer to the first child of the object (or null() if it is not associated).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    object or array JSON data

    type(json_value), pointer:: child

    pointer to the child

  • private subroutine json_value_get_child_by_name(json, p, name, child, found)

    Returns a child in the object or array given the name string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    the name of a child of p

    type(json_value), pointer:: child

    pointer to the child

    logical(kind=LK), intent(out), optional :: found

    true if the value was found (if not present, an exception will be thrown if it was not found. If present and not found, no exception will be thrown).

procedure, private :: get_current_line_from_file_sequential

  • private subroutine get_current_line_from_file_sequential(json, iunit, line)

    Author
    Jacob Williams

    Rewind the file to the beginning of the current line, and return this line. The file is assumed to be opened. This is the SEQUENTIAL version (see also get_current_line_from_file_stream).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: iunit

    file unit number

    character(kind=CK,len=:), intent(out), allocatable:: line

    current line

procedure, private :: get_current_line_from_file_stream

  • private subroutine get_current_line_from_file_stream(json, iunit, line)

    Author
    Jacob Williams

    Rewind the file to the beginning of the current line, and return this line. The file is assumed to be opened. This is the STREAM version (see also get_current_line_from_file_sequential).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: iunit

    file unit number

    character(kind=CK,len=:), intent(out), allocatable:: line

    current line

procedure, public :: get_next => json_get_next

get pointer to json_value next

  • private subroutine json_get_next(json, p, next)

    Author
    Jacob Williams
    Date
    10/31/2015

    Returns a pointer to the next of a json_value. If there is no next, then a null() pointer is returned.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    JSON object

    type(json_value), intent(out), pointer:: next

    pointer to next

procedure, public :: get_parent => json_get_parent

get pointer to json_value parent

  • private subroutine json_get_parent(json, p, parent)

    Author
    Jacob Williams
    Date
    10/16/2015

    Returns a pointer to the parent of a json_value. If there is no parent, then a null() pointer is returned.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    JSON object

    type(json_value), intent(out), pointer:: parent

    pointer to parent

generic, public :: get_path => json_get_path

get the path to a JSON variable in a structure:

  • private subroutine json_get_path(json, p, path, found, use_alt_array_tokens, path_sep)

    Returns the path to a JSON object that is part of a linked list structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    a JSON linked list object

    character(kind=CK,len=:), intent(out), allocatable:: path

    path to the variable

    logical(kind=LK), intent(out), optional :: found

    true if there were no problems

    logical(kind=LK), intent(in), optional :: use_alt_array_tokens

    if true, then '()' are used for array elements otherwise, '[]' are used [default] (only used if path_mode=1)

    character(kind=CK,len=1), intent(in), optional :: path_sep

    character to use for path separator (otherwise use json%path_separator) (only used if path_mode=1)

procedure, public :: get_previous => json_get_previous

get pointer to json_value previous

  • private subroutine json_get_previous(json, p, previous)

    Author
    Jacob Williams
    Date
    10/31/2015

    Returns a pointer to the previous of a json_value. If there is no previous, then a null() pointer is returned.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    JSON object

    type(json_value), intent(out), pointer:: previous

    pointer to previous

procedure, public :: get_tail => json_get_tail

get pointer to json_value tail

  • private subroutine json_get_tail(json, p, tail)

    Author
    Jacob Williams
    Date
    10/31/2015

    Returns a pointer to the tail of a json_value (the last child of an array of object). If there is no tail, then a null() pointer is returned.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    JSON object

    type(json_value), intent(out), pointer:: tail

    pointer to tail

generic, public :: info => json_info, json_info_by_path

get info about a json_value

  • private subroutine json_info(json, p, var_type, n_children, name)

    Author
    Jacob Williams
    Date
    2/13/2014

    Returns information about a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(out), optional :: var_type

    variable type

    integer(kind=IK), intent(out), optional :: n_children

    number of children

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

  • private subroutine json_info_by_path(json, p, path, found, var_type, n_children, name)

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    integer(kind=IK), intent(out), optional :: var_type

    variable type

    integer(kind=IK), intent(out), optional :: n_children

    number of children

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, public :: initialize => json_initialize

to initialize some parsing parameters

  • private subroutine json_initialize(me, verbose, compact_reals, print_signs, real_format, spaces_per_tab, strict_type_checking, trailing_spaces_significant, case_sensitive_keys, no_whitespace, unescape_strings, comment_char, path_mode, path_separator, compress_vectors, allow_duplicate_keys, escape_solidus)

    Author
    Jacob Williams
    Date
    12/4/2013

    Initialize the json_core instance.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: me
    logical(kind=LK), intent(in), optional :: verbose

    mainly useful for debugging (default is false)

    logical(kind=LK), intent(in), optional :: compact_reals

    to compact the real number strings for output (default is true)

    logical(kind=LK), intent(in), optional :: print_signs

    always print numeric sign (default is false)

    character(kind=CDK,len=*), intent(in), optional :: real_format

    Real number format: 'E' [default], '*', 'G', 'EN', or 'ES'

    integer(kind=IK), intent(in), optional :: spaces_per_tab

    number of spaces per tab for indenting (default is 2)

    logical(kind=LK), intent(in), optional :: strict_type_checking

    if true, no integer, double, or logical type conversions are done for the get routines (default is false)

    logical(kind=LK), intent(in), optional :: trailing_spaces_significant

    for name and path comparisons, is trailing space to be considered significant. (default is false)

    logical(kind=LK), intent(in), optional :: case_sensitive_keys

    for name and path comparisons, are they case sensitive. (default is true)

    logical(kind=LK), intent(in), optional :: no_whitespace

    if true, printing the JSON structure is done without adding any non-significant spaces or linebreaks (default is false)

    logical(kind=LK), intent(in), optional :: unescape_strings

    If false, then the raw escaped string is returned from json_get_string and similar routines. If true [default], then the string is returned unescaped.

    character(kind=CK,len=1), intent(in), optional :: comment_char

    If present, this character is used to denote comments in the JSON file, which will be ignored if present. Example: ! or #. Setting this to a blank string disables the ignoring of comments. (Default is !).

    integer(kind=IK), intent(in), optional :: path_mode

    How the path strings are interpreted in the get_by_path routines: * 1 – Default way (see json_get_by_path_default) [Default] * 2 – as RFC 6901 "JSON Pointer" paths (see json_get_by_path_rfc6901)

    character(kind=CK,len=1), intent(in), optional :: path_separator

    The path separator to use in the "default" mode for the paths in the various get_by_path routines. Example: . [default] or %. Note: if path_mode/=1 then this is ignored.

    logical(kind=LK), intent(in), optional :: compress_vectors

    If true, then arrays of integers, nulls, doubles, and logicals are printed all on one line. [Note: no_whitespace will override this option if necessary]. (Default is False).

    logical(kind=LK), intent(in), optional :: allow_duplicate_keys
    logical(kind=LK), intent(in), optional :: escape_solidus

insert a new element after an existing one, updating the JSON structure accordingly

  • private subroutine json_value_insert_after(json, p, element)

    Inserts element after p, and updates the JSON structure accordingly.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a value from a JSON structure (presumably, this is a child of an object or array).

    type(json_value), pointer:: element

    the element to insert after p

  • private subroutine json_value_insert_after_child_by_index(json, p, idx, element)

    Inserts element after the idx-th child of p, and updates the JSON structure accordingly. This is just a wrapper for json_value_insert_after.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON object or array.

    integer(kind=IK), intent(in) :: idx

    the index of the child of p to insert the new element after (this is a 1-based Fortran style array index)

    type(json_value), pointer:: element

    the element to insert

procedure, public :: is_child_of => json_value_is_child_of

Check if a json_value is a descendant of another.

  • private function json_value_is_child_of(json, p1, p2) result(is_child_of)

    Author
    Jacob Williams
    Date
    4/28/2016

    Returns True if p2 is a descendant of p1 (i.e, a child, or a child of child, etc.)

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p1
    type(json_value), pointer:: p2

    Return Value logical(kind=LK)

procedure, private :: json_add_double_by_path

  • private subroutine json_add_double_by_path(json, me, path, value, found, was_created)

    Add an double value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    real(kind=RK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_double_vec_by_path

  • private subroutine json_add_double_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_double_by_path for adding a double vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    real(kind=RK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_integer_by_path

  • private subroutine json_add_integer_by_path(json, me, path, value, found, was_created)

    Add an integer value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    integer(kind=IK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_integer_vec_by_path

  • private subroutine json_add_integer_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_integer_by_path for adding an integer vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    integer(kind=IK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_logical_by_path

  • private subroutine json_add_logical_by_path(json, me, path, value, found, was_created)

    Add a logical value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    logical(kind=LK), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_logical_vec_by_path

  • private subroutine json_add_logical_vec_by_path(json, me, path, value, found, was_created)

    Wrapper to json_add_logical_by_path for adding a logical vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    logical(kind=LK), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_member_by_path

  • private subroutine json_add_member_by_path(json, me, path, p, found, was_created)

    Add a new member (json_value pointer) to a JSON structure, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    type(json_value), intent(in), pointer:: p

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_string_by_path

  • private subroutine json_add_string_by_path(json, me, path, value, found, was_created)

    Add a string value to a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    character(kind=CK,len=*), intent(in) :: value

    the value to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

procedure, private :: json_add_string_vec_by_path

  • private subroutine json_add_string_vec_by_path(json, me, path, value, found, was_created, ilen)

    Wrapper to json_add_string_by_path for adding a string vector by path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me

    the JSON structure

    character(kind=CK,len=*), intent(in) :: path

    the path to the variable

    character(kind=CK,len=*), intent(in), dimension(:):: value

    the vector to add

    logical(kind=LK), intent(out), optional :: found

    if the variable was found

    logical(kind=LK), intent(out), optional :: was_created

    if the variable had to be created

    integer(kind=IK), intent(in), optional dimension(:):: ilen

    the string lengths of each element in value. If not present, the full len(value) string is added for each element.

procedure, private :: json_create_by_path

  • private subroutine json_create_by_path(json, me, path, p, found, was_created)

    Returns the json_value pointer given the path string, If necessary, by creating the variables as needed.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    type(json_value), intent(out), optional pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if there were no errors (variable found or created)

    logical(kind=LK), intent(out), optional :: was_created

    true if it was actually created (as opposed to already being there)

procedure, private :: json_get_alloc_string_vec

  • private subroutine json_get_alloc_string_vec(json, me, vec, ilen)

    Author
    Jacob Williams
    Date
    12/16/2016

    Get a string vector from a json_value. This is an alternate version of json_get_string_vec. This one returns an allocatable length character (where the string length is the maximum length of any element in the array). It also returns an integer array of the actual sizes of the strings in the JSON structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=:), intent(out), dimension(:), allocatable:: vec
    integer(kind=IK), intent(out), dimension(:), allocatable:: ilen

    the actual length of each character string in the array

procedure, private :: json_get_alloc_string_vec_by_path

  • private subroutine json_get_alloc_string_vec_by_path(json, me, path, vec, ilen, found)

    Alternate version of json_get_alloc_string_vec where input is the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=:), intent(out), dimension(:), allocatable:: vec
    integer(kind=IK), intent(out), dimension(:), allocatable:: ilen

    the actual length of each character string in the array

    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_array

procedure, private :: json_get_array_by_path

  • private subroutine json_get_array_by_path(json, me, path, array_callback, found)

    This routine calls the user-supplied array_callback subroutine for each element in the array (specified by the path).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    procedure(json_array_callback_func) :: array_callback
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_by_path

  • private subroutine json_get_by_path(json, me, path, p, found)

    Returns the json_value pointer given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    type(json_value), intent(out), pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if it was found

procedure, private :: json_get_by_path_default

  • private subroutine json_get_by_path_default(json, me, path, p, found, create_it, was_created)

    Returns the json_value pointer given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    type(json_value), intent(out), pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    logical(kind=LK), intent(in), optional :: create_it

    if a variable is not present in the path, then it is created. the leaf node is returned as a null json type and can be changed by the caller.

    logical(kind=LK), intent(out), optional :: was_created

    if create_it is true, this will be true if the variable was actually created. Otherwise it will be false.

procedure, private :: json_get_by_path_jsonpath_bracket

  • private subroutine json_get_by_path_jsonpath_bracket(json, me, path, p, found, create_it, was_created)

    Author
    Jacob Williams
    Date
    9/2/2017

    Returns the json_value pointer given the path string, using the "JSON Pointer" path specification defined by the JSONPath "bracket-notation".

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable (using JSONPath "bracket-notation")

    type(json_value), intent(out), pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    logical(kind=LK), intent(in), optional :: create_it

    if a variable is not present in the path, then it is created. the leaf node is returned as a null json type and can be changed by the caller.

    logical(kind=LK), intent(out), optional :: was_created

    if create_it is true, this will be true if the variable was actually created. Otherwise it will be false.

procedure, private :: json_get_by_path_rfc6901

  • private subroutine json_get_by_path_rfc6901(json, me, path, p, found)

    Author
    Jacob Williams
    Date
    2/4/2017

    Returns the json_value pointer given the path string, using the "JSON Pointer" path specification defined by RFC 6901.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable (an RFC 6901 "JSON Pointer")

    type(json_value), intent(out), pointer:: p

    pointer to the variable specify by path

    logical(kind=LK), intent(out), optional :: found

    true if it was found

procedure, private :: json_get_double

  • private subroutine json_get_double(json, me, value)

    Get a double value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    real(kind=RK), intent(out) :: value

procedure, private :: json_get_double_by_path

  • private subroutine json_get_double_by_path(json, me, path, value, found)

    Get a double value from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_double_vec

  • private subroutine json_get_double_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a double vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    real(kind=RK), intent(out), dimension(:), allocatable:: vec

procedure, private :: json_get_double_vec_by_path

  • private subroutine json_get_double_vec_by_path(json, me, path, vec, found)

    Get a double vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_integer

  • private subroutine json_get_integer(json, me, value)

    Get an integer value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    integer(kind=IK), intent(out) :: value

procedure, private :: json_get_integer_by_path

  • private subroutine json_get_integer_by_path(json, me, path, value, found)

    Get an integer value from a json_value, given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_integer_vec

  • private subroutine json_get_integer_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get an integer vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: me
    integer(kind=IK), intent(out), dimension(:), allocatable:: vec

procedure, private :: json_get_integer_vec_by_path

  • private subroutine json_get_integer_vec_by_path(json, me, path, vec, found)

    Get an integer vector from a json_value, given the path string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_logical

  • private subroutine json_get_logical(json, me, value)

    Get a logical value from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    logical(kind=LK), intent(out) :: value

procedure, private :: json_get_logical_by_path

  • private subroutine json_get_logical_by_path(json, me, path, value, found)

    Get a logical value from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(out) :: value
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_logical_vec

  • private subroutine json_get_logical_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a logical vector from json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    logical(kind=LK), intent(out), dimension(:), allocatable:: vec

procedure, private :: json_get_logical_vec_by_path

  • private subroutine json_get_logical_vec_by_path(json, me, path, vec, found)

    Get a logical vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_path

  • private subroutine json_get_path(json, p, path, found, use_alt_array_tokens, path_sep)

    Returns the path to a JSON object that is part of a linked list structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    a JSON linked list object

    character(kind=CK,len=:), intent(out), allocatable:: path

    path to the variable

    logical(kind=LK), intent(out), optional :: found

    true if there were no problems

    logical(kind=LK), intent(in), optional :: use_alt_array_tokens

    if true, then '()' are used for array elements otherwise, '[]' are used [default] (only used if path_mode=1)

    character(kind=CK,len=1), intent(in), optional :: path_sep

    character to use for path separator (otherwise use json%path_separator) (only used if path_mode=1)

procedure, private :: json_get_string

  • private subroutine json_get_string(json, me, value)

    Get a character string from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=:), intent(out), allocatable:: value

procedure, private :: json_get_string_by_path

  • private subroutine json_get_string_by_path(json, me, path, value, found)

    Get a character string from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=:), intent(out), allocatable:: value
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_get_string_vec

  • private subroutine json_get_string_vec(json, me, vec)

    Author
    Jacob Williams
    Date
    5/14/2014

    Get a string vector from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(out), dimension(:), allocatable:: vec

procedure, private :: json_get_string_vec_by_path

  • private subroutine json_get_string_vec_by_path(json, me, path, vec, found)

    Get a string vector from a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: me
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=*), intent(out), dimension(:), allocatable:: vec
    logical(kind=LK), intent(out), optional :: found

procedure, private :: json_info

  • private subroutine json_info(json, p, var_type, n_children, name)

    Author
    Jacob Williams
    Date
    2/13/2014

    Returns information about a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(out), optional :: var_type

    variable type

    integer(kind=IK), intent(out), optional :: n_children

    number of children

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, private :: json_info_by_path

  • private subroutine json_info_by_path(json, p, path, found, var_type, n_children, name)

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    integer(kind=IK), intent(out), optional :: var_type

    variable type

    integer(kind=IK), intent(out), optional :: n_children

    number of children

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, private :: json_matrix_info

  • private subroutine json_matrix_info(json, p, is_matrix, var_type, n_sets, set_size, name)

    Author
    Jacob Williams
    Date
    10/16/2015

    Alternate version of json_info that returns matrix information about a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON linked list

    logical(kind=LK), intent(out) :: is_matrix

    true if it is a valid matrix

    integer(kind=IK), intent(out), optional :: var_type

    variable type of data in the matrix (if all elements have the same type)

    integer(kind=IK), intent(out), optional :: n_sets

    number of data sets (i.e., matrix rows if using row-major order)

    integer(kind=IK), intent(out), optional :: set_size

    size of each data set (i.e., matrix cols if using row-major order)

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, private :: json_matrix_info_by_path

  • private subroutine json_matrix_info_by_path(json, p, path, is_matrix, found, var_type, n_sets, set_size, name)

    Returns matrix information about a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    logical(kind=LK), intent(out) :: is_matrix

    true if it is a valid matrix

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    integer(kind=IK), intent(out), optional :: var_type

    variable type of data in the matrix (if all elements have the same type)

    integer(kind=IK), intent(out), optional :: n_sets

    number of data sets (i.e., matrix rows if using row-major order)

    integer(kind=IK), intent(out), optional :: set_size

    size of each data set (i.e., matrix cols if using row-major order)

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, private :: json_parse_file

  • private subroutine json_parse_file(json, file, p, unit)

    Parse the JSON file and populate the json_value tree.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CDK,len=*), intent(in) :: file

    JSON file name

    type(json_value), pointer:: p

    output structure

    integer(kind=IK), intent(in), optional :: unit

    file unit number (/= 0)

procedure, private :: json_parse_string

  • private subroutine json_parse_string(json, p, str)

    Parse the JSON string and populate the json_value tree.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    output structure

    character(kind=CK,len=*), intent(in) :: str

    string with JSON data

procedure, private :: json_print_1

  • private subroutine json_print_1(json, p, iunit)

    Author
    Jacob Williams
    Date
    6/20/2014

    Print the json_value structure to a file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    integer(kind=IK), intent(in) :: iunit

    the file unit (the file must already have been opened, can't be -1).

procedure, private :: json_print_2

  • private subroutine json_print_2(json, p, filename)

    Author
    Jacob Williams
    Date
    12/23/2014

    Print the json_value structure to a file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CDK,len=*), intent(in) :: filename

    the filename to print to (should not already be open)

procedure, private :: json_string_info

  • private subroutine json_string_info(json, p, ilen, max_str_len, found)

    Author
    Jacob Williams
    Date
    12/18/2016

    Returns information about character strings returned from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(out), optional dimension(:), allocatable:: ilen

    if p is an array, this is the actual length of each character string in the array. if not an array, this is returned unallocated.

    integer(kind=IK), intent(out), optional :: max_str_len

    The maximum length required to hold the string representation returned by a call to a get routine. If a scalar, this is just the length of the scalar. If a vector, this is the maximum length of any element.

    logical(kind=LK), intent(out), optional :: found

    true if there were no errors. if not present, an error will throw an exception

procedure, private :: json_throw_exception

  • private subroutine json_throw_exception(json, msg)

    Author
    Jacob Williams
    Date
    12/4/2013

    Throw an exception in the json_core. This routine sets the error flag, and prevents any subsequent routine from doing anything, until json_clear_exceptions is called.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=*), intent(in) :: msg

    the error message

procedure, private :: json_update_double

  • private subroutine json_update_double(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_integer

  • private subroutine json_update_integer(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_logical

  • private subroutine json_update_logical(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_string

  • private subroutine json_update_string(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=*), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_value_add_double

  • private subroutine json_value_add_double(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add a real value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    variable name

    real(kind=RK), intent(in) :: val

    real value

procedure, private :: json_value_add_double_vec

  • private subroutine json_value_add_double_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a real vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name
    real(kind=RK), intent(in), dimension(:):: val

procedure, private :: json_value_add_integer

  • private subroutine json_value_add_integer(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add an integer value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name
    integer(kind=IK), intent(in) :: val

procedure, private :: json_value_add_integer_vec

  • private subroutine json_value_add_integer_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add an integer vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    integer(kind=IK), intent(in), dimension(:):: val

    value

procedure, private :: json_value_add_logical

  • private subroutine json_value_add_logical(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a logical value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    logical(kind=LK), intent(in) :: val

    value

procedure, private :: json_value_add_logical_vec

  • private subroutine json_value_add_logical_vec(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/20/2014

    Add a logical vector to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the vector

    logical(kind=LK), intent(in), dimension(:):: val

    value

procedure, private :: json_value_add_member

  • private subroutine json_value_add_member(json, p, member)

    Adds member as a child of p.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    type(json_value), pointer:: member

    the child member to add to p

procedure, private :: json_value_add_null

  • private subroutine json_value_add_null(json, p, name)

    Add a NULL value child to the json_value variable

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_add_string

  • private subroutine json_value_add_string(json, p, name, val)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add a character string child to the json_value variable.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    name of the variable

    character(kind=CK,len=*), intent(in) :: val

    value

procedure, private :: json_value_add_string_vec

  • private subroutine json_value_add_string_vec(json, p, name, val, trim_str, adjustl_str)

    Author
    Jacob Williams
    Date
    1/19/2014

    Add an array of character strings to the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    variable name

    character(kind=CK,len=*), intent(in), dimension(:):: val

    array of strings

    logical(kind=LK), intent(in), optional :: trim_str

    if TRIM() should be called for each element

    logical(kind=LK), intent(in), optional :: adjustl_str

    if ADJUSTL() should be called for each element

procedure, private :: json_value_create_array

  • private subroutine json_value_create_array(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an array variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_create_double

  • private subroutine json_value_create_double(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a real(RK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    real(kind=RK), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_create_integer

  • private subroutine json_value_create_integer(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an integer(IK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_create_logical

  • private subroutine json_value_create_logical(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a logical(LK) variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    logical(kind=LK), intent(in) :: val

    variable value

    character(kind=CK,len=*), intent(in) :: name

    variable name

procedure, private :: json_value_create_null

  • private subroutine json_value_create_null(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a null variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_create_object

  • private subroutine json_value_create_object(json, p, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it an object variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_create_string

  • private subroutine json_value_create_string(json, p, val, name)

    Author
    Jacob Williams

    Allocate a json_value pointer and make it a string variable. The pointer should not already be allocated.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: val
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_destroy

  • private recursive subroutine json_value_destroy(json, p, destroy_next)

    Author
    Jacob Williams
    Date
    1/22/2014

    Destroy a json_value linked-list structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    variable to destroy

    logical(kind=LK), intent(in), optional :: destroy_next

    if true, then p%next is also destroyed (default is true)

procedure, private :: json_value_get_child

  • private subroutine json_value_get_child(json, p, child)

    Returns pointer to the first child of the object (or null() if it is not associated).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    object or array JSON data

    type(json_value), pointer:: child

    pointer to the child

procedure, private :: json_value_get_child_by_index

  • private subroutine json_value_get_child_by_index(json, p, idx, child, found)

    Returns a child in the object or array given the index.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p

    object or array JSON data

    integer(kind=IK), intent(in) :: idx

    index of the child (this is a 1-based Fortran style array index).

    type(json_value), pointer:: child

    pointer to the child

    logical(kind=LK), intent(out), optional :: found

    true if the value was found (if not present, an exception will be thrown if it was not found. If present and not found, no exception will be thrown).

procedure, private :: json_value_get_child_by_name

  • private subroutine json_value_get_child_by_name(json, p, name, child, found)

    Returns a child in the object or array given the name string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    the name of a child of p

    type(json_value), pointer:: child

    pointer to the child

    logical(kind=LK), intent(out), optional :: found

    true if the value was found (if not present, an exception will be thrown if it was not found. If present and not found, no exception will be thrown).

procedure, private :: json_value_insert_after

  • private subroutine json_value_insert_after(json, p, element)

    Inserts element after p, and updates the JSON structure accordingly.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a value from a JSON structure (presumably, this is a child of an object or array).

    type(json_value), pointer:: element

    the element to insert after p

procedure, private :: json_value_insert_after_child_by_index

  • private subroutine json_value_insert_after_child_by_index(json, p, idx, element)

    Inserts element after the idx-th child of p, and updates the JSON structure accordingly. This is just a wrapper for json_value_insert_after.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON object or array.

    integer(kind=IK), intent(in) :: idx

    the index of the child of p to insert the new element after (this is a 1-based Fortran style array index)

    type(json_value), pointer:: element

    the element to insert

procedure, private :: json_value_print

  • private recursive subroutine json_value_print(json, p, iunit, str, indent, need_comma, colon, is_array_element, is_compressed_vector)

    Print the JSON structure to a string or a file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    integer(kind=IK), intent(in) :: iunit

    file unit to write to (6=console)

    character(kind=CK,len=:), intent(inout), allocatable:: str

    if iunit==unit2str (-1) then the structure is printed to this string rather than a file. This mode is used by json_value_to_string.

    integer(kind=IK), intent(in), optional :: indent

    indention level

    logical(kind=LK), intent(in), optional :: need_comma

    if it needs a comma after it

    logical(kind=LK), intent(in), optional :: colon

    if the colon was just written

    logical(kind=LK), intent(in), optional :: is_array_element

    if this is an array element

    logical(kind=LK), intent(in), optional :: is_compressed_vector

    if True, this is an element from an array being printed on one line [default is False]

procedure, private :: json_value_remove_if_present

  • private subroutine json_value_remove_if_present(json, p, name)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, remove the variable from the json_value structure, if it exists.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

procedure, private :: json_value_rename

  • private subroutine json_value_rename(json, p, name)

    Author
    Jacob Williams
    Date
    4/29/2016

    Rename a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    new variable name

generic, public :: matrix_info => json_matrix_info, json_matrix_info_by_path

get matrix info about a json_value

  • private subroutine json_matrix_info(json, p, is_matrix, var_type, n_sets, set_size, name)

    Author
    Jacob Williams
    Date
    10/16/2015

    Alternate version of json_info that returns matrix information about a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON linked list

    logical(kind=LK), intent(out) :: is_matrix

    true if it is a valid matrix

    integer(kind=IK), intent(out), optional :: var_type

    variable type of data in the matrix (if all elements have the same type)

    integer(kind=IK), intent(out), optional :: n_sets

    number of data sets (i.e., matrix rows if using row-major order)

    integer(kind=IK), intent(out), optional :: set_size

    size of each data set (i.e., matrix cols if using row-major order)

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

  • private subroutine json_matrix_info_by_path(json, p, path, is_matrix, found, var_type, n_sets, set_size, name)

    Returns matrix information about a json_value, given the path.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    a JSON linked list

    character(kind=CK,len=*), intent(in) :: path

    path to the variable

    logical(kind=LK), intent(out) :: is_matrix

    true if it is a valid matrix

    logical(kind=LK), intent(out), optional :: found

    true if it was found

    integer(kind=IK), intent(out), optional :: var_type

    variable type of data in the matrix (if all elements have the same type)

    integer(kind=IK), intent(out), optional :: n_sets

    number of data sets (i.e., matrix rows if using row-major order)

    integer(kind=IK), intent(out), optional :: set_size

    size of each data set (i.e., matrix cols if using row-major order)

    character(kind=CK,len=:), intent(out), optional allocatable:: name

    variable name

procedure, private :: name_equal

  • private function name_equal(json, p, name) result(is_equal)

    Author
    Jacob Williams

    Returns true if name is equal to p%name, using the specified settings for case sensitivity and trailing whitespace.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in) :: p

    the json object

    character(kind=CK,len=*), intent(in) :: name

    the name to check for

    Return Value logical(kind=LK)

    true if the string are lexically equal

procedure, private :: name_strings_equal

  • private function name_strings_equal(json, name1, name2) result(is_equal)

    Author
    Jacob Williams
    Date
    8/25/2017

    Returns true if the name strings name1 is equal to name2, using the specified settings for case sensitivity and trailing whitespace.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=*), intent(in) :: name1

    the name to check

    character(kind=CK,len=*), intent(in) :: name2

    the name to check

    Return Value logical(kind=LK)

    true if the string are lexically equal

generic, public :: parse => json_parse_file, json_parse_string

Parse the JSON file and populate the json_value tree.

  • private subroutine json_parse_file(json, file, p, unit)

    Parse the JSON file and populate the json_value tree.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CDK,len=*), intent(in) :: file

    JSON file name

    type(json_value), pointer:: p

    output structure

    integer(kind=IK), intent(in), optional :: unit

    file unit number (/= 0)

  • private subroutine json_parse_string(json, p, str)

    Parse the JSON string and populate the json_value tree.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

    output structure

    character(kind=CK,len=*), intent(in) :: str

    string with JSON data

procedure, private :: parse_array

  • private recursive subroutine parse_array(json, unit, str, array)

    Core parsing routine.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string)

    type(json_value), pointer:: array

procedure, private :: parse_for_chars

  • private subroutine parse_for_chars(json, unit, str, chars)

    Core parsing routine.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string)

    character(kind=CK,len=*), intent(in) :: chars

    the string to check for.

procedure, private :: parse_number

  • private subroutine parse_number(json, unit, str, value)

    Author
    Jacob Williams
    Date
    1/20/2014

    Read a numerical value from the file (or string). The routine will determine if it is an integer or a double, and allocate the type accordingly.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string)

    type(json_value), pointer:: value

procedure, private :: parse_object

  • private recursive subroutine parse_object(json, unit, str, parent)

    Core parsing routine.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string)

    type(json_value), pointer:: parent

    the parsed object will be added as a child of this

procedure, private :: parse_string

  • private subroutine parse_string(json, unit, str, string)

    Parses a string while reading a JSON file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string)

    character(kind=CK,len=:), intent(out), allocatable:: string

    the string (unescaped if necessary)

procedure, private :: parse_value

  • private recursive subroutine parse_value(json, unit, str, value)

    Core parsing routine.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number

    character(kind=CK,len=*), intent(in) :: str

    string containing JSON data (only used if unit=0)

    type(json_value), pointer:: value

    JSON data that is extracted

procedure, private :: pop_char

  • private recursive subroutine pop_char(json, unit, str, skip_ws, skip_comments, eof, popped)

    Get the next character from the file (or string).

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer(kind=IK), intent(in) :: unit

    file unit number (if parsing from a file)

    character(kind=CK,len=*), intent(in) :: str

    JSON string (if parsing from a string) – only used if unit=0

    logical(kind=LK), intent(in), optional :: skip_ws

    to ignore whitespace [default False]

    logical(kind=LK), intent(in), optional :: skip_comments

    to ignore comment lines [default False]

    logical(kind=LK), intent(out) :: eof

    true if the end of the file has been reached.

    character(kind=CK,len=1), intent(out) :: popped

    the popped character returned

generic, public :: print => json_print_1, json_print_2

Print the json_value to a file.

Example

    type(json_core) :: json
    type(json_value) :: p
    !...
    call json%print(p,'test.json')  !this is json_print_2
  • private subroutine json_print_1(json, p, iunit)

    Author
    Jacob Williams
    Date
    6/20/2014

    Print the json_value structure to a file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    integer(kind=IK), intent(in) :: iunit

    the file unit (the file must already have been opened, can't be -1).

  • private subroutine json_print_2(json, p, filename)

    Author
    Jacob Williams
    Date
    12/23/2014

    Print the json_value structure to a file.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CDK,len=*), intent(in) :: filename

    the filename to print to (should not already be open)

procedure, public :: print_error_message => json_print_error_message

simply routine to print error messages

  • private subroutine json_print_error_message(json, io_unit)

    Author
    Jacob Williams

    Print any error message, and then clear the exceptions.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    integer, intent(in), optional :: io_unit

procedure, public :: print_to_string => json_value_to_string

Print the json_value structure to an allocatable string

  • private subroutine json_value_to_string(json, p, str)

    Author
    Jacob Williams
    Date
    2/12/2014

    Print the json_value structure to an allocatable string.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CK,len=:), intent(out), allocatable:: str

    prints structure to this string

procedure, private :: push_char

  • private subroutine push_char(json, c)

    Core routine.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=1), intent(in) :: c

    to character to push

procedure, public :: remove => json_value_remove

Remove a json_value from a linked-list structure.

  • private subroutine json_value_remove(json, p, destroy)

    Author
    Jacob Williams
    Date
    9/9/2014

    Remove a json_value (and all its children) from a linked-list structure, preserving the rest of the structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    logical(kind=LK), intent(in), optional :: destroy

    If destroy is not present, it is also destroyed. If destroy is present and true, it is destroyed. If destroy is present and false, it is not destroyed.

generic, public :: remove_if_present => json_value_remove_if_present

If the child variable is present, then remove it.

  • private subroutine json_value_remove_if_present(json, p, name)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, remove the variable from the json_value structure, if it exists.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

generic, public :: rename => json_value_rename

Rename a json_value variable.

  • private subroutine json_value_rename(json, p, name)

    Author
    Jacob Williams
    Date
    4/29/2016

    Rename a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    character(kind=CK,len=*), intent(in) :: name

    new variable name

procedure, public :: replace => json_value_replace

Replace a json_value in a linked-list structure.

  • private subroutine json_value_replace(json, p1, p2, destroy)

    Replace p1 with p2 in a JSON structure.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p1

    the item to replace

    type(json_value), pointer:: p2

    item to take the place of p1

    logical(kind=LK), intent(in), optional :: destroy

    Should p1 also be destroyed (default is True). Normally, this should be true to avoid a memory leak.

procedure, public :: reverse => json_value_reverse

Reverse the order of the children of an array of object.

  • private subroutine json_value_reverse(json, p)

    Author
    Jacob Williams
    Date
    4/11/2017

    Reverse the order of the children of an array or object.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p

generic, public :: string_info => json_string_info

get string info about a json_value

  • private subroutine json_string_info(json, p, ilen, max_str_len, found)

    Author
    Jacob Williams
    Date
    12/18/2016

    Returns information about character strings returned from a json_value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    integer(kind=IK), intent(out), optional dimension(:), allocatable:: ilen

    if p is an array, this is the actual length of each character string in the array. if not an array, this is returned unallocated.

    integer(kind=IK), intent(out), optional :: max_str_len

    The maximum length required to hold the string representation returned by a call to a get routine. If a scalar, this is just the length of the scalar. If a vector, this is the maximum length of any element.

    logical(kind=LK), intent(out), optional :: found

    true if there were no errors. if not present, an error will throw an exception

procedure, private :: string_to_dble

  • private function string_to_dble(json, str) result(rval)

    Convert a string into a double.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=*), intent(in) :: str

    Return Value real(kind=RK)

procedure, private :: string_to_int

  • private function string_to_int(json, str) result(ival)

    Convert a string into an integer.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=*), intent(in) :: str

    Return Value integer(kind=IK)

procedure, public :: swap => json_value_swap

Swap two json_value pointers in a structure (or two different structures).

  • private subroutine json_value_swap(json, p1, p2)

    Author
    Jacob Williams
    Date
    4/26/2016

    Swap two elements in a JSON structure. All of the children are carried along as well.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p1
    type(json_value), pointer:: p2

generic, public :: throw_exception => json_throw_exception

Throw an exception.

  • private subroutine json_throw_exception(json, msg)

    Author
    Jacob Williams
    Date
    12/4/2013

    Throw an exception in the json_core. This routine sets the error flag, and prevents any subsequent routine from doing anything, until json_clear_exceptions is called.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    character(kind=CK,len=*), intent(in) :: msg

    the error message

procedure, public :: traverse => json_traverse

to traverse all elements of a JSON structure

These are like the add methods, except if a variable with the same path is already present, then its value is simply updated. Note that currently, these only work for scalar variables. These routines can also change the variable's type (but an error will be thrown if the existing variable is not a scalar).

See also

  • add_by_path - this one can be used to change arrays and objects to scalars if so desired.

  • private subroutine json_update_logical(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    logical(kind=LK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_double(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    real(kind=RK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_integer(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    integer(kind=IK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_string(json, p, path, val, found)

    Author
    Jacob Williams
    Date
    12/6/2014

    Given the path string, if the variable is present, and is a scalar, then update its value. If it is not present, then create it and set its value.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), pointer:: p
    character(kind=CK,len=*), intent(in) :: path
    character(kind=CK,len=*), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, public :: validate => json_value_validate

Check that a json_value linked list is valid (i.e., is properly constructed). This may be useful if it has been constructed externally.

  • private subroutine json_value_validate(json, p, is_valid, error_msg)

    Author
    Jacob Williams
    Date
    5/2/2016

    Validate a json_value linked list by checking to make sure all the pointers are properly associated, arrays and objects have the correct number of children, and the correct data is allocated for the variable types.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    type(json_value), intent(in), pointer:: p
    logical(kind=LK), intent(out) :: is_valid

    True if the structure is valid.

    character(kind=CK,len=:), intent(out), allocatable:: error_msg

    if not valid, this will contain a description of the problem

Source Code

    type,public :: json_core

        private

        integer(IK) :: spaces_per_tab = 2    !! number of spaces for indenting

        logical(LK) :: compact_real = .true.  !! to use the "compact" form of real
                                              !! numbers for output
        character(kind=CDK,len=:),allocatable :: real_fmt   !! the format string to use
                                                            !! for converting real numbers to strings.
                                                            !! It can be set in [[json_initialize]],
                                                            !! and used in [[json_value_print]]
                                                            !! If not set, then `default_real_fmt`
                                                            !! is used instead.

        logical(LK) :: is_verbose = .false.        !! if true, all exceptions are
                                                   !! immediately printed to console.
        logical(LK) :: exception_thrown = .false.  !! The error flag. Will be set to true
                                                   !! when an error is thrown in the class.
                                                   !! Many of the methods will check this
                                                   !! and return immediately if it is true.
        character(kind=CK,len=:),allocatable :: err_message !! the error message

        integer(IK) :: char_count = 0    !! character position in the current line
        integer(IK) :: line_count = 1    !! lines read counter
        integer(IK) :: pushed_index = 0  !! used when parsing lines in file
        character(kind=CK,len=pushed_char_size) :: pushed_char = CK_''  !! used when parsing
                                                                        !! lines in file

        integer(IK) :: ipos = 1  !! for allocatable strings: next character to read

        logical(LK) :: strict_type_checking = .false. !! if true, then no type conversions are done
                                                      !! in the `get` routines if the actual variable
                                                      !! type is different from the return type (for
                                                      !! example, integer to double).

        logical(LK) :: trailing_spaces_significant = .false.    !! for name and path comparisons, if trailing
                                                                !! space is to be considered significant.

        logical(LK) :: case_sensitive_keys = .true.    !! if name and path comparisons
                                                       !! are case sensitive.

        logical(LK) :: no_whitespace = .false. !! when printing a JSON string, don't include
                                               !! non-significant spaces or line breaks.
                                               !! If true, the entire structure will be
                                               !! printed on one line.

        logical(LK) :: unescaped_strings = .true.  !! If false, then the escaped
                                                   !! string is returned from [[json_get_string]]
                                                   !! and similar routines. If true [default],
                                                   !! then the string is returned unescaped.

        logical(LK) :: allow_comments = .true.  !! if true, any comments will be ignored when
                                                !! parsing a file. The comment token is defined
                                                !! by the `comment_char` character variable.
        character(kind=CK,len=1) :: comment_char = CK_'!'  !! comment token when
                                                           !! `allow_comments` is true.
                                                           !! Examples: '`!`' or '`#`'.

        integer(IK) :: path_mode = 1_IK  !! How the path strings are interpreted in the
                                         !! `get_by_path` routines:
                                         !!
                                         !! * 1 -- Default mode (see [[json_get_by_path_default]])
                                         !! * 2 -- as RFC 6901 "JSON Pointer" paths
                                         !!   (see [[json_get_by_path_rfc6901]])
                                         !! * 3 -- JSONPath "bracket-notation"
                                         !!   see [[json_get_by_path_jsonpath_bracket]])

        character(kind=CK,len=1) :: path_separator = dot !! The `path` separator to use
                                                         !! in the "default" mode for
                                                         !! the paths in the various
                                                         !! `get_by_path` routines.
                                                         !! Note: if `path_mode/=1`
                                                         !! then this is ignored.

        logical(LK) :: compress_vectors = .false. !! If true, then arrays of integers,
                                                  !! nulls, doubles, & logicals are
                                                  !! printed all on one line.
                                                  !! [Note: `no_whitespace` will
                                                  !! override this option if necessary]

        logical(LK) :: allow_duplicate_keys = .true. !! If False, then after parsing, if any
                                                     !! duplicate keys are found, an error is
                                                     !! thrown. A call to [[json_value_validate]]
                                                     !! will also check for duplicates. If True
                                                     !! [default] then no special checks are done

        logical(LK) :: escape_solidus = .false.   !! If True then the solidus "`/`" is always escaped
                                                  !! ("`\/`") when serializing JSON.
                                                  !! If False [default], then it is not escaped.
                                                  !! Note that this option does not affect parsing
                                                  !! (both escaped and unescaped versions are still
                                                  !! valid in all cases).

        contains

        private

        !>
        !  Return a child of a [[json_value]] structure.
        generic,public :: get_child => json_value_get_child_by_index, &
                                       json_value_get_child,&
                                       MAYBEWRAP(json_value_get_child_by_name)
        procedure,private :: json_value_get_child_by_index
        procedure,private :: MAYBEWRAP(json_value_get_child_by_name)
        procedure,private :: json_value_get_child

        !>
        !  Add objects to a linked list of [[json_value]]s.
        !
        !@note It might make more sense to call this `add_child`.
        generic,public :: add => json_value_add_member, &
                                 MAYBEWRAP(json_value_add_null), &
                                 MAYBEWRAP(json_value_add_integer), &
                                 MAYBEWRAP(json_value_add_integer_vec), &
                                 MAYBEWRAP(json_value_add_double), &
                                 MAYBEWRAP(json_value_add_double_vec), &
                                 MAYBEWRAP(json_value_add_logical), &
                                 MAYBEWRAP(json_value_add_logical_vec), &
                                 MAYBEWRAP(json_value_add_string), &
                                 MAYBEWRAP(json_value_add_string_vec)
#ifdef USE_UCS4
        generic,public :: add => json_value_add_string_name_ascii, &
                                 json_value_add_string_val_ascii, &
                                 json_value_add_string_vec_name_ascii, &
                                 json_value_add_string_vec_val_ascii
#endif

    procedure,private :: json_value_add_member
    procedure,private :: MAYBEWRAP(json_value_add_integer)
    procedure,private :: MAYBEWRAP(json_value_add_null)
    procedure,private :: MAYBEWRAP(json_value_add_integer_vec)
    procedure,private :: MAYBEWRAP(json_value_add_double)
    procedure,private :: MAYBEWRAP(json_value_add_double_vec)
    procedure,private :: MAYBEWRAP(json_value_add_logical)
    procedure,private :: MAYBEWRAP(json_value_add_logical_vec)
    procedure,private :: MAYBEWRAP(json_value_add_string)
    procedure,private :: MAYBEWRAP(json_value_add_string_vec)
#ifdef USE_UCS4
    procedure,private :: json_value_add_string_name_ascii
    procedure,private :: json_value_add_string_val_ascii
    procedure,private :: json_value_add_string_vec_name_ascii
    procedure,private :: json_value_add_string_vec_val_ascii
#endif

        !>
        !  These are like the `add` methods, except if a variable with the
        !  same path is already present, then its value is simply updated.
        !  Note that currently, these only work for scalar variables.
        !  These routines can also change the variable's type (but an error will be
        !  thrown if the existing variable is not a scalar).
        !
        !### See also
        !  * [[json_core(type):add_by_path]] - this one can be used to change
        !    arrays and objects to scalars if so desired.
        !
        !@note Unlike some routines, the `found` output is not optional,
        !      so it doesn't present exceptions from being thrown.
        !
        !@note These have been mostly supplanted by the [[json_core(type):add_by_path]]
        !      methods, which do a similar thing (and can be used for
        !      scalars and vectors, etc.)
        generic,public :: update => MAYBEWRAP(json_update_logical),&
                                    MAYBEWRAP(json_update_double),&
                                    MAYBEWRAP(json_update_integer),&
                                    MAYBEWRAP(json_update_string)
#ifdef USE_UCS4
        generic,public :: update => json_update_string_name_ascii,&
                                    json_update_string_val_ascii
#endif
        procedure,private :: MAYBEWRAP(json_update_logical)
        procedure,private :: MAYBEWRAP(json_update_double)
        procedure,private :: MAYBEWRAP(json_update_integer)
        procedure,private :: MAYBEWRAP(json_update_string)
#ifdef USE_UCS4
        procedure,private :: json_update_string_name_ascii
        procedure,private :: json_update_string_val_ascii
#endif

        !>
        !  Add variables to a [[json_value]] linked list
        !  by specifying their paths.
        !
        !### Example
        !
        !````fortran
        !    use, intrinsic :: iso_fortran_env, only: output_unit, wp=>real64
        !    use json_module
        !    type(json_core) :: json
        !    type(json_value) :: p
        !    call json%create_object(p,'root') ! create the root
        !    ! now add some variables using the paths:
        !    call json%add_by_path(p,'inputs.t',    0.0_wp  )
        !    call json%add_by_path(p,'inputs.x(1)', 100.0_wp)
        !    call json%add_by_path(p,'inputs.x(2)', 200.0_wp)
        !    call json%print(p,output_unit)  ! now print to console
        !````
        !
        !### Notes
        !  * This uses [[json_create_by_path]]
        !
        !### See also
        !  * The `json_core%update` methods.
        !  * [[json_create_by_path]]

        generic,public :: add_by_path => MAYBEWRAP(json_add_member_by_path),&
                                         MAYBEWRAP(json_add_integer_by_path),&
                                         MAYBEWRAP(json_add_double_by_path),&
                                         MAYBEWRAP(json_add_logical_by_path),&
                                         MAYBEWRAP(json_add_string_by_path),&
                                         MAYBEWRAP(json_add_integer_vec_by_path),&
                                         MAYBEWRAP(json_add_double_vec_by_path),&
                                         MAYBEWRAP(json_add_logical_vec_by_path),&
                                         MAYBEWRAP(json_add_string_vec_by_path)
#ifdef USE_UCS4
        generic,public :: add_by_path => json_add_string_by_path_value_ascii,&
                                         json_add_string_by_path_path_ascii,&
                                         json_add_string_vec_by_path_value_ascii,&
                                         json_add_string_vec_by_path_path_ascii
#endif
        procedure :: MAYBEWRAP(json_add_member_by_path)
        procedure :: MAYBEWRAP(json_add_integer_by_path)
        procedure :: MAYBEWRAP(json_add_double_by_path)
        procedure :: MAYBEWRAP(json_add_logical_by_path)
        procedure :: MAYBEWRAP(json_add_string_by_path)
        procedure :: MAYBEWRAP(json_add_integer_vec_by_path)
        procedure :: MAYBEWRAP(json_add_double_vec_by_path)
        procedure :: MAYBEWRAP(json_add_logical_vec_by_path)
        procedure :: MAYBEWRAP(json_add_string_vec_by_path)
#ifdef USE_UCS4
        procedure :: json_add_string_by_path_value_ascii
        procedure :: json_add_string_by_path_path_ascii
        procedure :: json_add_string_vec_by_path_value_ascii
        procedure :: json_add_string_vec_by_path_path_ascii
#endif

        !>
        !  Create a [[json_value]] linked list using the
        !  path to the variables. Optionally return a
        !  pointer to the variable.
        !
        !  (This will create a `null` variable)
        !
        !### See also
        !  * [[json_core(type):add_by_path]]

        generic,public :: create => MAYBEWRAP(json_create_by_path)
        procedure :: MAYBEWRAP(json_create_by_path)

        !>
        !  Get data from a [[json_value]] linked list.
        !
        !@note There are two versions (e.g. [[json_get_integer]] and [[json_get_integer_by_path]]).
        !      The first one gets the value from the [[json_value]] passed into the routine,
        !      while the second one gets the value from the [[json_value]] found by parsing the
        !      path.  The path version is split up into unicode and non-unicode versions.

        generic,public :: get => &
                                  MAYBEWRAP(json_get_by_path),             &
            json_get_integer,     MAYBEWRAP(json_get_integer_by_path),     &
            json_get_integer_vec, MAYBEWRAP(json_get_integer_vec_by_path), &
            json_get_double,      MAYBEWRAP(json_get_double_by_path),      &
            json_get_double_vec,  MAYBEWRAP(json_get_double_vec_by_path),  &
            json_get_logical,     MAYBEWRAP(json_get_logical_by_path),     &
            json_get_logical_vec, MAYBEWRAP(json_get_logical_vec_by_path), &
            json_get_string,      MAYBEWRAP(json_get_string_by_path),      &
            json_get_string_vec,  MAYBEWRAP(json_get_string_vec_by_path),  &
            json_get_alloc_string_vec,MAYBEWRAP(json_get_alloc_string_vec_by_path),&
            json_get_array,       MAYBEWRAP(json_get_array_by_path)

        procedure,private :: json_get_integer
        procedure,private :: json_get_integer_vec
        procedure,private :: json_get_double
        procedure,private :: json_get_double_vec
        procedure,private :: json_get_logical
        procedure,private :: json_get_logical_vec
        procedure,private :: json_get_string
        procedure,private :: json_get_string_vec
        procedure,private :: json_get_alloc_string_vec
        procedure,private :: json_get_array
        procedure,private :: MAYBEWRAP(json_get_by_path)
        procedure,private :: MAYBEWRAP(json_get_integer_by_path)
        procedure,private :: MAYBEWRAP(json_get_integer_vec_by_path)
        procedure,private :: MAYBEWRAP(json_get_double_by_path)
        procedure,private :: MAYBEWRAP(json_get_double_vec_by_path)
        procedure,private :: MAYBEWRAP(json_get_logical_by_path)
        procedure,private :: MAYBEWRAP(json_get_logical_vec_by_path)
        procedure,private :: MAYBEWRAP(json_get_string_by_path)
        procedure,private :: MAYBEWRAP(json_get_string_vec_by_path)
        procedure,private :: MAYBEWRAP(json_get_array_by_path)
        procedure,private :: MAYBEWRAP(json_get_alloc_string_vec_by_path)
        procedure,private :: json_get_by_path_default
        procedure,private :: json_get_by_path_rfc6901
        procedure,private :: json_get_by_path_jsonpath_bracket

        procedure,public :: print_to_string => json_value_to_string !! Print the [[json_value]]
                                                                    !! structure to an allocatable
                                                                    !! string

        !>
        !  Print the [[json_value]] to a file.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value) :: p
        !    !...
        !    call json%print(p,'test.json')  !this is [[json_print_2]]
        !````
        generic,public :: print => json_print_1,json_print_2
        procedure :: json_print_1
        procedure :: json_print_2

        !>
        !  Destructor routine for a [[json_value]] pointer.
        !  This must be called explicitly if it is no longer needed,
        !  before it goes out of scope.  Otherwise, a memory leak will result.
        !
        !### Example
        !
        !  Destroy the [[json_value]] pointer before the variable goes out of scope:
        !````fortran
        !     subroutine example1()
        !     type(json_core) :: json
        !     type(json_value),pointer :: p
        !     call json%create_object(p,'')
        !     call json%add(p,'year',2015)
        !     call json%print(p)
        !     call json%destroy(p)
        !     end subroutine example1
        !````
        !
        !  Note: it should NOT be called for a [[json_value]] pointer than has already been
        !  added to another [[json_value]] structure, since doing so may render the
        !  other structure invalid.  Consider the following example:
        !````fortran
        !     subroutine example2(p)
        !     type(json_core) :: json
        !     type(json_value),pointer,intent(out) :: p
        !     type(json_value),pointer :: q
        !     call json%create_object(p,'')
        !     call json%add(p,'year',2015)
        !     call json%create_object(q,'q')
        !     call json%add(q,'val',1)
        !     call json%add(p, q)  !add q to p structure
        !     ! do NOT call json%destroy(q) here, because q is
        !     ! now part of the output structure p.  p should be destroyed
        !     ! somewhere upstream by the caller of this routine.
        !     nullify(q) !OK, but not strictly necessary
        !     end subroutine example2
        !````
        generic,public :: destroy => json_value_destroy,destroy_json_core
        procedure :: json_value_destroy
        procedure :: destroy_json_core

        !>
        !  If the child variable is present, then remove it.
        generic,public :: remove_if_present => MAYBEWRAP(json_value_remove_if_present)
        procedure :: MAYBEWRAP(json_value_remove_if_present)

        !>
        !  Allocate a [[json_value]] pointer and make it a double variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_double(p,'value',1.0_RK)
        !````
        generic,public :: create_double => MAYBEWRAP(json_value_create_double)
        procedure :: MAYBEWRAP(json_value_create_double)

        !>
        !  Allocate a [[json_value]] pointer and make it an array variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_array(p,'arrayname')
        !````
        generic,public :: create_array => MAYBEWRAP(json_value_create_array)
        procedure :: MAYBEWRAP(json_value_create_array)

        !>
        !  Allocate a [[json_value]] pointer and make it an object variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_object(p,'objectname')
        !````
        !
        !@note The name is not significant for the root structure or an array element.
        !      In those cases, an empty string can be used.
        generic,public :: create_object => MAYBEWRAP(json_value_create_object)
        procedure :: MAYBEWRAP(json_value_create_object)

        !>
        !  Allocate a json_value pointer and make it a null variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_null(p,'value')
        !````
        generic,public :: create_null => MAYBEWRAP(json_value_create_null)
        procedure :: MAYBEWRAP(json_value_create_null)

        !>
        !  Allocate a json_value pointer and make it a string variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_string(p,'value','foobar')
        !````
        generic,public :: create_string => MAYBEWRAP(json_value_create_string)
        procedure :: MAYBEWRAP(json_value_create_string)

        !>
        !  Allocate a json_value pointer and make it an integer variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_integer(p,42,'value')
        !````
        generic,public :: create_integer => MAYBEWRAP(json_value_create_integer)
        procedure :: MAYBEWRAP(json_value_create_integer)

        !>
        !  Allocate a json_value pointer and make it a logical variable.
        !  The pointer should not already be allocated.
        !
        !### Example
        !
        !````fortran
        !    type(json_core) :: json
        !    type(json_value),pointer :: p
        !    call json%create_logical(p,'value',.true.)
        !````
        generic,public :: create_logical => MAYBEWRAP(json_value_create_logical)
        procedure :: MAYBEWRAP(json_value_create_logical)

        !>
        !  Parse the JSON file and populate the [[json_value]] tree.
        generic,public :: parse => json_parse_file, MAYBEWRAP(json_parse_string)
        procedure :: json_parse_file
        procedure :: MAYBEWRAP(json_parse_string)

        !>
        !  Throw an exception.
        generic,public :: throw_exception => MAYBEWRAP(json_throw_exception)
        procedure :: MAYBEWRAP(json_throw_exception)

        !>
        !  Rename a [[json_value]] variable.
        generic,public :: rename => MAYBEWRAP(json_value_rename)
        procedure :: MAYBEWRAP(json_value_rename)

        !>
        !  get info about a [[json_value]]
        generic,public :: info => json_info, MAYBEWRAP(json_info_by_path)
        procedure :: json_info
        procedure :: MAYBEWRAP(json_info_by_path)

        !>
        !  get string info about a [[json_value]]
        generic,public :: string_info => json_string_info
        procedure :: json_string_info

        !>
        !  get matrix info about a [[json_value]]
        generic,public :: matrix_info => json_matrix_info, MAYBEWRAP(json_matrix_info_by_path)
        procedure :: json_matrix_info
        procedure :: MAYBEWRAP(json_matrix_info_by_path)

        !>
        !  insert a new element after an existing one,
        !  updating the JSON structure accordingly
        generic,public :: insert_after => json_value_insert_after, &
                                          json_value_insert_after_child_by_index
        procedure :: json_value_insert_after
        procedure :: json_value_insert_after_child_by_index

        !>
        !  get the path to a JSON variable in a structure:
        generic,public :: get_path => MAYBEWRAP(json_get_path)
        procedure :: MAYBEWRAP(json_get_path)

        procedure,public :: remove              => json_value_remove        !! Remove a [[json_value]] from a
                                                                            !! linked-list structure.
        procedure,public :: replace             => json_value_replace       !! Replace a [[json_value]] in a
                                                                            !! linked-list structure.
        procedure,public :: reverse             => json_value_reverse       !! Reverse the order of the children
                                                                            !! of an array of object.
        procedure,public :: check_for_errors    => json_check_for_errors    !! check for error and get error message
        procedure,public :: clear_exceptions    => json_clear_exceptions    !! clear exceptions
        procedure,public :: count               => json_count               !! count the number of children
        procedure,public :: clone               => json_clone               !! clone a JSON structure (deep copy)
        procedure,public :: failed              => json_failed              !! check for error
        procedure,public :: get_parent          => json_get_parent          !! get pointer to json_value parent
        procedure,public :: get_next            => json_get_next            !! get pointer to json_value next
        procedure,public :: get_previous        => json_get_previous        !! get pointer to json_value previous
        procedure,public :: get_tail            => json_get_tail            !! get pointer to json_value tail
        procedure,public :: initialize          => json_initialize          !! to initialize some parsing parameters
        procedure,public :: traverse            => json_traverse            !! to traverse all elements of a JSON
                                                                            !! structure
        procedure,public :: print_error_message => json_print_error_message !! simply routine to print error
                                                                            !! messages
        procedure,public :: swap                => json_value_swap          !! Swap two [[json_value]] pointers
                                                                            !! in a structure (or two different
                                                                            !! structures).
        procedure,public :: is_child_of         => json_value_is_child_of   !! Check if a [[json_value]] is a
                                                                            !! descendant of another.
        procedure,public :: validate            => json_value_validate      !! Check that a [[json_value]] linked
                                                                            !! list is valid (i.e., is properly
                                                                            !! constructed). This may be useful
                                                                            !! if it has been constructed externally.
        procedure,public :: check_for_duplicate_keys &
                                => json_check_all_for_duplicate_keys  !! Check entire JSON structure
                                                                      !! for duplicate keys (recursively)
        procedure,public :: check_children_for_duplicate_keys &
                                => json_check_children_for_duplicate_keys  !! Check a `json_value` object's
                                                                           !! children for duplicate keys

        !other private routines:
        procedure :: name_equal
        procedure :: name_strings_equal
        procedure :: json_value_print
        procedure :: string_to_int
        procedure :: string_to_dble
        procedure :: parse_value
        procedure :: parse_number
        procedure :: parse_string
        procedure :: parse_for_chars
        procedure :: parse_object
        procedure :: parse_array
        procedure :: annotate_invalid_json
        procedure :: pop_char
        procedure :: push_char
        procedure :: get_current_line_from_file_stream
        procedure :: get_current_line_from_file_sequential
        procedure :: convert

    end type json_core