mod byte_fallback;
mod byte_level;
mod replace;
use crate::json_structs::DecoderConfig;
pub use self::byte_fallback::ByteFallbackDecoder;
pub use self::byte_level::ByteLevelDecoder;
pub use self::replace::ReplaceDecoder;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("invalid config value: {0}")]
Json(#[from] serde_json::Error),
#[error("regex error: {0}")]
Regex(#[from] fancy_regex::Error),
}
impl From<crate::normalizers::Error> for Error {
fn from(e: crate::normalizers::Error) -> Self {
match e {
crate::normalizers::Error::Json(j) => Self::Json(j),
crate::normalizers::Error::Regex(r) => Self::Regex(r),
}
}
}
#[derive(Debug)]
pub enum Decoder {
ByteFallback(ByteFallbackDecoder),
ByteLevel(ByteLevelDecoder),
Replace(ReplaceDecoder),
Sequence(Vec<Decoder>),
}
impl Decoder {
pub fn from_config(config: DecoderConfig) -> Result<Self, Error> {
match config {
DecoderConfig::ByteFallback => Ok(Self::ByteFallback(ByteFallbackDecoder)),
DecoderConfig::ByteLevel => Ok(Self::ByteLevel(ByteLevelDecoder)),
DecoderConfig::Replace { pattern, content } => Ok(Self::Replace(
ReplaceDecoder::from_config(pattern, content)?,
)),
DecoderConfig::Fuse => Ok(Self::Sequence(vec![])), DecoderConfig::Sequence { decoders } => {
let steps = decoders
.into_iter()
.map(Self::from_config)
.collect::<Result<Vec<_>, _>>()?;
Ok(Self::Sequence(steps))
}
}
}
pub fn decode_chain(&self, tokens: Vec<String>) -> Result<Vec<String>, Error> {
match self {
Self::ByteFallback(bf) => Ok(bf.decode_chain(tokens)),
Self::ByteLevel(bl) => Ok(bl.decode_chain(tokens)),
Self::Replace(repl) => Ok(repl.decode_chain(tokens)),
Self::Sequence(steps) => {
let mut current = tokens;
for step in steps {
current = step.decode_chain(current)?;
}
Ok(current)
}
}
}
pub fn decode(&self, tokens: Vec<String>) -> Result<String, Error> {
let result = self.decode_chain(tokens)?;
Ok(result.concat())
}
}