Struct Ignore 

pub struct Ignore { /* private fields */ }

Implementations

impl Ignore

pub fn new(keys: Vec<&str>) -> Self

Examples found in repository

example/ignore.rs (line 17)

fn main() {
    let json = json!(
        {
            "explanation": "test",
            "media_type": "test",
            "hdurl": "test",
            "service_version": "test",
            "code": 200,
            "msg": "test"
        }
    );
    let values = filter::<Ignore>(json, &Ignore::new(vec!["explanation", "media_type"]));
    if let Ok(trimmed) = values {
        println!("TRIMMED: {:#?}", trimmed);
        assert!(trimmed.get("explanation").is_none());
        assert!(trimmed.get("media_type").is_none());
        assert!(trimmed.get("hdurl").is_some());
    } else {
        panic!();
    }

    let json = json!({
        "2020-01-01": {
            "explanation": "test_1",
            "media_type": "test",
            "hdurl": "test",
            "service_version": "test",
            "code": 200,
            "msg": "test"
        },
        "Object": {
            "2023-01-11": {
                "Object": {
                    "explanation": "test_3",
                    "media_type": "test",
                    "hdurl": "test",
                    "service_version": "test",
                    "code": 200,
                    "msg": "test"
                },
                "explanation": "test_2",
            }
        },
        "explanation": "test_0"
    });

    let ignore = Ignore::new(vec!["explanation"]);
    let trimmed = filter::<Ignore>(json, &ignore).unwrap();
    println!("TRIMMED: {:#?}", trimmed);
    assert!(trimmed["2020-01-01"].get("explanation").is_none(), "test_1");
    assert!(
        trimmed["Object"]["2023-01-11"]["Object"]
            .get("explanation")
            .is_none(),
        "test_3"
    );
    assert!(
        trimmed["Object"]["2023-01-11"].get("explanation").is_none(),
        "test_2"
    );
    assert!(trimmed.get("explanation").is_none(), "test_0");
}

pub fn sift(json: &Value, ignore_keys: &HashSet<String>) -> Value

Trait Implementations

impl Clone for Ignore

fn clone(&self) -> Ignore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ignore

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ignore

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Filter for Ignore

type Output = Value

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

impl PartialEq for Ignore

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Ignore