pub struct Mechanism<T> { /* private fields */ }
Implementations§
source§impl<T> Mechanism<T>
impl<T> Mechanism<T>
These are the generic methods for the struct of Mechanism.
All the following methods can be used on any struct of type Mechanism.
sourcepub fn is_softfail(&self) -> bool
pub fn is_softfail(&self) -> bool
Check mechanism is softfail
sourcepub fn is_neutral(&self) -> bool
pub fn is_neutral(&self) -> bool
Check mechanism is neutral
source§impl Mechanism<String>
impl Mechanism<String>
sourcepub fn new_redirect(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use redirect()
instead
pub fn new_redirect(qualifier: Qualifier, mechanism: String) -> Self
redirect()
insteadCreate a new Mechanism struct of Redirect
sourcepub fn redirect(
qualifier: Qualifier,
rrdata: &str
) -> Result<Self, MechanismError>
pub fn redirect( qualifier: Qualifier, rrdata: &str ) -> Result<Self, MechanismError>
Create a new Mechanism struct of Redirect
sourcepub fn new_a_without_mechanism(qualifier: Qualifier) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use a()
instead
pub fn new_a_without_mechanism(qualifier: Qualifier) -> Self
a()
insteadCreate a new Mechanism struct of A
with no string value.
sourcepub fn new_a_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use a().with_rrdata()
instead
pub fn new_a_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
a().with_rrdata()
insteadCreate a new Mechanism struct of A
with string value.
sourcepub fn a(qualifier: Qualifier) -> Self
pub fn a(qualifier: Qualifier) -> Self
Create a new Mechanism struct of A
Example:
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
// New `A` without rrdata.
let m = Mechanism::new_a_without_mechanism(Qualifier::Pass);
assert_eq!(m.kind().is_a(), true);
assert_eq!(m.raw(), "a".to_string());
assert_eq!(m.mechanism().is_none(), true);
// Create `A` with rrdata
if let Ok(m_with_rrdata) = Mechanism::a(Qualifier::Pass)
.with_rrdata("example.com") {
assert_eq!(m_with_rrdata.raw(), "example.com".to_string());
assert_eq!(m_with_rrdata.to_string(), "a:example.com".to_string());
}
// Create `A` with bad rrdata and `strict-dns` is disabled
if let Ok(bad_rrdata) = Mechanism::a(Qualifier::Pass)
.with_rrdata("example.xx") {
assert_eq!(bad_rrdata.raw(), "example.xx".to_string());
assert_eq!(bad_rrdata.to_string(), "a:example.xx".to_string());
}
// Create `A` with bad rrdata and `strict-dns` is enabled
if let Err(bad_rrdata) = Mechanism::a(Qualifier::Pass)
.with_rrdata("example.xx") {
assert_eq!(bad_rrdata, MechanismError::InvalidDomainHost("example.xx".to_string()));
}
sourcepub fn new_mx_without_mechanism(qualifier: Qualifier) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use mx()
instead
pub fn new_mx_without_mechanism(qualifier: Qualifier) -> Self
mx()
insteadCreate a new Mechanism struct of MX
without string value.
sourcepub fn new_mx_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use mx().with_rrdata()
instead
pub fn new_mx_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
mx().with_rrdata()
insteadCreate a new Mechanism struct of MX
sourcepub fn mx(qualifier: Qualifier) -> Self
pub fn mx(qualifier: Qualifier) -> Self
Create a new Mechanism struct of MX
Example:
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
// without rrdata
let mx = Mechanism::mx(Qualifier::Pass);
assert_eq!(mx.kind().is_mx(), true);
assert_eq!(mx.raw(), "mx");
// with rrdata
if let Ok(mx) = Mechanism::mx(Qualifier::Pass)
.with_rrdata("example.com") {
assert_eq!(mx.kind().is_mx(), true);
assert_eq!(mx.raw(), "example.com".to_string());
assert_eq!(mx.to_string(), "mx:example.com".to_string());
}
sourcepub fn new_include(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use include()
instead
pub fn new_include(qualifier: Qualifier, mechanism: String) -> Self
include()
insteadCreate a new Mechanism struct of Include
sourcepub fn include(
qualifier: Qualifier,
rrdata: &str
) -> Result<Self, MechanismError>
pub fn include( qualifier: Qualifier, rrdata: &str ) -> Result<Self, MechanismError>
Create a new Mechanism struct of Include
Example:
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
let include = Mechanism::include(Qualifier::Pass,
"example.com").unwrap();
assert_eq!(include.qualifier().as_str(), "");
assert_eq!(include.raw(), "example.com");
assert_eq!(include.to_string(), "include:example.com");
let include2 = Mechanism::include(Qualifier::SoftFail,
"example.com").unwrap();
assert_eq!(include2.to_string(), "~include:example.com")
sourcepub fn new_ptr_without_mechanism(qualifier: Qualifier) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use ptr()
instead
pub fn new_ptr_without_mechanism(qualifier: Qualifier) -> Self
ptr()
insteadCreate a new Mechanism struct of Ptr
with no value
sourcepub fn new_ptr_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use ptr().with_rrdata()
instead
pub fn new_ptr_with_mechanism(qualifier: Qualifier, mechanism: String) -> Self
ptr().with_rrdata()
insteadCreate a new Mechanism struct of Ptr
sourcepub fn ptr(qualifier: Qualifier) -> Self
pub fn ptr(qualifier: Qualifier) -> Self
Create a new Mechanism struct of Ptr
Example:
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
// without rrdata
let ptr = Mechanism::ptr(Qualifier::Fail);
assert_eq!(ptr.to_string(), "-ptr");
// with rrdata
let ptr = Mechanism::ptr(Qualifier::Fail)
.with_rrdata("example.com").unwrap();
assert_eq!(ptr.to_string(), "-ptr:example.com");
sourcepub fn new_exists(qualifier: Qualifier, mechanism: String) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use exists().with_rrdata()
instead
pub fn new_exists(qualifier: Qualifier, mechanism: String) -> Self
exists().with_rrdata()
insteadCreate a new Mechanism struct of Exists
sourcepub fn exists(
qualifier: Qualifier,
rrdata: &str
) -> Result<Self, MechanismError>
pub fn exists( qualifier: Qualifier, rrdata: &str ) -> Result<Self, MechanismError>
Create a new Mechanism struct of Exists
sourcepub fn with_rrdata(
self,
rrdata: impl Into<String>
) -> Result<Self, MechanismError>
pub fn with_rrdata( self, rrdata: impl Into<String> ) -> Result<Self, MechanismError>
Set the rrdata for Mechanism
Note: This is only applicable for Mechanisms of A
, MX
and Ptr
.
All other Mechanism types require rrdata
to be set. That is to say that rrdata
is
optional for A
, MX
and PTR
See: a
for an example.
sourcepub fn new_all(qualifier: Qualifier) -> Self
👎Deprecated: This will be depreciated in 0.3.0. Please use all()
instead
pub fn new_all(qualifier: Qualifier) -> Self
all()
insteadCreate a new Mechanism struct of All
sourcepub fn raw(&self) -> String
pub fn raw(&self) -> String
Return the mechanism string stored in the Mechanism
Example:
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
let mechanism_a = Mechanism::new_a_without_mechanism(Qualifier::Neutral);
assert_eq!(mechanism_a.raw(), "a");
let mechanism_a_string = Mechanism::new_a_with_mechanism(Qualifier::Neutral,
String::from("example.com"));
assert_eq!(mechanism_a_string.raw(), "example.com");
source§impl Mechanism<IpNetwork>
impl Mechanism<IpNetwork>
sourcepub fn new_ip(
qualifier: Qualifier,
mechanism: IpNetwork
) -> Mechanism<IpNetwork>
👎Deprecated: This will be depreciated in 0.3.0. Please use ip()
instead
pub fn new_ip( qualifier: Qualifier, mechanism: IpNetwork ) -> Mechanism<IpNetwork>
ip()
insteadCreate a new V4 or V6 Mechanism<IpNetwork>
sourcepub fn ip_from_string(
string: &str
) -> Result<Mechanism<IpNetwork>, MechanismError>
pub fn ip_from_string( string: &str ) -> Result<Mechanism<IpNetwork>, MechanismError>
Create a new V4 or V6 Mechanism from a string representation.
let string = "+ip4:203.32.160.0/24";
if let Ok(m) = Mechanism::ip_from_string(&string) {
assert_eq!(m.raw(), "203.32.160.0/24");
assert_eq!(m.to_string(), "ip4:203.32.160.0/24");
}
sourcepub fn ip(qualifier: Qualifier, rrdata: IpNetwork) -> Mechanism<IpNetwork>
pub fn ip(qualifier: Qualifier, rrdata: IpNetwork) -> Mechanism<IpNetwork>
Create a new V4 or V6 Mechanism<IpNetwork>
Will correctly set its kind
based on the IpNetwork
type.
Examples:
use decon_spf::mechanism::{Mechanism, Qualifier};
// Requires: use ipnetwork::IpNetwork;
let ip: IpNetwork = "192.168.11.0/24".parse().unwrap();
let mechanism = Mechanism::ip(Qualifier::Pass, ip);
assert_eq!(mechanism.kind().is_ip_v4(), true);
assert_eq!(mechanism.raw(), "192.168.11.0/24".to_string());
assert_eq!(mechanism.as_network().to_string(), "192.168.11.0/24".to_string());
assert_eq!(mechanism.as_network().prefix(), 24);
// This section does not require use of ipnetwork::IpNetwork;
let mechanism_ip4 = Mechanism::ip(Qualifier::Pass,
"203.32.160.0/23".parse().unwrap());
assert_eq!(mechanism_ip4.kind().is_ip(), true);
assert_eq!(mechanism_ip4.kind().is_ip_v4(), true);
assert_eq!(mechanism_ip4.to_string(), "ip4:203.32.160.0/23".to_string());
let mechanism_ip6 = Mechanism::ip(Qualifier::Pass,
"2001:4860:4000::/36".parse().unwrap());
assert_eq!(mechanism_ip6.kind().is_ip(), true);
assert_eq!(mechanism_ip6.kind().is_ip_v6(),true);
assert_eq!(mechanism_ip6.to_string(), "ip6:2001:4860:4000::/36".to_string());
sourcepub fn raw(&self) -> String
pub fn raw(&self) -> String
Returns the simple string representation of the mechanism
Example
use ipnetwork::IpNetwork;
use decon_spf::mechanism::Qualifier;
use decon_spf::mechanism::Mechanism;
let ip: IpNetwork = "192.168.11.0/24".parse().unwrap();
let ip_mechanism = Mechanism::ip(Qualifier::Pass, ip);
assert_eq!(ip_mechanism.raw(), "192.168.11.0/24");
assert_eq!(ip_mechanism.kind().is_ip(), true);
sourcepub fn as_network(&self) -> &IpNetwork
pub fn as_network(&self) -> &IpNetwork
Returns a reference to the mechanism as an IpNetwork
Trait Implementations§
source§impl<'de, T> Deserialize<'de> for Mechanism<T>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for Mechanism<T>where
T: Deserialize<'de>,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
source§impl FromStr for Mechanism<IpNetwork>
impl FromStr for Mechanism<IpNetwork>
Create a Mechanism<IpNetwork>
from the provided string.
Examples:
let ip4: Mechanism<IpNetwork> = "ip4:203.32.160.0/24".parse().unwrap();
assert_eq!(ip4.kind().is_ip_v4(), true);
let ip6 = "ip6:2001:4860:4000::/36".parse::<Mechanism<IpNetwork>>().unwrap();
assert_eq!(ip6.kind().is_ip_v6(), true);
let bad_ip4: Result<Mechanism<IpNetwork>, MechanismError> = "ip4:203.32.160.0/33".parse();
assert_eq!(bad_ip4.unwrap_err().to_string(), "invalid address: 203.32.160.0/33");
let ip6_but_ip4: Result<Mechanism<IpNetwork>, MechanismError> = "ip6:203.32.160.0/24".parse();
let err = ip6_but_ip4.unwrap_err();
assert_eq!(err, MechanismError::NotIP6Network("203.32.160.0/24".to_string()));
assert_eq!(err.to_string(), "203.32.160.0/24 is not an ip6 network");
source§impl FromStr for Mechanism<String>
impl FromStr for Mechanism<String>
Create a Mechanism<String>
from the provided string.
Examples:
let a: Mechanism<String> = "a".parse().unwrap();
assert_eq!(a.kind().is_a(), true);
if let Ok(mx) = "mx".parse::<Mechanism<String>>() {
assert_eq!(mx.kind().is_mx(), true);
}
if let Ok(mx2) = "-mx:example.com".parse::<Mechanism<String>>() {
assert_eq!(mx2.qualifier().is_fail(), true);
assert_eq!(mx2.to_string(), "-mx:example.com");
}