Struct SpfBuilder

pub struct SpfBuilder<State = Builder> { /* private fields */ }

Available on crate feature builder only.

The definition of the SpfBuilder struct which contains all information related a single SPF record.

Implementations

impl<State> SpfBuilder<State>

pub fn new() -> Self

Create a new empty SpfBuilder struct.

use decon_spf::{SpfBuilder, Builder};
use decon_spf::mechanism::{Mechanism, MechanismError, Qualifier};

// Strict building style.
let mut spf: SpfBuilder<Builder> = SpfBuilder::new();
spf.set_v1()
    .add_a(Mechanism::a(Qualifier::Pass))
    .add_mx(Mechanism::mx(Qualifier::Pass).with_rrdata("test.com").unwrap());
// add_all() changes the struct state from Builder to ContainsAll
let mut spf = spf.add_all(Mechanism::all());

let mut spf = SpfBuilder::new_builder();
spf
    .set_v1()
    .append_mechanism(Mechanism::a(Qualifier::Pass))
    .append_mechanism(Mechanism::ip_from_string("ip4:203.32.160.10").unwrap())
    .append_mechanism(Mechanism::all());

pub fn version(&self) -> &String

Access the version attribute

impl SpfBuilder<Builder>

pub fn new_builder() -> SpfBuilder<Builder>

Create an SpfBuilder with State of Builder

impl SpfBuilder<Parsed>

pub fn new_parsed() -> SpfBuilder<Parsed>

Create an SpfBuilder with State of Parsed

impl<State> SpfBuilder<State>

where State: Modifiable,

pub fn set_v1(&mut self) -> &mut Self

Set version to v=spf1

pub fn add_a(&mut self, mechanism: Mechanism<String>) -> &mut Self

Add an a mechanism

pub fn add_mx(&mut self, mechanism: Mechanism<String>) -> &mut Self

Add an mx mechanism

pub fn add_include(&mut self, mechanism: Mechanism<String>) -> &mut Self

Add an include Mechanism

pub fn add_ip(&mut self, mechanism: Mechanism<IpNetwork>) -> &mut Self

Add either and Ip4 or Ip6 Mechanism

impl SpfBuilder<Builder>

pub fn add_redirect( self, mechanism: Mechanism<String>, ) -> SpfBuilder<Redirected>

Append a Redirect Mechanism to the Spf Struct. This also changes the struct’s State

pub fn add_all(self, mechanism: Mechanism<All>) -> SpfBuilder<ContainsAll>

Add a Mechanism to the SpfBuilder struct. This also changes the State to ContainsAll

impl<State> SpfBuilder<State>

where State: Modifiable,

pub fn set_v2_pra(&mut self) -> &mut Self

Available on crate feature spf2 only.

Set version to spf2.0/pra

pub fn set_v2_mfrom(&mut self) -> &mut Self

Available on crate feature spf2 only.

Set version to spf2.0/mfrom

pub fn set_v2_pra_mfrom(&mut self) -> &mut Self

Available on crate feature spf2 only.

Set version to spf2.0/pra,mfrom

pub fn set_v2_mfrom_pra(&mut self) -> &mut Self

Available on crate feature spf2 only.

Set version to spf2.0/mfrom,pra

pub fn is_v2(&self) -> bool

Available on crate feature spf2 only.

Check that version is v2

impl<State> SpfBuilder<State>

pub fn clear_mechanism(&mut self, kind: Kind)

where State: Modifiable,

Clear the passed Kind which has been passed. Sets the passed mechanism to None

Note:

This method clears all associated Mechanism for the Kind provided.

Example:

use decon_spf::mechanism::{Qualifier, Kind, Mechanism};
use decon_spf::{Builder, SpfBuilder};
let mut spf: SpfBuilder<Builder> = SpfBuilder::new();
spf.set_v1();
spf.append_mechanism(Mechanism::all_with_qualifier(Qualifier::Pass));
spf.append_mechanism(Mechanism::a(Qualifier::Pass));
spf.append_mechanism(Mechanism::ip(Qualifier::Pass,
                                                 "203.32.160.0/23".parse().unwrap()));
// Remove ip4 Mechanism
spf.clear_mechanism(Kind::IpV4);

pub fn append_mechanism<T>(&mut self, mechanism: Mechanism<T>) -> &mut Self

where Self: Append<T>,

This is generic method for adding Mechanism<T> to the SpfBuilder struct.

Note:

This approach does not provide protection to prevent redirect and all from both being present in a single SpfBuilder struct. If you wish to prevent this. Please use the add_redirect() and add_all() functions.

use decon_spf::mechanism::{Qualifier, Mechanism};
use decon_spf::{Builder, Spf, SpfBuilder};
let mut spf: SpfBuilder<Builder> = SpfBuilder::new();
spf.set_v1();
spf.append_mechanism(Mechanism::redirect(Qualifier::Pass,
                                "_spf.example.com").unwrap())
   .append_mechanism(Mechanism::all_with_qualifier(Qualifier::Pass));

let mut spf: SpfBuilder<Builder> = SpfBuilder::new_builder();
spf.set_v1().add_a(Mechanism::a(Qualifier::Pass));
let mut spf = spf.add_all(Mechanism::all()); // spf -> SpfBuilder<ContainsAll>
// spf.redirect() and spf.add_all() are only defined for SpfBuilder<Builder>
// As such they do not exist for <ContainsAll> or <Redirect>

pub fn is_redirect(&self) -> bool

True if there is a redirect present in the spf record.

pub fn redirect(&self) -> Option<&Mechanism<String>>

Returns a reference to the Redirect Mechanism

pub fn includes(&self) -> Option<&Vec<Mechanism<String>>>

Returns a reference to the a Vec of Mechanism<String> for Include

pub fn a(&self) -> Option<&Vec<Mechanism<String>>>

Returns a reference to a Vec of Mechanism<String> for A

pub fn mx(&self) -> Option<&Vec<Mechanism<String>>>

Returns a reference to a Vec of Mechanism<String> for MX

pub fn ip4(&self) -> Option<&Vec<Mechanism<IpNetwork>>>

Returns a reference to a Vec of Mechanism<IpNetwork> for IP4

pub fn ip6(&self) -> Option<&Vec<Mechanism<IpNetwork>>>

Returns a reference to a Vec of Mechanism<IpNetwork> for IP6

pub fn exists(&self) -> Option<&Vec<Mechanism<String>>>

Returns a reference to a Vec of Mechanism<String> for Exists

pub fn ptr(&self) -> Option<&Mechanism<String>>

Returns a reference to a Vec of Mechanism<String> for Ptr

pub fn all(&self) -> Option<&Mechanism<All>>

Returns a reference to Mechanism<All> for All

pub fn build(self) -> Result<Spf<String>, SpfError>

Creates a Spf<String> from SpfBuilder This function also validates the SpfBuilder struct before returning a Spf

use decon_spf::{Spf, SpfBuilder, Builder, SpfError};
use decon_spf::mechanism::{Mechanism, Qualifier};
let mut builder: SpfBuilder<Builder> = SpfBuilder::new();
// Note Version was not Set. build() assumes v=spf1 when not present
builder.add_a(Mechanism::a(Qualifier::Pass));
let mut builder = builder.add_all(Mechanism::all());
let spf = match builder.build() {
    Ok(result) => { result },
    Err(_) => { panic!() }
};
assert_eq!(1,spf.lookup_count());

let mut builder: SpfBuilder<Builder> = SpfBuilder::new();
builder.append_mechanism(Mechanism::redirect(Qualifier::Pass,"test.com").expect("ok"));
builder.append_mechanism(Mechanism::all());

let result = match builder.build() {
    Ok(_) => { panic!()},
    Err(e) => {
        assert!(matches!(e, SpfError::RedirectWithAllMechanism));
        e
    }
};
assert!(result.is_spf_error());

impl<State> SpfBuilder<State>

pub fn iter(&self) -> SpfBuilderIterator

Allows you to iterate over Mechanisms contained within the SPF record.

Note: Version string is not included.

Trait Implementations

impl<State: Clone> Clone for SpfBuilder<State>

fn clone(&self) -> SpfBuilder<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for SpfBuilder<State>

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

Formats the value using the given formatter.

impl<State> Default for SpfBuilder<State>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, State> Deserialize<'de> for SpfBuilder<State>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<State> Display for SpfBuilder<State>

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

Formats the value using the given formatter.

impl From<Spf<String>> for SpfBuilder<Builder>

Converts a Spf<String> into a SpfBuilder`struct.

fn from(source: Spf<String>) -> SpfBuilder<Builder>

Converts to this type from the input type.

impl FromStr for SpfBuilder<Parsed>

Creates an SpfBuilder struct by parsing a string representation of Spf.

Examples:

 use decon_spf::{Parsed, SpfBuilder};
 use decon_spf::SpfError;
 // Successful
 let input = "v=spf1 a mx -all";
 let spf: SpfBuilder<Parsed> = input.parse().unwrap();
 assert_eq!(spf.to_string(), input);

 // Additional Space between `A` and `MX`
 let invalid_input = "v=spf1 a   mx -all";
 let err: SpfError = invalid_input.parse::<SpfBuilder<Parsed>>().unwrap_err();
 assert_eq!(err, SpfError::WhiteSpaceSyntaxError);
 //  err.to_string() -> "Spf contains two or more consecutive whitespace characters.");

type Err = SpfError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<State: PartialEq> PartialEq for SpfBuilder<State>

fn eq(&self, other: &SpfBuilder<State>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<State> Serialize for SpfBuilder<State>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<State> StructuralPartialEq for SpfBuilder<State>