Struct docuglot::Tongue

pub struct Tongue { /* fields omitted */ }

Manages all of the Translators.

Implementations

impl Tongue

#[must_use]pub fn new(root_dir: &Url) -> Self

Creates a new Tongue.

pub fn join(&mut self)

Joins the thread.

Trait Implementations

impl Consumer for Tongue

type Good = ServerStatement

The type of the item being consumed.

type Error = <PermanentQueue<ServerStatement> as Consumer>::Error

The type of the error that could be thrown during consumption.

fn consume(&self) -> Result<Self::Good, ConsumeFailure<Self::Error>>

Retrieves the next good from the market without blocking.

fn consume_all(&self) -> Result<Vec<Self::Good>, Self::Error>

Retrieves all goods held in the market without blocking.

fn demand(&self) -> Result<Self::Good, Self::Error>

Retrieves the next good from the market, blocking until one is available.

fn adapt<G, F>(self) -> Adapter<Self, G, F>

Creates an Adapter that converts each consumption by self to the appropriate G or F.

impl Debug for Tongue

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

Formats the value using the given formatter.

impl Producer for Tongue

type Good = ClientStatement

The type of the item being produced.

type Error = <PermanentQueue<ClientStatement> as Producer>::Error

The type of the error that could be thrown during production.

fn produce(&self, good: Self::Good) -> Result<(), ProduceFailure<Self::Error>>

Stores good in the market without blocking.

fn produce_or_recall(
    &self,
    good: Self::Good
) -> Result<(), Recall<Self::Good, Self::Error>> where
    Self::Good: Clone,
    Self::Good: Debug,
    Self::Good: Display, 

Stores good in the market without blocking, returning the good on failure.

fn produce_all(
    &self,
    goods: Vec<Self::Good>
) -> Result<(), ProduceFailure<Self::Error>>

Stores each good in goods in the market without blocking.

fn force(&self, good: Self::Good) -> Result<(), Self::Error> where
    Self::Good: Clone,
    Self::Good: Debug,
    Self::Good: Display,
    Self::Error: 'static, 

Stores good in the market, blocking until space is available.

fn force_all(&self, goods: Vec<Self::Good>) -> Result<(), Self::Error> where
    Self::Good: Clone,
    Self::Good: Debug,
    Self::Good: Display,
    Self::Error: 'static, 

Stores every good in goods, blocking until space is available.