Struct Translator

pub struct Translator {
    pub source: String,
    pub target: String,
    pub engine: Engine,
    pub proxies: Vec<Proxy>,
}

A Translator

 use deeptrans::Translator;

 let mut translator = Translator::new();
 let translation =
     translator.translate("Texto a traducir").await;

 println!("{translation}");

Fields

source: String

target: String

engine: Engine

proxies: Vec<Proxy>

Implementations

impl Translator

pub fn new(source: &str, target: &str) -> Self

pub fn with_engine(source: &str, target: &str, engine: Engine) -> Self

pub async fn translate(&self, text: &str) -> Result<Value, Error>

pub async fn translate_file(&self, path: &str) -> Result<Value, Error>

translate directly from file

pub async fn translate_batch( &self, batch: &Vec<String>, ) -> Vec<Result<Value, Error>>

Translate batch of text

Methods from Deref<Target = Engine>

pub fn base_url(&self) -> String

pub fn name(&self) -> &str

pub fn supported_languages(&self) -> LanguagesToCodes

Trait Implementations

impl Clone for Translator

fn clone(&self) -> Translator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Translator

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

Formats the value using the given formatter.

impl Default for Translator

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Translator

type Target = Engine

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Translator

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Translator

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Translator

fn eq(&self, rhl: &Self) -> 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 Serialize for Translator

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Translator