Struct ModalEncoder 

pub struct ModalEncoder<'a, 'e> { /* private fields */ }

This wraps a BinEncoder and applies different name encoding options.

Original name encoding options will be restored when this is dropped.

Methods from Deref<Target = BinEncoder<'a>>

pub fn set_max_size(&mut self, max: u16)

Sets the maximum size of the buffer

DNS message lens must be smaller than u16::max_value due to hard limits in the protocol

this method will move to the constructor in a future release

pub fn len(&self) -> usize

Returns the length of the buffer

pub fn is_empty(&self) -> bool

Returns true if the buffer is empty

pub fn offset(&self) -> usize

Returns the current offset into the buffer

pub fn set_offset(&mut self, offset: usize)

sets the current offset to the new offset

pub fn set_canonical_form(&mut self, canonical_form: bool)

If set to true, then records will be written into the buffer in DNSSEC canonical form

pub fn is_canonical_form(&self) -> bool

Returns true if the encoder is writing in DNSSEC canonical form

pub fn set_name_encoding(&mut self, name_encoding: NameEncoding)

Select how names are encoded

pub fn name_encoding(&self) -> NameEncoding

Returns the current name encoding mode

pub fn with_name_encoding<'e>( &'e mut self, name_encoding: NameEncoding, ) -> ModalEncoder<'a, 'e>

Returns a guard type that uses a different name encoding mode.

pub fn with_rdata_behavior<'e>( &'e mut self, rdata_encoding: RDataEncoding, ) -> ModalEncoder<'a, 'e>

Returns a guard type that uses a different name encoding mode, for RDATA.

If the encoder is using canonical form, name compression will not be used. Otherwise, name compression will be used for standard record types.

If the encoder is using canonical form, the case of names will depend on the record type. Otherwise, the case will be unchanged.

pub fn trim(&mut self)

trims to the current offset

pub fn slice_of(&self, start: usize, end: usize) -> &[u8]

borrow a slice from the encoder

pub fn store_label_pointer(&mut self, start: usize, end: usize)

Stores a label pointer to an already written label

The location is the current position in the buffer implicitly, it is expected that the name will be written to the stream after the current index.

pub fn get_label_pointer(&self, start: usize, end: usize) -> Option<u16>

Looks up the index of an already written label

pub fn emit(&mut self, b: u8) -> Result<(), ProtoError>

Emit one byte into the buffer

pub fn emit_character_data<S>(&mut self, char_data: S) -> Result<(), ProtoError>

where S: AsRef<[u8]>,

matches description from above.

use hickory_proto::serialize::binary::BinEncoder;

let mut bytes: Vec<u8> = Vec::new();
{
  let mut encoder: BinEncoder = BinEncoder::new(&mut bytes);
  encoder.emit_character_data("abc");
}
assert_eq!(bytes, vec![3,b'a',b'b',b'c']);

pub fn emit_character_data_unrestricted<S>( &mut self, data: S, ) -> Result<(), ProtoError>

where S: AsRef<[u8]>,

Emit character data of unrestricted length

Although character strings are typically restricted to being no longer than 255 characters, some modern standards allow longer strings to be encoded.

pub fn emit_u8(&mut self, data: u8) -> Result<(), ProtoError>

Emit one byte into the buffer

pub fn emit_u16(&mut self, data: u16) -> Result<(), ProtoError>

Writes a u16 in network byte order to the buffer

pub fn emit_i32(&mut self, data: i32) -> Result<(), ProtoError>

Writes an i32 in network byte order to the buffer

pub fn emit_u32(&mut self, data: u32) -> Result<(), ProtoError>

Writes an u32 in network byte order to the buffer

pub fn emit_vec(&mut self, data: &[u8]) -> Result<(), ProtoError>

Writes the byte slice to the stream

pub fn emit_all<'e, I, E>(&mut self, iter: I) -> Result<usize, ProtoError>

where I: Iterator<Item = &'e E>, E: 'e + BinEncodable,

Emits all the elements of an Iterator to the encoder

pub fn emit_all_refs<'r, 'e, I, E>( &mut self, iter: I, ) -> Result<usize, ProtoError>

where 'e: 'r, I: Iterator<Item = &'r &'e E>, E: 'r + 'e + BinEncodable,

Emits all the elements of an Iterator to the encoder

pub fn emit_iter<'e, I, E>(&mut self, iter: &mut I) -> Result<usize, ProtoError>

where I: Iterator<Item = &'e E>, E: 'e + BinEncodable,

emits all items in the iterator, return the number emitted

pub fn place<T>(&mut self) -> Result<Place<T>, ProtoError>

where T: EncodedSize,

capture a location to write back to

pub fn len_since_place<T>(&self, place: &Place<T>) -> usize

where T: EncodedSize,

calculates the length of data written since the place was creating

pub fn emit_at<T>(&mut self, place: Place<T>, data: T) -> Result<(), ProtoError>

where T: EncodedSize,

write back to a previously captured location

Trait Implementations

impl<'a> Deref for ModalEncoder<'a, '_>

type Target = BinEncoder<'a>

The resulting type after dereferencing.

fn deref(&self) -> &<ModalEncoder<'a, '_> as Deref>::Target

Dereferences the value.

impl DerefMut for ModalEncoder<'_, '_>

fn deref_mut(&mut self) -> &mut <ModalEncoder<'_, '_> as Deref>::Target

Mutably dereferences the value.

impl Drop for ModalEncoder<'_, '_>

fn drop(&mut self)

Executes the destructor for this type.