Struct new_tokio_smtp::ReversePath

pub struct ReversePath(_);

represents a reverse path, most times this is just a mail address

Note that this type is not supposed to contain the surrounding '<' and '>'. They will be added automatically.

Note that this can be an empty string, representing a empty reverse path (donated in smtp with <>).

Note that currently no parser is implemented and that the allowed grammar of the forward path changes depending on the EsmtKeywords in EHLO and on the parameters of the the MAIL command it’s used in. This and the fact that part of the grammar of reverse paths are discouraged to be used makes it a bit of a wast of time to implement the grammar here. Through send_mail actually does know about SMTPUTF8 and keeps track of it.

Implementations

impl ReversePath

pub fn as_str(&self) -> &str

return the inner representation as &str

pub fn from_unchecked<I>(data: I) -> Selfwhere
    I: Into<String>,

create a new instance from a string without validating the input

impl ReversePath

pub fn empty() -> Self

creates an empty reverse path

In a mail command this will lead to "MAIL FROM:<>". Note that the '<','>' are not part of the content so the content is an empty string.

use new_tokio_smtp::ReversePath;

let rpath = ReversePath::empty();
assert_eq!(rpath.as_str(), "");

Trait Implementations

impl AsRef<str> for ReversePath

fn as_ref(&self) -> &str

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

impl Clone for ReversePath

fn clone(&self) -> ReversePath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ReversePath

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

Formats the value using the given formatter.

impl From<MailAddress> for ReversePath

fn from(addr: MailAddress) -> ReversePath

Converts to this type from the input type.

impl Hash for ReversePath

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 Into<String> for ReversePath

fn into(self) -> String

Converts this type into the (usually inferred) input type.

impl<'a> PartialEq<&'a str> for ReversePath

fn eq(&self, other: &&'a str) -> 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 PartialEq<ReversePath> for ReversePath

fn eq(&self, other: &ReversePath) -> 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 PartialEq<String> for ReversePath

fn eq(&self, other: &String) -> 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 PartialEq<str> for ReversePath

fn eq(&self, other: &str) -> 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 Eq for ReversePath

impl StructuralEq for ReversePath

impl StructuralPartialEq for ReversePath