Enum PluginError

#[non_exhaustive]
#[repr(u32)]
pub enum PluginError {
    SizeInteropFailure(String),
    Deserialize(String),
    Serialize(String),
}

Available on crate feature __common only.

Enum for possible errors while running transform via plugin.

This error indicates internal operation failure either in plugin_runner or plugin_macro. Plugin’s transform fn itself does not allow to return error - instead it should use provided handler to emit corresponding error to the host.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SizeInteropFailure(String)

Occurs when failed to convert size passed from host / guest into usize or similar for the conversion. This is an internal error rasied via plugin_macro, normally plugin author should not raise this manually.

Deserialize(String)

Occurs when failed to reconstruct a struct from Serialized.

Serialize(String)

Occurs when failed to serialize a struct into Serialized. Unlike deserialize error, this error cannot forward any context for the raw bytes: when serialize failed, there’s nothing we can pass between runtime.

Trait Implementations

impl Archive for PluginError

where String: Archive,

type Archived = ArchivedPluginError

The archived representation of this type.

type Resolver = PluginErrorResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <PluginError as Archive>::Resolver, out: Place<<PluginError as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<__C> CheckBytes<__C> for PluginError

where __C: Fallible + ?Sized, <__C as Fallible>::Error: Source, String: CheckBytes<__C>,

unsafe fn check_bytes( value: *const PluginError, context: &mut __C, ) -> Result<(), <__C as Fallible>::Error>

Checks whether the given pointer points to a valid value within the given context.

impl Clone for PluginError

fn clone(&self) -> PluginError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PluginError

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

Formats the value using the given formatter.

impl<__D> Deserialize<PluginError, __D> for <PluginError as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PluginError, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for PluginError

fn eq(&self, other: &PluginError) -> 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<__S> Serialize<__S> for PluginError

where __S: Fallible + ?Sized, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PluginError as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for PluginError

impl StructuralPartialEq for PluginError