1 package unstable 2 3 import ( 4 "fmt" 5 "unsafe" 6 7 "github.com/pelletier/go-toml/v2/internal/danger" 8 ) 9 10 // Iterator over a sequence of nodes. 11 // 12 // Starts uninitialized, you need to call Next() first. 13 // 14 // For example: 15 // 16 // it := n.Children() 17 // for it.Next() { 18 // n := it.Node() 19 // // do something with n 20 // } 21 type Iterator struct { 22 started bool 23 node *Node 24 } 25 26 // Next moves the iterator forward and returns true if points to a 27 // node, false otherwise. 28 func (c *Iterator) Next() bool { 29 if !c.started { 30 c.started = true 31 } else if c.node.Valid() { 32 c.node = c.node.Next() 33 } 34 return c.node.Valid() 35 } 36 37 // IsLast returns true if the current node of the iterator is the last 38 // one. Subsequent calls to Next() will return false. 39 func (c *Iterator) IsLast() bool { 40 return c.node.next == 0 41 } 42 43 // Node returns a pointer to the node pointed at by the iterator. 44 func (c *Iterator) Node() *Node { 45 return c.node 46 } 47 48 // Node in a TOML expression AST. 49 // 50 // Depending on Kind, its sequence of children should be interpreted 51 // differently. 52 // 53 // - Array have one child per element in the array. 54 // - InlineTable have one child per key-value in the table (each of kind 55 // InlineTable). 56 // - KeyValue have at least two children. The first one is the value. The rest 57 // make a potentially dotted key. 58 // - Table and ArrayTable's children represent a dotted key (same as 59 // KeyValue, but without the first node being the value). 60 // 61 // When relevant, Raw describes the range of bytes this node is referring to in 62 // the input document. Use Parser.Raw() to retrieve the actual bytes. 63 type Node struct { 64 Kind Kind 65 Raw Range // Raw bytes from the input. 66 Data []byte // Node value (either allocated or referencing the input). 67 68 // References to other nodes, as offsets in the backing array 69 // from this node. References can go backward, so those can be 70 // negative. 71 next int // 0 if last element 72 child int // 0 if no child 73 } 74 75 // Range of bytes in the document. 76 type Range struct { 77 Offset uint32 78 Length uint32 79 } 80 81 // Next returns a pointer to the next node, or nil if there is no next node. 82 func (n *Node) Next() *Node { 83 if n.next == 0 { 84 return nil 85 } 86 ptr := unsafe.Pointer(n) 87 size := unsafe.Sizeof(Node{}) 88 return (*Node)(danger.Stride(ptr, size, n.next)) 89 } 90 91 // Child returns a pointer to the first child node of this node. Other children 92 // can be accessed calling Next on the first child. Returns an nil if this Node 93 // has no child. 94 func (n *Node) Child() *Node { 95 if n.child == 0 { 96 return nil 97 } 98 ptr := unsafe.Pointer(n) 99 size := unsafe.Sizeof(Node{}) 100 return (*Node)(danger.Stride(ptr, size, n.child)) 101 } 102 103 // Valid returns true if the node's kind is set (not to Invalid). 104 func (n *Node) Valid() bool { 105 return n != nil 106 } 107 108 // Key returns the children nodes making the Key on a supported node. Panics 109 // otherwise. They are guaranteed to be all be of the Kind Key. A simple key 110 // would return just one element. 111 func (n *Node) Key() Iterator { 112 switch n.Kind { 113 case KeyValue: 114 value := n.Child() 115 if !value.Valid() { 116 panic(fmt.Errorf("KeyValue should have at least two children")) 117 } 118 return Iterator{node: value.Next()} 119 case Table, ArrayTable: 120 return Iterator{node: n.Child()} 121 default: 122 panic(fmt.Errorf("Key() is not supported on a %s", n.Kind)) 123 } 124 } 125 126 // Value returns a pointer to the value node of a KeyValue. 127 // Guaranteed to be non-nil. Panics if not called on a KeyValue node, 128 // or if the Children are malformed. 129 func (n *Node) Value() *Node { 130 return n.Child() 131 } 132 133 // Children returns an iterator over a node's children. 134 func (n *Node) Children() Iterator { 135 return Iterator{node: n.Child()} 136 } 137