Enum Filter 

#[non_exhaustive]
pub enum Filter {
    And(SetOf<Filter>),
    Or(SetOf<Filter>),
    Not(Box<Filter>),
    EqualityMatch(AttributeValueAssertion),
    Substrings(SubstringFilter),
    GreaterOrEqual(AttributeValueAssertion),
    LessOrEqual(AttributeValueAssertion),
    Present(AttributeDescription),
    ApproxMatch(AttributeValueAssertion),
    ExtensibleMatch(MatchingRuleAssertion),
}

Defines the conditions that must be fulfilled in order for the search to match a given entry.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

And(SetOf<Filter>)

All matching rules must evaluate to true.

Or(SetOf<Filter>)

Any matching rules must evaluate to true.

Not(Box<Filter>)

The matching rule must evaluate to false.

EqualityMatch(AttributeValueAssertion)

The filter is true when the EQUALITY rule returns true as applied to the attribute or subtype and the asserted value.

Substrings(SubstringFilter)

The filter is true when the SUBSTR rule returns true as applied to the attribute or subtype and the asserted value.

Note that the AssertionValue in a substrings filter item conforms to the assertion syntax of the EQUALITY matching rule for the attribute type rather than to the assertion syntax of the SUBSTR matching rule for the attribute type. Conceptually, the entire SubstringFilter is converted into an assertion value of the substrings matching rule prior to applying the rule.

GreaterOrEqual(AttributeValueAssertion)

The filter is true when the “ORDERING” rule returns false as applied to the attribute or subtype and the asserted value.

LessOrEqual(AttributeValueAssertion)

The filter is true when either the “ORDERING” or “EQUALITY” rule returns true as applied to the attribute or subtype and the asserted value.

Present(AttributeDescription)

The filter is true when there is an attribute or subtype of the specified attribute description present in an entry, false when no attribute or subtype of the specified attribute description is present in an entry, and “Undefined” otherwise.

ApproxMatch(AttributeValueAssertion)

The filter is true when there is a value of the attribute type or subtype for which some locally-defined approximate matching algorithm (e.g., spelling variations, phonetic match, etc.) returns true. If a value matches for equality, it also satisfies an approximate match. If approximate matching is not supported for the attribute, this filter item should be treated as an EqualityMatch.

ExtensibleMatch(MatchingRuleAssertion)

The filter is evaluated as follows:

Trait Implementations

impl AsnType for Filter

const TAG: Tag = { rasn::types::Tag::EOC }

The associated tag for the type.

const TAG_TREE: TagTree

The root of this type’s tree of tag’s if it a CHOICE type, otherwise its Leaf that points Self::TAG.

const IDENTIFIER: Identifier

Identifier of an ASN.1 type as specified in the original specification if not identical with the identifier of Self

const CONSTRAINTS: Constraints

The set of constraints for values of the given type.

const IS_CHOICE: bool = true

Whether the type is choice type. PER/OER encoding rules require this knowledge.

fn is_present(&self) -> bool

Whether the type is present with value. OPTIONAL fields are common in SEQUENCE or SET.

impl Choice for Filter

const VARIANTS: &'static [TagTree]

Variants contained in the “root component list”.

const VARIANCE_CONSTRAINT: Constraints

Constraint for the choice type, based on the number of root components. Used for PER encoding.

const EXTENDED_VARIANTS: Option<&'static [TagTree]>

Variants contained in the list of extensions.

const IDENTIFIERS: &'static [&'static str]

Variant identifiers for text-based encoding rules

impl Clone for Filter

fn clone(&self) -> Filter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Filter

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

Formats the value using the given formatter.

impl Decode for Filter

fn decode_with_tag_and_constraints<D: Decoder>( decoder: &mut D, tag: Tag, constraints: Constraints, ) -> Result<Self, D::Error>

Decode this value implicitly tagged with tag from a given ASN.1 decoder with a set of constraints on what values of that type are allowed.

fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, D::Error>

Decode this value from a given ASN.1 decoder.

fn decode_with_tag<D>( decoder: &mut D, tag: Tag, ) -> Result<Self, <D as Decoder>::Error>

where D: Decoder,

Decode this value implicitly tagged with tag from a given ASN.1 decoder.

fn decode_with_constraints<D>( decoder: &mut D, constraints: Constraints, ) -> Result<Self, <D as Decoder>::Error>

where D: Decoder,

Decode this value from a given ASN.1 decoder with a set of constraints on what values of that type are allowed.

impl DecodeChoice for Filter

fn from_tag<D: Decoder>(decoder: &mut D, tag: Tag) -> Result<Self, D::Error>

Decode the choice value based on the provided tag.

impl Encode for Filter

fn encode<'encoder, E: Encoder<'encoder>>( &self, encoder: &mut E, ) -> Result<(), E::Error>

Encodes self’s data into the given crate::Encoder.

fn encode_with_identifier<'encoder, E: Encoder<'encoder>>( &self, encoder: &mut E, identifier: Identifier, ) -> Result<(), E::Error>

Encode this value with identifier into the given crate::Encoder.

fn encode_with_tag_and_constraints<'encoder, EN: Encoder<'encoder>>( &self, encoder: &mut EN, tag: Tag, constraints: Constraints, identifier: Identifier, ) -> Result<(), EN::Error>

Encode this value with tag into the given crate::Encoder with the constraints the values this is allowed to encode into.

fn encode_with_tag<'b, E>( &self, encoder: &mut E, tag: Tag, ) -> Result<(), <E as Encoder<'b>>::Error>

where E: Encoder<'b>,

Encode this value with tag into the given crate::Encoder.

fn encode_with_tag_and_identifier<'b, E>( &self, encoder: &mut E, tag: Tag, identifier: Identifier, ) -> Result<(), <E as Encoder<'b>>::Error>

where E: Encoder<'b>,

Encode this value with tag and identifier into the given crate::Encoder.

fn encode_with_constraints<'b, E>( &self, encoder: &mut E, constraints: Constraints, ) -> Result<(), <E as Encoder<'b>>::Error>

where E: Encoder<'b>,

Encode this value into the given crate::Encoder with the constraints the values this is allowed to encode into.

fn encode_with_constraints_and_identifier<'b, E>( &self, encoder: &mut E, constraints: Constraints, identifier: Identifier, ) -> Result<(), <E as Encoder<'b>>::Error>

where E: Encoder<'b>,

Encode this value into the given crate::Encoder with identifier and the constraints the values this is allowed to encode into.

impl Hash for Filter

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 Not for Filter

type Output = Filter

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl PartialEq for Filter

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

impl StructuralPartialEq for Filter