Struct JsonPointer 

pub struct JsonPointer { /* private fields */ }

Represents a JSON pointer.

Implementations

impl JsonPointer

pub fn add(&self, target: &Value, value: &Value) -> Option<Value>

Add a value to a JSON object or array at the location specified by the JSON pointer.

let data = r#"
   [
       "string",
       {"test": "test"},
       ["string"]
   ]"#;
let array = Value::from_str(data)?.as_array().unwrap();

assert_eq!(array.insert_string(0, "string2").ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/0")
       .ok()
       .and_then(|p| {
           p.add(&Value::Array(array.clone()), &Value::String("string2".to_string()))
       }));
assert_eq!(None,
   JsonPointer::from_str("/4")
       .ok()
       .and_then(|p| {
           p.add(&Value::Array(array.clone()), &Value::String("string2".to_string()))
       }));
assert_eq!(array.insert_integer(3, 0).ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/-")
       .ok()
       .and_then(|p| p.add(&Value::Array(array.clone()), &Value::Number(Integer(0)))));
assert_eq!(array.set_object(
       1,
       &Object::new().add_string("test", "test").add_string("test2", "test2")
   ).ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/1/test2")
       .ok()
       .and_then(|p| {
           p.add(&Value::Array(array.clone()), &Value::String("test2".to_string()))
       }));

pub fn add_array(pointer: &str, target: &Value, value: &Array) -> Option<Value>

Add a JSON array to a JSON object or array at the location specified by the JSON pointer.

pub fn add_bool(pointer: &str, target: &Value, value: bool) -> Option<Value>

Add a Boolean value to a JSON object or array at the location specified by the JSON pointer.

pub fn add_decimal(pointer: &str, target: &Value, value: f64) -> Option<Value>

Add a decimal value to a JSON object or array at the location specified by the JSON pointer.

pub fn add_integer(pointer: &str, target: &Value, value: i128) -> Option<Value>

Add an integer value to a JSON object or array at the location specified by the JSON pointer.

pub fn add_number(pointer: &str, target: &Value, value: Number) -> Option<Value>

Add a number to a JSON object or array at the location specified by the JSON pointer.

pub fn add_object( pointer: &str, target: &Value, value: &Object, ) -> Option<Value>

Add a JSON object to a JSON object or array at the location specified by the JSON pointer.

pub fn add_string(pointer: &str, target: &Value, value: &str) -> Option<Value>

Add a string value to a JSON object or array at the location specified by the JSON pointer.

pub fn array_index(&self) -> Option<usize>

If the pointer refers to a value in an array, the index within the array is returned.

pub fn child(&self, segment: &str) -> Self

Returns a JSON pointer with an extra path segment.

pub fn get(&self, target: &Value) -> Option<Value>

Get a value from a JSON object or array through a JSON pointer.

let data = r#"
   {
       "string": "string",
       "int": 43,
       "float": 5.8,
       "boolean": true,
       "object": {"test": "test"},
       "array": [
           "string",
           1,
           3.0,
           false,
           {"test": "test"},
           [1]
       ],
       "es/cape": true
   }"#;
let object = Value::from_str(data)?;

assert_eq!(Some(Value::String("string".to_string())),
   JsonPointer::from_str("/string").ok().and_then(|p| p.get(&object)));
assert_eq!(Some(Value::String("test".to_string())),
   JsonPointer::from_str("/object/test").ok().and_then(|p| p.get(&object)));
assert_eq!(None, JsonPointer::from_str("/object/test2").ok().and_then(|p| p.get(&object)));
assert_eq!(None, JsonPointer::from_str("/object2/test").ok().and_then(|p| p.get(&object)));
assert_eq!(Some(Value::String("test".to_string())),
   JsonPointer::from_str("/array/4/test").ok().and_then(|p| p.get(&object)));
assert_eq!(None, JsonPointer::from_str("/array/3/test").ok().and_then(|p| p.get(&object)));
assert_eq!(None, JsonPointer::from_str("/array2/4/test").ok().and_then(|p| p.get(&object)));
assert_eq!(Some(Value::Bool(true)),
   JsonPointer::from_str("/es~1cape").ok().and_then(|p| p.get(&object)));
assert_eq!(Some(object.clone()), JsonPointer::from_str("/").ok().and_then(|p| p.get(&object)));

pub fn get_array(pointer: &str, target: &Value) -> Option<Array>

Get a value from a JSON object or array through a JSON pointer if it is an array. Otherwise, None is returned.

pub fn get_bool(pointer: &str, target: &Value) -> Option<bool>

Get a value from a JSON object or array through a JSON pointer if it is a Boolean. Otherwise, None is returned.

pub fn get_decimal(pointer: &str, target: &Value) -> Option<f64>

Get a value from a JSON object or array through a JSON pointer if it is a decimal. Otherwise, None is returned.

pub fn get_integer(pointer: &str, target: &Value) -> Option<i128>

Get a value from a JSON object or array through a JSON pointer if it is an integer. Otherwise, None is returned.

pub fn get_number(pointer: &str, target: &Value) -> Option<Number>

Get a value from a JSON object or array through a JSON pointer if it is a number. Otherwise, None is returned.

pub fn get_object(pointer: &str, target: &Value) -> Option<Object>

Get a value from a JSON object or array through a JSON pointer if it is an object. Otherwise, None is returned.

pub fn get_string(pointer: &str, target: &Value) -> Option<String>

Get a value from a JSON object or array through a JSON pointer if it is a string. Otherwise, None is returned.

pub fn new() -> Self

Creates a JSON pointer that refers to the root.

pub fn parent(&self) -> Self

Returns a JSON pointer that refers to the parent.

pub fn remove(&self, target: &Value) -> Option<Value>

Remove a value in a JSON object or array at the location specified by the JSON pointer.

let data = r#"
   [
       "string",
       {"test": "test", "test2": "test2"},
       ["string"]
   ]"#;
let array = Value::from_str(data)?.as_array().unwrap();

assert_eq!(array.remove(0).ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/0")
       .ok()
       .and_then(|p| p.remove(&Value::Array(array.clone()))));
assert_eq!(None,
   JsonPointer::from_str("/4")
       .ok()
       .and_then(|p| p.remove(&Value::Array(array.clone()))));
assert_eq!(array.set_object(1, &Object::new().add_string("test", "test"))
       .ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/1/test2")
       .ok()
       .and_then(|p| p.remove(&Value::Array(array.clone()))));

pub fn set(&self, target: &Value, value: &Value) -> Option<Value>

Set a value in a JSON object or array at the location specified by the JSON pointer.

let data = r#"
   [
       "string",
       {"test": "test"},
       ["string"]
   ]"#;
let array = Value::from_str(data)?.as_array().unwrap();

assert_eq!(array.set_string(0, "string2").ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/0")
       .ok()
       .and_then(|p| {
           p.set(&Value::Array(array.clone()), &Value::String("string2".to_string()))
       }));
assert_eq!(None,
   JsonPointer::from_str("/4")
       .ok()
       .and_then(|p| {
           p.set(&Value::Array(array.clone()), &Value::String("string2".to_string()))
       }));
assert_eq!(array.set_object(1, &Object::new().add_string("test", "test2"))
       .ok().map(|a| Value::Array(a)),
   JsonPointer::from_str("/1/test")
       .ok()
       .and_then(|p| {
           p.set(&Value::Array(array.clone()), &Value::String("test2".to_string()))
       }));

pub fn set_array(pointer: &str, target: &Value, value: &Array) -> Option<Value>

Set an array in a JSON object or array at the location specified by the JSON pointer.

pub fn set_bool(pointer: &str, target: &Value, value: bool) -> Option<Value>

Set a Boolean value in a JSON object or array at the location specified by the JSON pointer.

pub fn set_decimal(pointer: &str, target: &Value, value: f64) -> Option<Value>

Set a decimal value in a JSON object or array at the location specified by the JSON pointer.

pub fn set_integer(pointer: &str, target: &Value, value: i128) -> Option<Value>

Set an integer value in a JSON object or array at the location specified by the JSON pointer.

pub fn set_number(pointer: &str, target: &Value, value: Number) -> Option<Value>

Set a number in a JSON object or array at the location specified by the JSON pointer.

pub fn set_object( pointer: &str, target: &Value, value: &Object, ) -> Option<Value>

Set a JSON object in a JSON object or array at the location specified by the JSON pointer.

pub fn set_string(pointer: &str, target: &Value, value: &str) -> Option<Value>

Set a string value in a JSON object or array at the location specified by the JSON pointer.

Trait Implementations

impl Clone for JsonPointer

fn clone(&self) -> JsonPointer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsonPointer

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

Formats the value using the given formatter.

impl Default for JsonPointer

fn default() -> Self

Returns the “default value” for a type.

impl Display for JsonPointer

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

Convert a JSON pointer to a string.

let p = "/a/b~1c/~0d";

assert_eq!(p, JsonPointer::from_str(p).unwrap().to_string())

impl FromStr for JsonPointer

fn from_str(s: &str) -> Result<Self, Self::Err>

Create a JSON pointer from a string.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for JsonPointer

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

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 Ord for JsonPointer

fn cmp(&self, other: &Self) -> Ordering

The comparison takes into account array indexes, which are compared numerically.

assert!(JsonPointer::from_str("/a").unwrap() == JsonPointer::from_str("/a").unwrap());
assert!(JsonPointer::from_str("/a/b").unwrap() < JsonPointer::from_str("/a/c").unwrap());
assert!(JsonPointer::from_str("/a/b/0").unwrap() < JsonPointer::from_str("/a/b/1").unwrap());
assert!(JsonPointer::from_str("/a/b/10").unwrap() > JsonPointer::from_str("/a/b/2").unwrap());
assert!(JsonPointer::from_str("/a/b/-").unwrap() > JsonPointer::from_str("/a/b/2").unwrap());
assert!(JsonPointer::from_str("/a/b/1").unwrap() < JsonPointer::from_str("/a/b/-").unwrap())

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for JsonPointer

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for JsonPointer

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for JsonPointer

impl StructuralPartialEq for JsonPointer