Struct cdx::trans::TransMaker

pub struct TransMaker {}

Makes a Trans

Implementations

impl TransMaker

pub fn push<F: 'static>(
    tag: &'static str,
    help: &'static str,
    maker: F
) -> Result<()> where
    F: Fn(&TransSettings, &str) -> Result<Box<dyn Trans>> + Send, 

Add a new trans. If a Trans already exists by that name, replace it.

pub fn add_alias(old_name: &'static str, new_name: &'static str) -> Result<()>

Add a new alias. If an alias already exists by that name, replace it.

pub fn help()

Print all available Transs to stdout.

pub fn make2(trans: &str, pattern: &str) -> Result<Transform>

Create a Trans from a trans spec and a pattern

Examples found in repository

src/trans.rs (line 395)

≺ ≻

pub fn make(spec: &str) -> Result<Transform> {
        if let Some((a, b)) = spec.split_once(',') {
            Self::make2(a, b)
        } else {
            Self::make2(spec, "")
        }
    }

pub fn make_box(
    kind: &str,
    conf: &TransSettings,
    pattern: &str
) -> Result<Box<dyn Trans>>

make a dyn Trans from a named trans and a pattern

Examples found in repository

src/trans.rs (line 377)

↕

pub fn make2(trans: &str, pattern: &str) -> Result<Transform> {
        let mut spec = trans.to_string();
        if !pattern.is_empty() {
            spec.push(',');
            spec.push_str(pattern);
        }
        let mut conf = TransSettings::default();
        let mut kind = "";
        if !trans.is_empty() {
            for x in trans.split('.') {
                if x.eq_ignore_ascii_case("utf8") {
                    conf.utf8 = true;
                } else {
                    kind = x;
                }
            }
            kind = Self::resolve_alias(kind);
        }
        Ok(Transform {
            spec,
            conf,
            trans: Self::make_box(kind, &conf, pattern)?,
        })
    }

pub fn make(spec: &str) -> Result<Transform>

Create a trans from a full spec, i.e. “Trans,Pattern”

Examples found in repository

src/trans.rs (line 158)

≺ ≻↕

fn clone(&self) -> Self {
        TransMaker::make(&self.spec).unwrap()
    }
}

impl Transform {
    fn trans(&mut self, src: &[u8], cont: &TextLine, dst: &mut Vec<u8>) -> Result<()> {
        self.trans.trans(src, cont, dst)
    }
    fn lookup(&mut self, fieldnames: &[&str]) -> Result<()> {
        self.trans.lookup(fieldnames)
    }
}

#[derive(Default, Clone, Debug)]
/// a chain of transforms
pub struct TransList {
    v: Vec<Transform>,
    tmp1: Vec<u8>,
    tmp2: Vec<u8>,
}

impl TransList {
    /// new
    pub fn new(spec: &str) -> Result<Self> {
        let mut s = Self::default();
        for x in spec.split('+') {
            s.push(x)?;
        }
        Ok(s)
    }
    /// add new trans
    pub fn push(&mut self, spec: &str) -> Result<()> {
        self.v.push(TransMaker::make(spec)?);
        Ok(())
    }

Trait Implementations

impl Clone for TransMaker

fn clone(&self) -> TransMaker

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransMaker

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

Formats the value using the given formatter.

impl Default for TransMaker

fn default() -> TransMaker

Returns the “default value” for a type.