Paths and Absolute Paths

Some zippers maintain can expose their focus position within the trie as a path. The following traits expose access to the path buffer in some way.

Zipper Relative Path

The path method in ZipperMoving returns the current path from the zipper's root to its focus as a byte slice. This represents the sequence of bytes traversed to reach the current focus position.

Note that this path is relative to the zipper's root, which may not be the same as the absolute path from the original data structure's root if the zipper was created with a prefix or from a subtrie.

ZipperAbsolutePath

The ZipperAbsolutePath trait provides methods to access a more complete path slice, including the origin_path, and may extend above the zipper's root.

Origin and Root Prefix Paths

The trait provides two key methods:

• origin_path returns the entire path from the zipper's origin to its current focus. The origin depends on how the zipper was created - for zippers created directly from a PathMap, this starts at the map's root.

• root_prefix_path returns the path from the zipper's origin to the zipper's root. This value remains constant throughout the zipper's life and is unaffected by the focus position.

The relationship between these paths is: origin_path() == root_prefix_path() + path().

After calling reset to return to the zipper's root, root_prefix_path() equals origin_path().

ZipperPathBuffer

The ZipperPathBuffer trait provides low-level control over the zipper's internal path buffer management. This trait is primarily used for performance optimization.

Buffer Management

The trait offers methods for direct buffer manipulation:

• prepare_buffers ensures the path buffer is allocated to facilitate zipper movement. Normally buffer allocation is done lazily.
• reserve_buffers grows the internal buffers to accommodate larger paths and deeper node stacks, but never shrinks them.
• origin_path_assert_len provides unsafe access to the path buffer beyond its current length.

The buffer management is designed to minimize allocations during zipper operations by pre-allocating the buffers for expected path lengths and traversal depths, so that the buffer can be sized once, instead of incurring multiple reallocs.