core/encoding/json package | Odin Programming Language

Encoding and decoding JSON in strict `JSON`, [[ JSON5 ; https://json5.org/ ]] and [[ BitSquid ; https://bitsquid.blogspot.com/2009/10/simplified-json-notation.html ]] variants. Using one of these `Specification`s. JSON strict JSON JSON5 pure superset of JSON and valid JavaScript https://json5.org/ * Object keys may be an ECMAScript 5.1 IdentifierName. * Objects may have a single trailing comma. * Arrays may have a single trailing comma. * Strings may be single quoted. * Strings may span multiple lines by escaping new line characters. * Strings may include character escapes * Numbers may be hexadecimal. * Numbers may have a leading or trailing decimal point. * Numbers may be IEEE 754 positive infinity, negative infinity, and NaN. * Numbers may begin with an explicit plus sign. * Single and multi-line comments are allowed. * Additional white space characters are allowed. MJSON pure superset of JSON5, may not be valid JavaScript https://bitsquid.blogspot.com/2009/10/simplified-json-notation.html * All the same features as JSON5 plus extras. * Assume an object definition at the root level (no need to surround entire file with { } ). * Commas are optional, using comma insertion rules with newlines. * Quotes around object keys are optional if the keys are valid identifiers. * : can be replaced with =

Collection Info

Collection: core
Path: encoding/json
Entries: 72

Source Files

Constants

1

DEFAULT_SPECIFICATION #

DEFAULT_SPECIFICATION :: Specification.JSON5

Types

25

Array #

Array :: distinct Array

Boolean #

Boolean :: bool

Error #

Error :: Error

Float #

Float :: f64

Integer #

Integer :: i64

Marshal_Data_Error #

Marshal_Data_Error :: Marshal_Data_Error

Marshal_Error #

Marshal_Error :: Marshal_Error

Marshal_Options #

Marshal_Options :: Marshal_Options

careful with MJSON maps & non quotes usage as keys with whitespace will lead to bad results

Null #

Null :: distinct Null

Object #

Object :: distinct Object

Parser #

Parser :: Parser

Pos #

Pos :: Pos

Register_User_Marshaler_Error #

Register_User_Marshaler_Error :: Register_User_Marshaler_Error

Register_User_Unmarshaler_Error #

Register_User_Unmarshaler_Error :: Register_User_Unmarshaler_Error

Specification #

Specification :: Specification

String #

String :: string

Token #

Token :: Token

Token_Kind #

Token_Kind :: Token_Kind

Tokenizer #

Tokenizer :: Tokenizer

Unmarshal_Data_Error #

Unmarshal_Data_Error :: Unmarshal_Data_Error

Unmarshal_Error #

Unmarshal_Error :: Unmarshal_Error

Unsupported_Type_Error #

Unsupported_Type_Error :: Unsupported_Type_Error

User_Marshaler #

User_Marshaler :: User_Marshaler

User_Unmarshaler #

User_Unmarshaler :: User_Unmarshaler

Value #

Value :: Value

Procedures

46

advance_token #

advance_token :: proc(p: ^Parser) -> (Token, Error) {…}

allow_token #

allow_token :: proc(p: ^Parser, kind: Token_Kind) -> bool {…}

clone_string #

clone_string :: proc(s: string, allocator: Allocator, loc := #caller_location) -> (str: string, err: Error) {…}

clone_value #

clone_value :: proc(value: Value, allocator := context.allocator) -> Value {…}

destroy_value #

destroy_value :: proc(value: Value, allocator := context.allocator, loc := #caller_location) {…}

expect_token #

expect_token :: proc(p: ^Parser, kind: Token_Kind) -> Error {…}

get_token #

get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {…}

is_valid #

is_valid :: proc(data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false) -> bool {…}

NOTE(bill): is_valid will not check for duplicate keys

is_valid_number #

is_valid_number :: proc(str: string, spec: Specification) -> bool {…}

is_valid_string_literal #

is_valid_string_literal :: proc(str: string, spec: Specification) -> bool {…}

make_parser #

make_parser :: proc(data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> Parser {…}

make_parser_from_string #

make_parser_from_string :: proc(data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> Parser {…}

make_tokenizer #

make_tokenizer :: proc(data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false) -> Tokenizer {…}

marshal #

marshal :: proc(v: any, opt: Marshal_Options = {}, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: Marshal_Error) {…}

marshal_to_builder #

marshal_to_builder :: proc(b: ^Builder, v: any, opt: ^Marshal_Options) -> Marshal_Error {…}

marshal_to_writer #

marshal_to_writer :: proc(w: Stream, v: any, opt: ^Marshal_Options) -> (err: Marshal_Error) {…}

next_rune #

next_rune :: proc(t: ^Tokenizer) -> rune {…}

opt_write_comment #

opt_write_comment :: proc(w: Stream, opt: ^Marshal_Options, comment: ^string) -> (err: Error) {…}

Newlines are split into multiple comment lines

opt_write_end #

opt_write_end :: proc(w: Stream, opt: ^Marshal_Options, c: u8) -> (err: Error) {…}

decrease indent, write spacing and insert end byte

opt_write_indentation #

opt_write_indentation :: proc(w: Stream, opt: ^Marshal_Options) -> (err: Error) {…}

writes current indentation level based on options

opt_write_iteration #

opt_write_iteration :: proc(w: Stream, opt: ^Marshal_Options, first_iteration: bool) -> (err: Error) {…}

insert comma separation and write indentations

opt_write_key #

opt_write_key :: proc(w: Stream, opt: ^Marshal_Options, name: string) -> (err: Error) {…}

write key as quoted string or with optional quotes in mjson

opt_write_start #

opt_write_start :: proc(w: Stream, opt: ^Marshal_Options, c: u8) -> (err: Error) {…}

insert start byte and increase indentation on pretty

parse #

parse :: proc(data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator, loc := #caller_location) -> (Value, Error) {…}

parse_array #

parse_array :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

parse_colon #

parse_colon :: proc(p: ^Parser) -> (err: Error) {…}

parse_comma #

parse_comma :: proc(p: ^Parser) -> (do_break: bool) {…}

parse_object #

parse_object :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

parse_object_body #

parse_object_body :: proc(p: ^Parser, end_token: Token_Kind, loc := #caller_location) -> (obj: Object, err: Error) {…}

parse_object_key #

parse_object_key :: proc(p: ^Parser, key_allocator: Allocator, loc := #caller_location) -> (key: string, err: Error) {…}

parse_string #

parse_string :: proc(data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator, loc := #caller_location) -> (Value, Error) {…}

parse_value #

parse_value :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

register_user_marshaler #

register_user_marshaler :: proc(id: typeid, marshaler: User_Marshaler) -> Register_User_Marshaler_Error {…}

Registers a user-defined marshaler for a specific typeid Inputs: - id: The typeid of the custom type. - formatter: The User_Marshaler function for the custom type. Returns: A Register_User_Marshaler_Error value indicating the success or failure of the operation. WARNING: set_user_marshalers must be called before using this procedure.

register_user_unmarshaler #

register_user_unmarshaler :: proc(id: typeid, unmarshaler: User_Unmarshaler) -> Register_User_Unmarshaler_Error {…}

Registers a user-defined unmarshaler for a specific `typeid`. WARNING: set_user_unmarshalers must be called before using this procedure. Inputs: - id: The `typeid` of the custom type. - unmarshaler: The `User_Unmarshaler` function for the custom type. Example: import "core:fmt" import "core:encoding/json" import "core:strconv" // Custom Unmarshaler for `int` some_unmarshaler :: proc(p: ^json.Parser, v: any) -> json.Unmarshal_Error { token := p.curr_token.text i, ok := strconv.parse_i64_of_base(token, 2) if !ok { return .Invalid_Data } (^int)(v.data)^ = int(i) json.advance_token(p) return nil } register_user_unmarshaler_example :: proc() { // Ensure the `json._user_unmarshalers` map is initialized. json.set_user_unmarshalers(new(map[typeid]json.User_Unmarshaler)) reg_err := json.register_user_unmarshaler(typeid_of(int), some_unmarshaler) assert(reg_err == .None) data := `{"value":101010}` SomeType :: struct { value: int, } y: SomeType unmarshal_err := json.unmarshal(transmute([]byte)data, &y) fmt.println(y, unmarshal_err) } Output: SomeType{value = 42} nil

set_user_marshalers #

set_user_marshalers :: proc(m: ^map[typeid]User_Marshaler) {…}

Sets user-defined marshalers for custom json marshaling of specific types Inputs: - m: A pointer to a map of typeids to User_Marshaler procs. NOTE: Must be called before using register_user_marshaler.

set_user_unmarshalers #

set_user_unmarshalers :: proc(m: ^map[typeid]User_Unmarshaler) {…}

Sets user-defined unmarshalers for custom json unmarshaling of specific types Inputs: - m: A pointer to a map of typeids to User_Unmarshaler procs. NOTE: Must be called before using `register_user_unmarshaler`.

token_end_pos #

token_end_pos :: proc(tok: Token) -> Pos {…}

unmarshal #

unmarshal :: proc(data: []u8, ptr: ^$T, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unmarshal_any #

unmarshal_any :: proc(data: []u8, v: any, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unmarshal_string #

unmarshal_string :: proc(data: string, ptr: ^$T, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unquote_string #

unquote_string :: proc(token: Token, spec: Specification, allocator := context.allocator, loc := #caller_location) -> (value: string, err: Error) {…}

IMPORTANT NOTE(bill): unquote_string assumes a mostly valid string

validate_array #

validate_array :: proc(p: ^Parser) -> bool {…}

validate_object #

validate_object :: proc(p: ^Parser) -> bool {…}

validate_object_body #

validate_object_body :: proc(p: ^Parser, end_token: Token_Kind) -> bool {…}

validate_object_key #

validate_object_key :: proc(p: ^Parser) -> bool {…}

validate_value #

validate_value :: proc(p: ^Parser) -> bool {…}