Enum foxbox_taxonomy::api::InternalError [−] [src]

pub enum InternalError {
    NoSuchGetter(Id<Getter>),
    NoSuchSetter(Id<Setter>),
    NoSuchService(Id<ServiceId>),
    NoSuchAdapter(Id<AdapterId>),
    DuplicateGetter(Id<Getter>),
    DuplicateSetter(Id<Setter>),
    DuplicateService(Id<ServiceId>),
    DuplicateAdapter(Id<AdapterId>),
    ConflictingAdapter(Id<AdapterId>, Id<AdapterId>),
    GenericError(String),
    InvalidInitialService,
}

Variants

NoSuchGetter

Attempting to fetch or watch a getter that isn't registered.

NoSuchSetter

Attempting to send values to a setter that isn't registered.

NoSuchService

Attempting to access a service that isn't registered.

NoSuchAdapter

Attempting to access an adapter that isn't registered.

DuplicateGetter

Attempting to register a getter with an id that is already used.

DuplicateSetter

Attempting to register a setter with an id that is already used.

DuplicateService

Attempting to register a service with an id that is already used.

DuplicateAdapter

Attempting to register an adapter with an id that is already used.

ConflictingAdapter

Attempting to register a channel with an adapter that doesn't match that of its service.

GenericError

Open question: Individual adapters will have errors of many adapter-specific types. How do we make this best represent those?

InvalidInitialService

Attempting to register a service in an invalid initial state. Typically, a service that pretends that it already has channels.

Trait Implementations

impl Serialize for InternalError

fn serialize<__S>(&self, serializer: &mut __S) -> Result<(), __S::Error> where __S: Serializer

impl Deserialize for InternalError

fn deserialize<__D>(deserializer: &mut __D) -> Result<InternalError, __D::Error> where __D: Deserializer

Derived Implementations

impl Clone for InternalError

fn clone(&self) -> InternalError

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

impl Debug for InternalError

fn fmt(&self, __arg_0: &mut Formatter) -> Result