Struct JsonPath 

pub struct JsonPath { /* private fields */ }

Type-safe JSON path for addressing nodes in JSON structures.

Represented as a sequence of PathSegments; the root path ($) is the empty sequence. Every constructor funnels object keys through the same validation rule (see validate_key), so a JsonPath can never contain a key that would make Display/FromStr ambiguous — see the invariant documented on JsonPath’s Display impl (JP-1).

Implementations

impl JsonPath

pub fn root() -> JsonPath

Create the root path ($), i.e. the empty segment sequence.

pub fn new(path: impl Into<String>) -> Result<JsonPath, DomainError>

Parse a JSON path from its textual form (e.g. "$.users[0].name").

Examples

use pjson_rs_domain::value_objects::JsonPath;

let path = JsonPath::new("$.users[0].name").unwrap();
assert_eq!(path.depth(), 3);
assert_eq!(path.to_string(), "$.users[0].name");

assert!(JsonPath::new("$.key[not_a_number]").is_err());

pub fn from_segments( segments: impl IntoIterator<Item = PathSegment>, ) -> Result<JsonPath, DomainError>

Build a path directly from segments, validating every PathSegment::Key with the same rule as JsonPath::append_key.

Examples

use pjson_rs_domain::value_objects::{JsonPath, PathSegment};

let path = JsonPath::from_segments(vec![
    PathSegment::Key("users".to_string()),
    PathSegment::Index(0),
])
.unwrap();
assert_eq!(path.to_string(), "$.users[0]");

// A key containing a delimiter is rejected, just like `append_key`.
let invalid = JsonPath::from_segments(vec![PathSegment::Key("a.b".to_string())]);
assert!(invalid.is_err());

pub fn append_key(&self, key: &str) -> Result<JsonPath, DomainError>

Append a key segment, producing a new path.

Examples

use pjson_rs_domain::value_objects::JsonPath;

let path = JsonPath::root().append_key("users").unwrap();
assert_eq!(path.to_string(), "$.users");

// Keys containing '.', '[', ']', or the empty key are rejected.
assert!(JsonPath::root().append_key("").is_err());
assert!(JsonPath::root().append_key("a.b").is_err());

pub fn append_index(&self, index: usize) -> JsonPath

Append an array index segment, producing a new path.

pub fn segments(&self) -> &[PathSegment]

Borrow the path’s segments.

pub fn depth(&self) -> usize

Number of segments in the path (0 for root).

pub fn parent(&self) -> Option<JsonPath>

Get the parent path, or None if this is the root.

O(1) on the segmented representation. This corrects a bug in the previous string-based implementation, which returned root for any path ending in an index segment following a key (e.g. $.users[0] incorrectly produced $ instead of $.users).

pub fn last_segment(&self) -> Option<&PathSegment>

Get the last segment of the path, or None at root.

Distinct from JsonPath::last_key: this returns the literal final segment, whether it is a key or an index.

pub fn last_key(&self) -> Option<&str>

Get the last Key segment, skipping any trailing Index segments.

Distinct from JsonPath::last_segment: for $.arr[5] this returns Some("arr"), not None. Preserves the WASM/HTTP priority-heuristic parity fixed in #242 — do not conflate the two methods.

pub fn is_prefix_of(&self, other: &JsonPath) -> bool

Check whether self is a strict prefix of other (self-prefix is false).

pub fn to_json_pointer(&self) -> String

Convert to a JSON Pointer (RFC 6901) string.

Does not escape ~ or / within keys; see follow-up issue for #379.

Examples

use pjson_rs_domain::value_objects::JsonPath;

let path = JsonPath::new("$.users[0].name").unwrap();
assert_eq!(path.to_json_pointer(), "/users/0/name");
assert_eq!(JsonPath::root().to_json_pointer(), "/");

Trait Implementations

impl Clone for JsonPath

fn clone(&self) -> JsonPath

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsonPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for JsonPath

fn deserialize<D>( deserializer: D, ) -> Result<JsonPath, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for JsonPath

INVARIANT (JP-1): Display is injective and total over representable JsonPath values. It holds only because key validation (validate_key) excludes ., [, ], and the empty key: those delimiters cannot occur inside a valid key, so the boundary between a key and the next segment marker is always unambiguous, and every rendered path re-parses via FromStr to the same segments. Any future change that widens the key alphabet to admit ., [, ], or the empty string must add an escaping grammar (e.g. bracket-quote form with backslash-escaping) and a round-trip proptest in the same change, or Display/FromStr become a path-forgery primitive (see issue #333).

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for JsonPath

impl FromStr for JsonPath

Parses the textual form produced by JsonPath’s Display impl. See the injectivity/totality invariant documented there (JP-1).

type Err = DomainError

The associated error which can be returned from parsing.

fn from_str(path: &str) -> Result<JsonPath, <JsonPath as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for JsonPath

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for JsonPath

fn eq(&self, other: &JsonPath) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for JsonPath

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for JsonPath