Documents

The example parses the people document in your selected format. It then reads Ada's age through the document nodes. Typed reads give you these values without serializing the document.

Example

Read Ada's age

people_text holds this document:

TRON

449 B

Offset (hex)	Bytes (hex)	Meaning
000	54 52 4F 4E	magic TRON
004	3C 616765	txt "age"
008	02 24000000000000 00	i64 36
011	0F 0A 04000000 0800 0000	map leaf, size 10: @4 → @8
01B	4C 726F6C65	txt "role"
020	8C 656E67696E6565 72	txt "engineer"
029	0F 0A 1B000000 2000 0000	map leaf, size 10: @1B → @20
033	4C 6E616D65	txt "name"
038	3C 416461	txt "Ada"
03C	0F 0A 33000000 3800 0000	map leaf, size 10: @33 → @38
046	07 12 00910000 1100 0000 29000000 3C00 0000	map branch, size 18, depth 0 (root), slots 8, 12, 15: @11 → @29 → @3C
058	5C 236C696E6B	txt "#link"
05E	5C 235F616461	txt "#_ada"
064	0F 0A 58000000 5E00 0000	map leaf, size 10: @58 → @5E
06E	3C 616765	txt "age"
072	02 29000000000000 00	i64 41
07B	0F 0A 6E000000 7200 0000	map leaf, size 10: @6E → @72
085	6C 6D656E746F72	txt "mentor"
08C	0F 0A 85000000 6400 0000	map leaf, size 10: @85 → @64
096	4C 726F6C65	txt "role"
09B	8C 656E67696E6565 72	txt "engineer"
0A4	0F 0A 96000000 9B00 0000	map leaf, size 10: @96 → @9B
0AE	4C 6E616D65	txt "name"
0B3	3C 426F62	txt "Bob"
0B7	0F 0A AE000000 B300 0000	map leaf, size 10: @AE → @B3
0C1	07 16 00990000 7B00 0000 8C000000 A400 0000 B7000000	map branch, size 22, depth 0 (root), slots 8, 11, 12, 15: @7B → @8C → @A4 → @B7
0D7	3C 616765	txt "age"
0DB	02 1D000000000000 00	i64 29
0E4	0F 0A D7000000 DB00 0000	map leaf, size 10: @D7 → @DB
0EE	4C 726F6C65	txt "role"
0F3	8C 64657369676E65 72	txt "designer"
0FC	0F 0A EE000000 F300 0000	map leaf, size 10: @EE → @F3
106	4C 6E616D65	txt "name"
10B	2C 4379	txt "Cy"
10E	0F 0A 06010000 0B01 0000	map leaf, size 10: @106 → @10B
118	07 12 00910000 E400 0000 FC000000 0E01 0000	map branch, size 18, depth 0 (root), slots 8, 12, 15: @E4 → @FC → @10E
12A	6C 617574686F72	txt "author"
131	5C 736D6F6B65	txt "smoke"
137	0F 0A 2A010000 3101 0000	map leaf, size 10: @12A → @131
141	6C 726561736F6E	txt "reason"
148	4C 73656564	txt "seed"
14D	0F 0A 41010000 4801 0000	map leaf, size 10: @141 → @148
157	07 0E 40080000 3701 0000 4D010000	map branch, size 14, depth 0 (root), slots 6, 11: @137 → @14D
165	4C 235F7478	txt "#_tx"
16A	0F 0A 65010000 5701 0000	map leaf, size 10: @165 → @157
174	4C 235F6379	txt "#_cy"
179	0F 0A 74010000 1801 0000	map leaf, size 10: @174 → @118
183	5C 235F626F62	txt "#_bob"
189	0F 0A 83010000 C100 0000	map leaf, size 10: @183 → @C1
193	5C 235F616461	txt "#_ada"
199	0F 0A 93010000 4600 0000	map leaf, size 10: @193 → @46
1A3	07 16 88210000 6A01 0000 79010000 8901 0000 99010000	map branch, size 22, depth 0 (root), slots 3, 7, 8, 13: @16A → @179 → @189 → @199
1B9	A3010000 00000000	root → @1A3; previous: none

odin

280 B

people := stardust.parse(people_text, .TRON) or_return
defer stardust.close(&people)

root := stardust.root(people) or_return
ada := stardust.member(people, root, "#_ada") or_return
age := stardust.member(people, ada, "age") or_return
result := stardust.i64(people, age) or_return

TRON

21 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	02 24000000000000 00	i64 36
0D	04000000 00000000	root → @4; previous: none

Numbers

A document number is an i64 integer or a finite f64 value. The number type defines both.

An integer read requires an integer node. A floating-point node can cause the read to fail.
Choose the typed read that matches the node that you read.

Operations

Operation	Returns	Summary
parse	document	parse(text, format) returns an owned document.
root	node	document.root() returns the root node ID.
count	count	document.count() returns the number of nodes.
read	node_view	document.read(id) returns a node view: kind, boolean, parent, position, first_child, next_sibling, key and text.
read_many	node_views	document.read_many(start, capacity) reads consecutive node views.
member	node	document.member(id, key) returns the first matching object member ID.
child_iterator	node_views	document.children(id) iterates the node views of a node's children in order.
members	Unavailable	document.members(id) iterates the members of an object node in order, each with its key.
i64	integer	Read an exact signed integer.
f64	real	Read a finite floating-point number.
close	none	Release the document handle.

parse

odin

114 B

parse :: proc(
	text: string,
	format: Source_Format,
	allocator := context.allocator,
) -> (
	Document,
	Error,
)

Parameters

Parameter	Type	Ownership	Default	Meaning
`text`	`string`	Value	Required	Encoded input bytes in the selected format. TRON is binary.
`format`	`Source_Format`	Value	Required	The codec to use for this operation.
`allocator`	`mem.Allocator`	Value	context.allocator	Allocator for copied return values and diagnostics. The caller releases them with the same allocator.

Errors

Status	When
`.Invalid_JSON`	JSON text is malformed
`.Invalid_Argument`	the text is malformed, the format is unknown or a number is outside `i64` or finite `f64`
`.Out_Of_Memory`	native memory is exhausted

Examples

Parse the shared DUST expression fixture

expression_text holds these bytes:

text

278 B

// One expression built once and evaluated against several inputs. The
// evaluate examples load this file, build `expression`, evaluate it with each
// of `inputs` in order and compare each result with `expected`.
expression [+ ?x 1]
inputs     [{x 1} {x 41}]
expected   [2 42]

odin

88 B

result := stardust.parse(expression_text, .DUST) or_return
defer stardust.close(&result)

TRON

466 B

Offset (hex)	Bytes (hex)	Meaning
000	54 52 4F 4E	magic TRON
004	1C 2B	txt "+"
006	2C 3F78	txt "?x"
009	02 01000000000000 00	i64 1
012	0E 15 00 0700 030000 00 04000000 060000 00 09000000	array leaf, size 21, shift 0, bitmap 0007, count 3 (root): @4 → @6 → @9
027	1C 78	txt "x"
029	02 01000000000000 00	i64 1
032	0F 0A 27000000 2900 0000	map leaf, size 10: @27 → @29
03C	1C 78	txt "x"
03E	02 29000000000000 00	i64 41
047	0F 0A 3C000000 3E00 0000	map leaf, size 10: @3C → @3E
051	0E 11 00 0300 020000 00 32000000 470000 00	array leaf, size 17, shift 0, bitmap 0003, count 2 (root): @32 → @47
062	02 02000000000000 00	i64 2
06B	02 2A000000000000 00	i64 42
074	0E 11 00 0300 020000 00 62000000 6B0000 00	array leaf, size 17, shift 0, bitmap 0003, count 2 (root): @62 → @6B
085	8C 24636F6D6D656E 74	txt "$comment"
08E	14 CD 4F6E65206578 7072657373696F6E 206275696C74206F 6E636520616E6420 6576616C75617465 6420616761696E73 7420736576657261 6C20696E70757473 2E205468650A6576 616C756174652065 78616D706C657320 6C6F616420746869 732066696C652C20 6275696C64206065 787072657373696F 6E602C206576616C 7561746520697420 7769746820656163 680A6F662060696E 707574736020696E 206F726465722061 6E6420636F6D7061 7265206561636820 726573756C742077 6974682060657870 6563746564602E	txt "One expression built onc…"
15D	0F 0A 85000000 8E00 0000	map leaf, size 10: @85 → @8E
167	6C 696E70757473	txt "inputs"
16E	0F 0A 67010000 5100 0000	map leaf, size 10: @167 → @51
178	8C 65787065637465 64	txt "expected"
181	0F 0A 78010000 7400 0000	map leaf, size 10: @178 → @74
18B	07 0E 02010000 6E01 0000 81010000	map branch, size 14, depth 2, slots 1, 8: @16E → @181
199	07 0A 01000000 8B01 0000	map branch, size 10, depth 1, slots 0: @18B
1A3	AC 65787072657373 696F6E	txt "expression"
1AE	0F 0A A3010000 1200 0000	map leaf, size 10: @1A3 → @12
1B8	07 12 40090000 5D01 0000 99010000 AE01 0000	map branch, size 18, depth 0 (root), slots 6, 8, 11: @15D → @199 → @1AE
1CA	B8010000 00000000	root → @1B8; previous: none

Report a malformed byte at offset zero

malformed holds these bytes:

text

1 B

odin

110 B

failed, result := stardust.parse(malformed, .DUST)
defer stardust.close(&failed)
defer stardust.close(&result)

TRON

242 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	6C 737461747573	txt "status"
0B	14 10 696E76616C69 645F617267756D65 6E74	txt "invalid_argument"
1D	0F 0A 04000000 0B00 0000	map leaf, size 10: @4 → @B
27	6C 656E74697479	txt "entity"
2E	00	nil
2F	0F 0A 27000000 2E00 0000	map leaf, size 10: @27 → @2E
39	7C 6D657373616765	txt "message"
41	14 1A 496E76616C69 645F53796E746178 206174206F666673 65742030	txt "Invalid_Syntax at offset…"
5D	0F 0A 39000000 4100 0000	map leaf, size 10: @39 → @41
67	07 0E 08020000 2F00 0000 5D000000	map branch, size 14, depth 1, slots 3, 9: @2F → @5D
75	4C 70617468	txt "path"
7A	00	nil
7B	0F 0A 75000000 7A00 0000	map leaf, size 10: @75 → @7A
85	5C 6669656C64	txt "field"
8B	00	nil
8C	0F 0A 85000000 8B00 0000	map leaf, size 10: @85 → @8B
96	4C 636F6465	txt "code"
9B	CC 696E76616C6964 5F64757374	txt "invalid_dust"
A8	0F 0A 96000000 9B00 0000	map leaf, size 10: @96 → @9B
B2	6C 6F6666736574	txt "offset"
B9	02 00000000000000 00	i64 0
C2	0F 0A B2000000 B900 0000	map leaf, size 10: @B2 → @B9
CC	07 1E 51620000 1D00 0000 67000000 7B00 0000 8C000000 A800 0000 C2000000	map branch, size 30, depth 0 (root), slots 0, 4, 6, 9, 13, 14: @1D → @67 → @7B → @8C → @A8 → @C2
EA	CC000000 00000000	root → @CC; previous: none

Report malformed DUST

malformed holds these bytes:

text

1 B

odin

110 B

failed, result := stardust.parse(malformed, .DUST)
defer stardust.close(&failed)
defer stardust.close(&result)

TRON

242 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	6C 737461747573	txt "status"
0B	14 10 696E76616C69 645F617267756D65 6E74	txt "invalid_argument"
1D	0F 0A 04000000 0B00 0000	map leaf, size 10: @4 → @B
27	6C 656E74697479	txt "entity"
2E	00	nil
2F	0F 0A 27000000 2E00 0000	map leaf, size 10: @27 → @2E
39	7C 6D657373616765	txt "message"
41	14 1A 556E65787065 637465645F456E64 206174206F666673 65742032	txt "Unexpected_End at offset…"
5D	0F 0A 39000000 4100 0000	map leaf, size 10: @39 → @41
67	07 0E 08020000 2F00 0000 5D000000	map branch, size 14, depth 1, slots 3, 9: @2F → @5D
75	4C 70617468	txt "path"
7A	00	nil
7B	0F 0A 75000000 7A00 0000	map leaf, size 10: @75 → @7A
85	5C 6669656C64	txt "field"
8B	00	nil
8C	0F 0A 85000000 8B00 0000	map leaf, size 10: @85 → @8B
96	4C 636F6465	txt "code"
9B	CC 696E76616C6964 5F64757374	txt "invalid_dust"
A8	0F 0A 96000000 9B00 0000	map leaf, size 10: @96 → @9B
B2	6C 6F6666736574	txt "offset"
B9	02 02000000000000 00	i64 2
C2	0F 0A B2000000 B900 0000	map leaf, size 10: @B2 → @B9
CC	07 1E 51620000 1D00 0000 67000000 7B00 0000 8C000000 A800 0000 C2000000	map branch, size 30, depth 0 (root), slots 0, 4, 6, 9, 13, 14: @1D → @67 → @7B → @8C → @A8 → @C2
EA	CC000000 00000000	root → @CC; previous: none

C exports: stardust_parse, stardust_document_error

Status	When
`.Closed`	the document is closed

Status	When
`.Closed`	the document is closed

read

odin

63 B

read :: proc(document: Document, id: u32) -> (Node_View, Error)

Parameters

Parameter	Type	Ownership	Default	Meaning
`document`	`Document`	Borrowed for the call	Required	The document owner for this operation. Keep it alive during the call.
`id`	`u32`	Value	Required	A node ID within the receiver document.

Errors

Status	When
`.Invalid_Argument`	id is not a node of the document
`.Closed`	the document is closed

Notes

Text contains string values. Read numbers with i64 or f64.

Examples

document/read

input_text holds this document:

TRON

33 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	1C 78	txt "x"
06	02 29000000000000 00	i64 41
0F	0F 0A 04000000 0600 0000	map leaf, size 10: @4 → @6
19	0F000000 00000000	root → @F; previous: none

odin

172 B

source := stardust.parse(input_text, .TRON) or_return
defer stardust.close(&source)

root := stardust.root(source) or_return
result := stardust.read(source, root) or_return

TRON

233 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	3C 6B6579	txt "key"
08	0C	txt ""
09	0F 0A 04000000 0800 0000	map leaf, size 10: @4 → @8
13	4C 6B696E64	txt "kind"
18	6C 6F626A656374	txt "object"
1F	0F 0A 13000000 1800 0000	map leaf, size 10: @13 → @18
29	BC 66697273745F63 68696C64	txt "first_child"
35	02 01000000000000 00	i64 1
3E	0F 0A 29000000 3500 0000	map leaf, size 10: @29 → @35
48	8C 706F736974696F 6E	txt "position"
51	02 00000000000000 00	i64 0
5A	0F 0A 48000000 5100 0000	map leaf, size 10: @48 → @51
64	07 0E 00810000 3E00 0000 5A000000	map branch, size 14, depth 1, slots 8, 15: @3E → @5A
72	6C 706172656E74	txt "parent"
79	00	nil
7A	0F 0A 72000000 7900 0000	map leaf, size 10: @72 → @79
84	4C 74657874	txt "text"
89	0C	txt ""
8A	0F 0A 84000000 8900 0000	map leaf, size 10: @84 → @89
94	7C 626F6F6C65616E	txt "boolean"
9C	01	bit false
9D	0F 0A 94000000 9C00 0000	map leaf, size 10: @94 → @9C
A7	CC 6E6578745F7369 626C696E67	txt "next_sibling"
B4	00	nil
B5	0F 0A A7000000 B400 0000	map leaf, size 10: @A7 → @B4
BF	07 22 A1990000 0900 0000 1F000000 6400 0000 7A000000 8A00 0000 9D000000 B500 0000	map branch, size 34, depth 0 (root), slots 0, 5, 7, 8, 11, 12, 15: @9 → @1F → @64 → @7A → @8A → @9D → @B5
E1	BF000000 00000000	root → @BF; previous: none

C exports: stardust_document_read_many

read_many

odin

86 B

read_many :: proc(document: Document, start: u32, output: []Node_View) -> (int, Error)

Parameters

Parameter	Type	Ownership	Default	Meaning
`document`	`Document`	Borrowed for the call	Required	The document owner for this operation. Keep it alive during the call.
`start`	`u32`	Value	Required	The first node ID of the consecutive read.
`output`	`[]Node_View`	Value	Required	The maximum number of node views to read. For output slices, the call uses the caller's slice length.

Errors

Status	When
`.Invalid_Argument`	start is past the last node or capacity is negative
`.Closed`	the document is closed

Examples

document/read_many

input_text holds this document:

TRON

33 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	1C 78	txt "x"
06	02 29000000000000 00	i64 41
0F	0F 0A 04000000 0600 0000	map leaf, size 10: @4 → @6
19	0F000000 00000000	root → @F; previous: none

odin

229 B

source := stardust.parse(input_text, .TRON) or_return
defer stardust.close(&source)

root := stardust.root(source) or_return
views: [1]stardust.Node_View
_ = stardust.read_many(source, root, views[:]) or_return
result := views[0]

TRON

233 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	3C 6B6579	txt "key"
08	0C	txt ""
09	0F 0A 04000000 0800 0000	map leaf, size 10: @4 → @8
13	4C 6B696E64	txt "kind"
18	6C 6F626A656374	txt "object"
1F	0F 0A 13000000 1800 0000	map leaf, size 10: @13 → @18
29	BC 66697273745F63 68696C64	txt "first_child"
35	02 01000000000000 00	i64 1
3E	0F 0A 29000000 3500 0000	map leaf, size 10: @29 → @35
48	8C 706F736974696F 6E	txt "position"
51	02 00000000000000 00	i64 0
5A	0F 0A 48000000 5100 0000	map leaf, size 10: @48 → @51
64	07 0E 00810000 3E00 0000 5A000000	map branch, size 14, depth 1, slots 8, 15: @3E → @5A
72	6C 706172656E74	txt "parent"
79	00	nil
7A	0F 0A 72000000 7900 0000	map leaf, size 10: @72 → @79
84	4C 74657874	txt "text"
89	0C	txt ""
8A	0F 0A 84000000 8900 0000	map leaf, size 10: @84 → @89
94	7C 626F6F6C65616E	txt "boolean"
9C	01	bit false
9D	0F 0A 94000000 9C00 0000	map leaf, size 10: @94 → @9C
A7	CC 6E6578745F7369 626C696E67	txt "next_sibling"
B4	00	nil
B5	0F 0A A7000000 B400 0000	map leaf, size 10: @A7 → @B4
BF	07 22 A1990000 0900 0000 1F000000 6400 0000 7A000000 8A00 0000 9D000000 B500 0000	map branch, size 34, depth 0 (root), slots 0, 5, 7, 8, 11, 12, 15: @9 → @1F → @64 → @7A → @8A → @9D → @B5
E1	BF000000 00000000	root → @BF; previous: none

C exports: stardust_document_read_many

Status	When
`.Not_Found`	the object has no member with the key
`.Invalid_Argument`	id is not an object node of the document
`.Closed`	the document is closed

child_iterator

odin

64 B

child_iterator :: proc(doc: Document, id: u32) -> Child_Iterator

Parameters

Parameter	Type	Ownership	Default	Meaning
`doc`	`Document`	Borrowed for the call	Required	The document owner for this operation. Keep it alive during the call.
`id`	`u32`	Value	Required	A node ID within the receiver document.

Errors

Status	When
`.Invalid_Argument`	id is not a node of the document
`.Closed`	the document is closed

Notes

Keep the document open during iteration. A scalar has no children. A read failure is reported once and ends iteration.

Examples

Iterate the children of a node

seed_text holds this document:

TRON

449 B

Offset (hex)	Bytes (hex)	Meaning
000	54 52 4F 4E	magic TRON
004	3C 616765	txt "age"
008	02 24000000000000 00	i64 36
011	0F 0A 04000000 0800 0000	map leaf, size 10: @4 → @8
01B	4C 726F6C65	txt "role"
020	8C 656E67696E6565 72	txt "engineer"
029	0F 0A 1B000000 2000 0000	map leaf, size 10: @1B → @20
033	4C 6E616D65	txt "name"
038	3C 416461	txt "Ada"
03C	0F 0A 33000000 3800 0000	map leaf, size 10: @33 → @38
046	07 12 00910000 1100 0000 29000000 3C00 0000	map branch, size 18, depth 0 (root), slots 8, 12, 15: @11 → @29 → @3C
058	5C 236C696E6B	txt "#link"
05E	5C 235F616461	txt "#_ada"
064	0F 0A 58000000 5E00 0000	map leaf, size 10: @58 → @5E
06E	3C 616765	txt "age"
072	02 29000000000000 00	i64 41
07B	0F 0A 6E000000 7200 0000	map leaf, size 10: @6E → @72
085	6C 6D656E746F72	txt "mentor"
08C	0F 0A 85000000 6400 0000	map leaf, size 10: @85 → @64
096	4C 726F6C65	txt "role"
09B	8C 656E67696E6565 72	txt "engineer"
0A4	0F 0A 96000000 9B00 0000	map leaf, size 10: @96 → @9B
0AE	4C 6E616D65	txt "name"
0B3	3C 426F62	txt "Bob"
0B7	0F 0A AE000000 B300 0000	map leaf, size 10: @AE → @B3
0C1	07 16 00990000 7B00 0000 8C000000 A400 0000 B7000000	map branch, size 22, depth 0 (root), slots 8, 11, 12, 15: @7B → @8C → @A4 → @B7
0D7	3C 616765	txt "age"
0DB	02 1D000000000000 00	i64 29
0E4	0F 0A D7000000 DB00 0000	map leaf, size 10: @D7 → @DB
0EE	4C 726F6C65	txt "role"
0F3	8C 64657369676E65 72	txt "designer"
0FC	0F 0A EE000000 F300 0000	map leaf, size 10: @EE → @F3
106	4C 6E616D65	txt "name"
10B	2C 4379	txt "Cy"
10E	0F 0A 06010000 0B01 0000	map leaf, size 10: @106 → @10B
118	07 12 00910000 E400 0000 FC000000 0E01 0000	map branch, size 18, depth 0 (root), slots 8, 12, 15: @E4 → @FC → @10E
12A	6C 617574686F72	txt "author"
131	5C 736D6F6B65	txt "smoke"
137	0F 0A 2A010000 3101 0000	map leaf, size 10: @12A → @131
141	6C 726561736F6E	txt "reason"
148	4C 73656564	txt "seed"
14D	0F 0A 41010000 4801 0000	map leaf, size 10: @141 → @148
157	07 0E 40080000 3701 0000 4D010000	map branch, size 14, depth 0 (root), slots 6, 11: @137 → @14D
165	4C 235F7478	txt "#_tx"
16A	0F 0A 65010000 5701 0000	map leaf, size 10: @165 → @157
174	4C 235F6379	txt "#_cy"
179	0F 0A 74010000 1801 0000	map leaf, size 10: @174 → @118
183	5C 235F626F62	txt "#_bob"
189	0F 0A 83010000 C100 0000	map leaf, size 10: @183 → @C1
193	5C 235F616461	txt "#_ada"
199	0F 0A 93010000 4600 0000	map leaf, size 10: @193 → @46
1A3	07 16 88210000 6A01 0000 79010000 8901 0000 99010000	map branch, size 22, depth 0 (root), slots 3, 7, 8, 13: @16A → @179 → @189 → @199
1B9	A3010000 00000000	root → @1A3; previous: none

odin

291 B

seed := stardust.parse(seed_text, .TRON) or_return
defer stardust.close(&seed)

root := stardust.root(seed) or_return
it := stardust.child_iterator(seed, root)
result: i64 = 0
for view in stardust.iterate_children(&it) {
	if len(view.key) > 0 {result += 1}
}
if it.err != nil {return it.err}

TRON

21 B

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	02 04000000000000 00	i64 4
0D	04000000 00000000	root → @4; previous: none

C exports: stardust_document_read_many

members

child_iterator views carry each member key. Odin has no separate members iterator.

C exports: stardust_document_read_many

Status	When
`.Invalid_Argument`	the node is not an integer number
`.Closed`	the document is closed

Status	When
`.Invalid_Argument`	the node is not a number or its value overflows `f64`
`.Closed`	the document is closed

Parameter	Type	Ownership	Default	Meaning
`document`	`^Document`	Consumed owner	Required	The document owner to release. Do not use it after this call.

node_view

This record contains the result of read and read_many. The key and text fields borrow the document until it closes.

Field	Type	Unit	Absent	Meaning
`kind`	`Value_Kind`	None	—	—
`boolean`	`bool`	None	—	True only for true.
`parent`	`u32`	None	NO_NODE	—
`position`	`u32`	Count	—	Index within the parent container.
`first_child`	`u32`	None	NO_NODE	—
`next_sibling`	`u32`	None	NO_NODE	—
`key`	`string`	None	—	Member key of an object member, else empty.
`text`	`string`	None	—	Value of a string, else empty. It can contain NUL.

This record supplies a node for add and add_many. The number field holds a typed i64 or f64 value. Go uses I64/F64, Rust and Odin use Number, Clojure uses long or double, and Python uses int or float. This value sets the ABI number kind and the integer or real field.

Field	Type	Absent	Meaning
`parent`	`u32`	NO_NODE	—
`kind`	`Value_Kind`	—	—
`boolean`	`bool`	—	Value of a boolean node.
`number`	`Number`	nil	Value of a number node.
`key`	`string`	—	Member key when the parent is an object.
`text`	`string`	—	Value of a string node.

Offset (hex)	Bytes (hex)	Meaning
00	54 52 4F 4E	magic TRON
04	03 000000000000F0 3F	f64 1
0D	04000000 00000000	root → @4; previous: none