Struct Match 

pub struct Match<M> { /* private fields */ }

The Match filter

Implementations

impl<M> Match<M>

where M: Matchable,

pub fn new(key: &str) -> Self

Examples found in repository

example/match.rs (line 19)

fn main() {
    let json = json!({
        "Object": {
            "explanation": "test explanation",
            "activeRegionNum": 23
        },
        "2022-01-11": {
            "Object2": {
                "explanation": "none",
                "activeRegionNum": 98
            }
        }
    });
    let nums = filter::<Match<u64>>(json, &Match::new("activeRegionNum")).unwrap();
    assert_eq!(vec![23 as u64, 98 as u64], nums);
    dbg!(nums);
}

Trait Implementations

impl<M: Clone> Clone for Match<M>

fn clone(&self) -> Match<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Match<M>

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

Formats the value using the given formatter.

impl<'de, M> Deserialize<'de> for Match<M>

where M: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M> Filter for Match<M>

where M: Matchable,

type Output = Vec<M>

fn filter(&self, json: Value) -> Result<Self::Output, Error>

impl<M: PartialEq> PartialEq for Match<M>

fn eq(&self, other: &Match<M>) -> 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<M> Serialize for Match<M>

where M: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<M> StructuralPartialEq for Match<M>