logo
pub struct Set<'a> {
    pub content: Cow<'a, [u8]>,
}
Available on crate feature mtls only.
Expand description

The SET object is an unordered list of heteregeneous types.

Sets can usually be of 2 types:

  • a list of different objects (SET, usually parsed as a struct)
  • a list of similar objects (SET OF, usually parsed as a BTreeSet<T> or HashSet<T>)

The current object covers the former. For the latter, see the SetOf documentation.

The Set object contains the (unparsed) encoded representation of its content. It provides methods to parse and iterate contained objects, or convert the sequence to other types.

Building a Set

To build a DER set:

  • if the set is composed of objects of the same type, the Set::from_iter_to_der method can be used
  • otherwise, the ToDer trait can be used to create content incrementally
use asn1_rs::{Integer, Set, SerializeResult, ToDer};

fn build_set<'a>() -> SerializeResult<Set<'a>> {
    let mut v = Vec::new();
    // add an Integer object (construct type):
    let i = Integer::from_u32(4);
    let _ = i.write_der(&mut v)?;
    // some primitive objects also implement `ToDer`. A string will be mapped as `Utf8String`:
    let _ = "abcd".write_der(&mut v)?;
    // return the set built from the DER content
    Ok(Set::new(v.into()))
}

let seq = build_set().unwrap();

Examples

use asn1_rs::Set;

// build set
let it = [2, 3, 4].iter();
let set = Set::from_iter_to_der(it).unwrap();

// `set` now contains the serialized DER representation of the array

// iterate objects
let mut sum = 0;
for item in set.der_iter::<u32>() {
    // item has type `Result<u32>`, since parsing the serialized bytes could fail
    sum += item.expect("parsing list item failed");
}
assert_eq!(sum, 9);

Note: the above example encodes a SET OF INTEGER object, the SetOf object could be used to provide a simpler API.

Fields

content: Cow<'a, [u8]>

Serialized DER representation of the set content

Implementations

Build a set, given the provided content

Consume the set and return the content

Apply the parsing function to the set content, consuming the set

Note: this function expects the caller to take ownership of content. In some cases, handling the lifetime of objects is not easy (when keeping only references on data). Other methods are provided (depending on the use case):

  • Set::parse takes a reference on the set data, but does not consume it,
  • Set::from_der_and_then does the parsing of the set and applying the function in one step, ensuring there are only references (and dropping the temporary set).

Same as Set::from_der_and_then, but using BER encoding (no constraints).

Parse a DER set and apply the provided parsing function to content

After parsing, the set object and header are discarded.

use asn1_rs::{FromDer, ParseResult, Set};

// Parse a SET {
//      a INTEGER (0..255),
//      b INTEGER (0..4294967296)
// }
// and return only `(a,b)
fn parser(i: &[u8]) -> ParseResult<(u8, u32)> {
    Set::from_der_and_then(i, |i| {
            let (i, a) = u8::from_der(i)?;
            let (i, b) = u32::from_der(i)?;
            Ok((i, (a, b)))
        }
    )
}

Apply the parsing function to the set content (non-consuming version)

Apply the parsing function to the set content (consuming version)

Note: to parse and apply a parsing function in one step, use the Set::from_der_and_then method.

Limitations

This function fails if the set contains Owned data, because the parsing function takes a reference on data (which is dropped).

Return an iterator over the set content, attempting to decode objects as BER

This method can be used when all objects from the set have the same type.

Return an iterator over the set content, attempting to decode objects as DER

This method can be used when all objects from the set have the same type.

Attempt to parse the set as a SET OF items (BER), and return the parsed items as a Vec.

Attempt to parse the set as a SET OF items (DER), and return the parsed items as a Vec.

Attempt to parse the set as a SET OF items (BER) (consuming input), and return the parsed items as a Vec.

Note: if Self is an Owned object, the data will be duplicated (causing allocations) into separate objects.

Attempt to parse the set as a SET OF items (DER) (consuming input), and return the parsed items as a Vec.

Note: if Self is an Owned object, the data will be duplicated (causing allocations) into separate objects.

Attempt to create a Set from an iterator over serializable objects (to DER)

Examples
use asn1_rs::Set;

// build set
let it = [2, 3, 4].iter();
let seq = Set::from_iter_to_der(it).unwrap();

Trait Implementations

Converts this type into a shared reference of the (usually inferred) input type.

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Get the length of the object, when encoded Read more

Attempt to write the DER header to this writer.

Attempt to write the DER content (all except header) to this writer.

Write the DER encoded representation to a newly allocated Vec<u8>.

Similar to using to_vec, but uses provided values without changes. This can generate an invalid encoding for a DER object. Read more

Attempt to write the DER encoded representation (header and content) into this writer. Read more

Similar to using to_der, but uses provided values without changes. This can generate an invalid encoding for a DER object. Read more

The type returned in the event of a conversion error.

Performs the conversion.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Is the provided Tag decodable as a variant of this CHOICE?

Returns the argument unchanged.

Attempt to parse input bytes into a BER object

Attempt to parse input bytes into a DER object (enforcing constraints)

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Converts self into a collection.

Should always be Self

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more