Struct tremor_value::KnownKey

pub struct KnownKey<'key> { /* fields omitted */ }

Well known key that can be looked up in a Value faster. It achives this by memorizing the hash.

Implementations

impl<'key> KnownKey<'key>

#[must_use]pub fn key(&self) -> &Cow<'key, str>

The known key

#[must_use]pub fn lookup<'target, 'value>(
    &self,
    target: &'target Value<'value>
) -> Option<&'target Value<'value>> where
    'key: 'value,
    'value: 'target, 

Looks up this key in a Value, returns None if the key wasn't present or target isn't an object

use tremor_value::*;
let object = json!({
  "answer": 42,
  "key": 7
}).into();
let known_key = KnownKey::from("answer");
assert_eq!(known_key.lookup(&object).unwrap(), &42);

pub fn lookup_mut<'target, 'value>(
    &self,
    target: &'target mut Value<'value>
) -> Option<&'target mut Value<'value>> where
    'key: 'value,
    'value: 'target, 

Looks up this key in a Value, returns None if the key wasn't present or target isn't an object

use tremor_value::*;
let mut object: Value = json!({
  "answer": 23,
  "key": 7
}).into();
let known_key = KnownKey::from("answer");

assert_eq!(object["answer"], 23);

if let Some(answer) = known_key.lookup_mut(&mut object) {
  *answer = Value::from(42);
}

assert_eq!(object["answer"], 42);

pub fn lookup_or_insert_mut<'target, 'value, F>(
    &self,
    target: &'target mut Value<'value>,
    with: F
) -> Result<&'target mut Value<'value>, Error> where
    'key: 'value,
    'value: 'target,
    F: FnOnce() -> Value<'value>, 

Looks up this key in a Value, inserts with when the key when wasn't present returns None if the target isn't an object

Errors

• if the value isn't an object

use tremor_value::*;
let mut object: Value = json!({
  "answer": 23,
  "key": 7
}).into();
let known_key = KnownKey::from("answer");

assert_eq!(object["answer"], 23);

if let Ok(answer) = known_key.lookup_or_insert_mut(&mut object, || 17.into()) {
  assert_eq!(*answer, 23);
  *answer = Value::from(42);
}

assert_eq!(object["answer"], 42);

let known_key2 = KnownKey::from("also the answer");
if let Ok(answer) = known_key2.lookup_or_insert_mut(&mut object, || 8.into()) {
  assert_eq!(*answer, 8);
  *answer = Value::from(42);
}

assert_eq!(object["also the answer"], 42);

pub fn insert<'target, 'value>(
    &self,
    target: &'target mut Value<'value>,
    value: Value<'value>
) -> Result<Option<Value<'value>>, Error> where
    'key: 'value,
    'value: 'target, 

Inserts a value key into Value, returns None if the key wasn't present otherwise Some(old value).

Errors

• if target isn't an object

use tremor_value::*;
let mut object: Value = json!({
  "answer": 23,
  "key": 7
}).into();
let known_key = KnownKey::from("answer");

assert_eq!(object["answer"], 23);

assert!(known_key.insert(&mut object, Value::from(42)).is_ok());

assert_eq!(object["answer"], 42);

let known_key2 = KnownKey::from("also the answer");

assert!(known_key2.insert(&mut object, Value::from(42)).is_ok());

assert_eq!(object["also the answer"], 42);

Trait Implementations

impl<'key> Clone for KnownKey<'key>

fn clone(&self) -> KnownKey<'key>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'key> Debug for KnownKey<'key>

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

Formats the value using the given formatter.

impl<'key, S> From<S> for KnownKey<'key> where
    Cow<'key, str>: From<S>, 

fn from(key: S) -> Self

Performs the conversion.

impl<'key> PartialEq<KnownKey<'key>> for KnownKey<'key>

fn eq(&self, other: &KnownKey<'key>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &KnownKey<'key>) -> bool

This method tests for !=.

impl<'key> StructuralPartialEq for KnownKey<'key>