Struct bcder::BitString

pub struct BitString { /* private fields */ }

A bit string value.

Bit strings are a sequence of bits. Unlike OctetStrings, they do not need to contain a multiple of eight bits.

You can parse a bit string value out of a constructed value using the take_from method. The from_content method parses the content octets of a bit string value and can be used of the bit string is implcitely tagged. Alternatively, you can create a new simple bit string via the [new] method.

There are two types of methods for accessing the data in a bit string. Methods starting with bit operate on the individual bits while those prefixed with octet access entire octets and ignore the fact that there may be unused bits in the final octet.

BER Encoding

When encoded in BER, bit strings can either be a primitive or constructed value.

If encoded as a primitive value, the first octet of the content contains the number of unused bits in the last octet and the following octets contain the bits with the first bit in the most significant bit of the octet.

In the constructed encoding, the bit string is represented as a sequence of bit strings which in turn may either be constructed or primitive encodings. The only limitation in this nesting is that only the last primitively encoded bit string may have a non-zero number of unused bits.

With BER, the sender can choose either form of encoding. With CER, the primitive encoding should be chosen if its length would be no more than 1000 octets long. Otherwise, the constructed encoding is to be chosen which must contain a sequence of primitively encoded bit strings. Each of these except for the last one must have content of exactly 1000 octets. The last one must be a least one and at most 1000 octets of content. With DER, only the primitive form is allowed.

Limitation

At this time, the BitString type does not implement the constructed encoding of a bit string.

Implementations

impl BitString

pub fn new(unused: u8, bits: Bytes) -> Self

Creates a new bit string.

pub fn bit(&self, bit: usize) -> bool

Returns the value of the given bit.

pub fn bit_len(&self) -> usize

Returns the number of bits in the bit string.

pub fn unused(&self) -> u8

Returns the number of unused bits in the last octet.

pub fn octet_len(&self) -> usize

Returns the number of octets in the bit string.

pub fn octets(&self) -> BitStringIter<'_>

Returns an iterator over the octets in the bit string.

pub fn octet_slice(&self) -> Option<&[u8]>

Returns a slice of the octets in the bit string if available.

The method will return None if the bit string is constructed from several parts.

pub fn octet_bytes(&self) -> Bytes

Returns a bytes value of the octets of the bit string.

This will be cheap for primitively encoded bit strings but requires allocations for complex ones.

impl BitString

Decoding and Encoding

pub fn take_from<S: Source>(
    constructed: &mut Constructed<'_, S>
) -> Result<Self, S::Err>

Takes a single bit string value from constructed content.

pub fn skip_in<S: Source>(cons: &mut Constructed<'_, S>) -> Result<(), S::Err>

Skip over a single bit string value inside constructed content.

pub fn from_content<S: Source>(
    content: &mut Content<'_, S>
) -> Result<Self, S::Err>

Parses the content octets of a bit string value.

pub fn skip_content<S: Source>(
    content: &mut Content<'_, S>
) -> Result<(), S::Err>

Skips over the content octets of a bit string value.

pub fn encode<'a>(&'a self) -> impl Values + 'a

pub fn encode_as<'a>(&'a self, tag: Tag) -> impl Values + 'a

Trait Implementations

impl Clone for BitString

fn clone(&self) -> BitString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BitString

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

Formats the value using the given formatter.

impl PartialEq<BitString> for BitString

fn eq(&self, other: &BitString) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PrimitiveContent for BitString

const TAG: Tag = Tag::BIT_STRING

The natural tag of an encoded value of this type.

fn encoded_len(&self, _: Mode) -> usize

Returns the length of the encoded content of this type.

fn write_encoded<W: Write>(&self, _: Mode, target: &mut W) -> Result<(), Error>

Writes the encoded content to a writer.

fn to_encoded_bytes(&self, mode: Mode) -> Bytes

Encodes the value to bytes (useful when you need to sign a structure)

fn encode(&self) -> Primitive<'_, Self>

Returns a value encoder for this content using the natural tag.

fn encode_as(&self, tag: Tag) -> Primitive<'_, Self>

Returns a value encoder for this content using the given tag.

impl Eq for BitString

impl StructuralEq for BitString

impl StructuralPartialEq for BitString