Struct StateContainer

pub struct StateContainer<S, T>
where
    S: StateResolver<T>,
    T: Clone,
{ /* private fields */ }

This is what is used internally take care of input and manage flushing and handling retries.

Implementations

impl<S, T> StateContainer<S, T>

where S: StateResolver<T>, T: Clone,

pub fn feed(&mut self, input: &T)

Takes the log events and processes it in the state. Note that it does not guarantee that the event will be processed immediately. In some situations the event will be queued when the state things it is better able to process the event, but it doesn’t do this automatically. For those events to be processed, you need to call StateContainer::flush. This will go through the remaining events and tries to process them.

pub fn flush(&mut self)

Processes any left-over events that were scheduled for later processing. Call this sparingly especially not while you’re also still reading a lot of events through StateContainer::feed as that will likely cause performance issues.

Trait Implementations

impl<S, T> Debug for StateContainer<S, T>

where S: StateResolver<T> + Debug, T: Clone,

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

Formats the value using the given formatter.

impl<S, T> Default for StateContainer<S, T>

where S: StateResolver<T> + Default, T: Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<S, T> DerefMut for StateContainer<S, T>

where S: StateResolver<T>, T: Clone,

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

Mutably dereferences the value.

impl<'de, S, T> Deserialize<'de> for StateContainer<S, T>

where S: StateResolver<T> + Deserialize<'de>, T: Clone,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, T> From<S> for StateContainer<S, T>

where S: StateResolver<T>, T: Clone,

fn from(value: S) -> Self

Converts to this type from the input type.

impl<S, T> Serialize for StateContainer<S, T>

where S: StateResolver<T> + Serialize, T: Clone,

fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>

where Se: Serializer,

Serialize this value into the given Serde serializer.

impl<S, T> Deref for StateContainer<S, T>

where S: StateResolver<T>, T: Clone,

type Target = S

The resulting type after dereferencing.

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

Dereferences the value.