Enum PluginError

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

Available on crate feature __plugin 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.

unsafe fn resolve( &self, pos: usize, resolver: <Self as Archive>::Resolver, out: *mut <Self as Archive>::Archived, )

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

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<PluginError, __D> for Archived<PluginError>

where String: Archive, Archived<String>: Deserialize<String, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<PluginError, __D::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: Fallible + ?Sized> Serialize<__S> for PluginError

where String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, __S::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