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 annotate_invalid_json check_for_errors clear_exceptions clone count 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_get_array json_get_array_with_path json_get_by_path json_get_double json_get_double_vec json_get_double_vec_with_path json_get_double_with_path json_get_integer json_get_integer_vec json_get_integer_vec_with_path json_get_integer_with_path json_get_logical json_get_logical_vec json_get_logical_vec_with_path json_get_logical_with_path json_get_path json_get_string json_get_string_vec json_get_string_vec_with_path json_get_string_with_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_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_by_index json_value_get_by_name_chars json_value_get_child 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 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 string_to_double string_to_integer swap throw_exception traverse update validate

Source Code


Components

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

for name and path comparisons, are they case sensitive.

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

character position in the current line

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

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

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

the error message

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.

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

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, is trailing space to be considered significant.

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

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.


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) 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.

    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

  • 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

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_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, 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_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,'value',42)
  • 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_with_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_with_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), 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_with_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_with_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), 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) :: value
  • private subroutine json_get_logical_with_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) :: 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_with_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_with_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_with_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_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_with_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
  • private subroutine json_value_get_by_index(json, p, idx, child)

    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

    type(json_value), pointer:: child

    pointer to the 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

  • private subroutine json_value_get_by_name_chars(json, p, name, child)

    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

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]

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

    character to use for path separator (default is '.')

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(json, verbose, compact_reals, print_signs, real_format, spaces_per_tab, strict_type_checking, trailing_spaces_significant, case_sensitive_keys, no_whitespace, unescape_strings)

    Author
    Jacob Williams
    Date
    12/4/2013

    Initialize the json_core instance.

    Arguments

    Type IntentOptional AttributesName
    class(json_core), intent(inout) :: json
    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.

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

    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_get_array

procedure, private :: json_get_array_with_path

  • private subroutine json_get_array_with_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_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_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_with_path

  • private subroutine json_get_double_vec_with_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), 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_double_with_path

  • private subroutine json_get_double_with_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_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_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_with_path

  • private subroutine json_get_integer_vec_with_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), 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_integer_with_path

  • private subroutine json_get_integer_with_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_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) :: value

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_with_path

  • private subroutine json_get_logical_vec_with_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_logical_with_path

  • private subroutine json_get_logical_with_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) :: value
    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]

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

    character to use for path separator (default is '.')

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_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_with_path

  • private subroutine json_get_string_vec_with_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_get_string_with_path

  • private subroutine json_get_string_with_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_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_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, name, 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) :: name
    real(kind=RK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_integer

  • private subroutine json_update_integer(json, p, name, 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) :: name
    integer(kind=IK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_logical

  • private subroutine json_update_logical(json, p, name, 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) :: name
    logical(kind=LK), intent(in) :: val
    logical(kind=LK), intent(out) :: found

procedure, private :: json_update_string

  • private subroutine json_update_string(json, p, name, 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) :: name
    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

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_by_index

  • private subroutine json_value_get_by_index(json, p, idx, child)

    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

    type(json_value), pointer:: child

    pointer to the child

procedure, private :: json_value_get_by_name_chars

  • private subroutine json_value_get_by_name_chars(json, p, name, child)

    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

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_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

    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)

    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

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
    Date
    4/30/2016

    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

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

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 function pop_char(json, unit, str, eof, skip_ws) result(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(out) :: eof

    true if the end of the file has been reached.

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

    to ignore whitespace.

    Return Value character(kind=CK,len=1)

    the popped character.

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

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, private :: string_to_double

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

    Author
    Jacob Williams
    Date
    1/19/2014

    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_integer

  • private function string_to_integer(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 child with the same name 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).

  • private subroutine json_update_logical(json, p, name, 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) :: name
    logical(kind=LK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_double(json, p, name, 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) :: name
    real(kind=RK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_integer(json, p, name, 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) :: name
    integer(kind=IK), intent(in) :: val
    logical(kind=LK), intent(out) :: found
  • private subroutine json_update_string(json, p, name, 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) :: name
    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 = ''  !! 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, is trailing
                                                                !! space to be considered significant.

        logical(LK) :: case_sensitive_keys = .true.    !! for name and path comparisons, are they
                                                       !! 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 raw escaped
                                                   !! string is returned from [[json_get_string]]
                                                   !! and similar routines. If true [default],
                                                   !! then the string is returned unescaped.

        contains

        private

        generic,public :: get_child => json_value_get_by_index, &
                                       json_value_get_child,&
                                       MAYBEWRAP(json_value_get_by_name_chars)
        procedure,private :: json_value_get_by_index
        procedure,private :: MAYBEWRAP(json_value_get_by_name_chars)
        procedure,private :: json_value_get_child

        !>
        !  Add objects to a linked list of [[json_value]]s.
        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 child with the
        !  same name 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).
        !
        !@note It should not be used to change the type of a variable in an array,
        !      or it may result in an invalid JSON file.

        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

        !>
        !  Get data from a [[json_value]] linked list.
        !
        !@note There are two versions (e.g. [[json_get_integer]] and [[json_get_integer_with_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_with_path),     &
            json_get_integer_vec, MAYBEWRAP(json_get_integer_vec_with_path), &
            json_get_double,      MAYBEWRAP(json_get_double_with_path),      &
            json_get_double_vec,  MAYBEWRAP(json_get_double_vec_with_path),  &
            json_get_logical,     MAYBEWRAP(json_get_logical_with_path),     &
            json_get_logical_vec, MAYBEWRAP(json_get_logical_vec_with_path), &
            json_get_string,      MAYBEWRAP(json_get_string_with_path),      &
            json_get_string_vec,  MAYBEWRAP(json_get_string_vec_with_path),  &
            json_get_array,       MAYBEWRAP(json_get_array_with_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_array
        procedure,private :: MAYBEWRAP(json_get_by_path)
        procedure,private :: MAYBEWRAP(json_get_integer_with_path)
        procedure,private :: MAYBEWRAP(json_get_integer_vec_with_path)
        procedure,private :: MAYBEWRAP(json_get_double_with_path)
        procedure,private :: MAYBEWRAP(json_get_double_vec_with_path)
        procedure,private :: MAYBEWRAP(json_get_logical_with_path)
        procedure,private :: MAYBEWRAP(json_get_logical_vec_with_path)
        procedure,private :: MAYBEWRAP(json_get_string_with_path)
        procedure,private :: MAYBEWRAP(json_get_string_vec_with_path)
        procedure,private :: MAYBEWRAP(json_get_array_with_path)

        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,'value',42)
        !````
        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 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 :: 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.

        !other private routines:
        procedure :: name_equal
        procedure :: json_value_print
        procedure :: string_to_integer
        procedure :: string_to_double
        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

    end type json_core