Struct MatchingRuleAssertion 

#[non_exhaustive]
pub struct MatchingRuleAssertion {
    pub matching_rule: Option<MatchingRuleId>,
    pub type: Option<AttributeDescription>,
    pub match_value: AssertionValue,
    pub dn_attributes: bool,
}

Extensible match rule assertion.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

matching_rule: Option<MatchingRuleId>

If the matching_rule is absent, the type field MUST be present, and an equality match is performed for that type.

type: Option<AttributeDescription>

The type match against if matching_rule is absent.

match_value: AssertionValue

The value to match against.

If the type field is absent and the matching_rule is present, match_value is compared against all attributes in an entry that support that matching_rule.

If the type field is present and the matching_rule is present, the match_value is compared against the specified attribute type and its subtypes.

dn_attributes: bool

If the dnAttributes field is set to true, the match is additionally applied against all the AttributeValueAssertions in an entry’s distinguished name, and it evaluates to TRUE if there is at least one attribute or subtype in the distinguished name for which the filter item evaluates to true. The dnAttributes field is present to alleviate the need for multiple versions of generic matching rules (such as word matching), where one applies to entries and another applies to entries and DN attributes as well.

Implementations

impl MatchingRuleAssertion

pub fn new( matching_rule: Option<MatchingRuleId>, type: Option<AttributeDescription>, match_value: AssertionValue, dn_attributes: bool, ) -> Self

MatchingRuleAssertion constructor

Trait Implementations

impl AsnType for MatchingRuleAssertion

const TAG: Tag

The associated tag for the type.

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 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 IS_CHOICE: bool = false

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 Clone for MatchingRuleAssertion

fn clone(&self) -> MatchingRuleAssertion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Constructed<4> for MatchingRuleAssertion

const FIELDS: Fields<4usize>

Fields contained in the “root component list”.

const IS_EXTENSIBLE: bool = true

Whether the type is extensible.

const EXTENDED_FIELDS: Option<Fields<0usize>> = None

Fields contained in the list of extensions.

impl Debug for MatchingRuleAssertion

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

Formats the value using the given formatter.

impl Decode for MatchingRuleAssertion

fn decode_with_tag_and_constraints<_DECODER: Decoder>( decoder: &mut _DECODER, tag: Tag, constraints: Constraints, ) -> Result<Self, _DECODER::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: &mut D) -> Result<Self, <D as Decoder>::Error>

where D: Decoder,

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 Encode for MatchingRuleAssertion

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

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

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

where E: Encoder<'b>,

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

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_identifier<'b, E>( &self, encoder: &mut E, identifier: Identifier, ) -> Result<(), <E as Encoder<'b>>::Error>

where E: Encoder<'b>,

Encode this value with identifier 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 MatchingRuleAssertion

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 MatchingRuleAssertion

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

This method returns an Ordering between self and other.

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 MatchingRuleAssertion

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

fn partial_cmp(&self, other: &MatchingRuleAssertion) -> 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 MatchingRuleAssertion

impl StructuralPartialEq for MatchingRuleAssertion