Struct acme_core::Backend

pub struct Backend<S: Default + Stateful> {
    pub count: usize,
    pub name: String,
    pub namespace: String,
    pub state: Arc<S>,
    pub symbol: String,
    pub version: String,
}

Fields

count: usize

name: String

namespace: String

state: Arc<S>

symbol: String

version: String

Implementations

impl<S: Default + Stateful> Backend<S>

pub fn new(
    name: String,
    namespace: String,
    symbol: String,
    version: Option<String>
) -> Self

Examples found in repository

src/backend.rs (lines 70-75)

    fn default() -> Self {
        Self::new(
            Default::default(),
            Default::default(),
            Default::default(),
            None,
        )
    }

Trait Implementations

impl<S: Default + Stateful> BaseApplication for Backend<S>

fn namespace(&self) -> String

fn application(&self) -> &Self

impl<S: Default + Stateful> BaseObject for Backend<S>

fn count(&self) -> usize

fn name(&self) -> String

fn symbol(&self) -> String

fn slug(&self) -> String

impl<S: Clone + Default + Stateful> Clone for Backend<S>

fn clone(&self) -> Backend<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Default + Stateful> Debug for Backend<S>

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

Formats the value using the given formatter.

impl<S: Default + Stateful> Default for Backend<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Hash + Default + Stateful> Hash for Backend<S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: PartialEq + Default + Stateful> PartialEq<Backend<S>> for Backend<S>

fn eq(&self, other: &Backend<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Default + Stateful> Stateful for Backend<S>

fn boxed(self: Box<Self>) -> Box<Self>

fn state(self) -> Selfwhere
    Self: Sized,

fn threaded(self: Arc<Self>) -> Arc<Self>

impl<S: Default + Stateful> Versionable for Backend<S>

type Error = Box<dyn Error + Sync + Send + 'static, Global>

fn update(&mut self) -> Result<(), Box<Self::Error>>

fn version(&self) -> String

impl<S: Eq + Default + Stateful> Eq for Backend<S>

impl<S: Default + Stateful> StructuralEq for Backend<S>

impl<S: Default + Stateful> StructuralPartialEq for Backend<S>