Enum Mapping 

pub enum Mapping<'left, 'right>
where
    Self: 'left + 'right,
{
    AsIs(Match, (Expr<'left>, Expr<'right>)),
    Into(Match, (Expr<'left>, Expr<'right>)),
    ManyInto {
        sources: Vec<Match>,
        target: PathBuf,
        excluded: Vec<Match>,
        exprs: (Expr<'left>, Expr<'right>),
    },
}

Variants

AsIs(Match, (Expr<'left>, Expr<'right>))

Copy source to target as-is.

Into(Match, (Expr<'left>, Expr<'right>))

Copy source into target as-is.

ManyInto

Fields

sources: Vec<Match>

target: PathBuf

Target directory. Related path that should be preserved in the output.

excluded: Vec<Match>

exprs: (Expr<'left>, Expr<'right>)

Implementations

impl Mapping<'_, '_>

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

pub fn exprs(&self) -> (&Expr<'_>, &Expr<'_>)

pub fn sources(&self) -> Vec<&Match>

pub fn kind(&self) -> MappingKind

pub fn pretty_print_compact(&self) -> String

Trait Implementations

impl<'left, 'right> Debug for Mapping<'left, 'right>

where Self: 'left + 'right,

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

Formats the value using the given formatter.

impl<'t> EnvRequired<'t> for Mapping<'_, '_>

where Self: 't,

type Item = &'t str

type Output = Vec<<Mapping<'_, '_> as EnvRequired<'t>>::Item>

fn env_required(&'t self) -> Self::Output

impl<'left, 'right> Hash for Mapping<'left, 'right>

where Self: 'left + 'right,

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<'left, 'right> PartialEq for Mapping<'left, 'right>

where Self: 'left + 'right,

fn eq(&self, other: &Mapping<'left, 'right>) -> 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<'left, 'right> Serialize for Mapping<'left, 'right>

where Mapping<'left, 'right>: 'left + 'right,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'left, 'right> Eq for Mapping<'left, 'right>

where Self: 'left + 'right,

impl<'left, 'right> StructuralPartialEq for Mapping<'left, 'right>

where Self: 'left + 'right,