Struct MimeParams 

pub struct MimeParams<'a> { /* private fields */ }

Validated MIME parameters.

Examples

use parse_net::{mail, Limits};

let (p, _) = mail::parse_mime_params(b"; charset=us-ascii", &Limits::DEFAULT)?;
let mut buf = [0u8; 16];
assert_eq!(p.decode_into("charset", &mut buf)?, Some("us-ascii"));

Implementations

impl<'a> MimeParams<'a>

pub fn get(&self, name: &str) -> Option<MimeValue<'a>>

The value of name (case-insensitive): a continuation when name*0 or name*0* is present, else the extended name*, else the plain name.

Examples

use parse_net::{mail::{self, MimeValue}, Limits};

let (p, _) = mail::parse_mime_params(b"; name=plain.txt; name*=UTF-8''ext.txt", &Limits::DEFAULT)?;
assert!(matches!(p.get("NAME"), Some(MimeValue::Extended(e)) if e.encoded() == b"ext.txt"));
assert!(p.get("other").is_none());

pub fn decode_into<'b>( &self, name: &str, out: &'b mut [u8], ) -> Result<Option<&'b str>, ParseError>

Decodes the value of name into out (as get chooses it); Ok(None) when absent.

Errors

ErrorKind::BufferTooSmall; ErrorKind::InvalidUtf8 for a plain value that is not UTF-8. Nothing is written on error.

Examples

use parse_net::{mail, ErrorKind, Limits};

let (p, _) = mail::parse_mime_params(b"; boundary=\"simple boundary\"", &Limits::DEFAULT)?;
let mut buf = [0u8; 32];
assert_eq!(p.decode_into("boundary", &mut buf)?, Some("simple boundary"));
assert_eq!(p.decode_into("charset", &mut buf)?, None);
assert_eq!(p.decode_into("boundary", &mut [0u8; 4]).unwrap_err().kind(), ErrorKind::BufferTooSmall);

pub fn iter(&self) -> MimeParamIter<'a>

The parameters as sent, sections included, in order.

Examples

use parse_net::{mail, Limits};

let (p, _) = mail::parse_mime_params(b"; a*0=x; a*1=y", &Limits::DEFAULT)?;
let names: Vec<&[u8]> = p.iter().map(|(name, _)| name).collect();
assert_eq!(names, [&b"a*0"[..], b"a*1"]);

pub const fn len(&self) -> usize

The number of parameters, sections counted one by one.

Examples

use parse_net::{mail, Limits};

let (p, _) = mail::parse_mime_params(b"; a*0=x; a*1=y; b=z", &Limits::DEFAULT)?;
assert_eq!(p.len(), 3);

pub const fn is_empty(&self) -> bool

Whether there are no parameters.

Examples

use parse_net::{mail, Limits};

let (p, used) = mail::parse_mime_params(b" no params", &Limits::DEFAULT)?;
assert!(p.is_empty() && used == 0);

Trait Implementations

impl<'a> Clone for MimeParams<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for MimeParams<'a>

impl<'a> Debug for MimeParams<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for MimeParams<'a>

impl<'a> Hash for MimeParams<'a>

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<'a> PartialEq for MimeParams<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for MimeParams<'a>