encoding_json

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

Example User Marshaler: Custom Marshaler for int Some_Marshaler :: proc(w: io.Writer, v: any, opt: ^json.Marshal_Options) -> json.Marshal_Error {

io.write_string(w, fmt.tprintf("%b", v))
	return json.Marshal_Data_Error.None
}

main :: proc() {
	// Ensure the json._user_marshaler map is initialized
	json.set_user_marshalers(new(map[typeid]json.User_Marshaler))
	reg_err := json.register_user_marshaler(type_info_of(int).id, Some_Marshaler)
	assert(reg_err == .None)


	// Use the custom marshaler
	SomeType :: struct {
		value: int,
	}

	x := SomeType{42}
	data, marshal_err := json.marshal(x)
	assert(marshal_err == nil)
	defer delete(data)

	fmt.println("Custom output:", string(data)) // Custom output: {"value":101010}
}
NOTE(Jeroen): This is a pointer to prevent accidental additions
it is prefixed with `_` rather than marked with a private attribute so that users can access it if necessary

NOTE(Jeroen): This is a pointer to prevent accidental additions it is prefixed with _ rather than marked with a private attribute so that users can access it if necessary

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

Newlines are split into multiple comment lines

decrease indent, write spacing and insert end byte

writes current indentation level based on options

insert comma separation and write indentations

write key as quoted string or with optional quotes in mjson

insert start byte and increase indentation on pretty

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.

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

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.

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.

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