Struct DelegateManifest 

#[non_exhaustive]
pub struct DelegateManifest {
    pub manifest_version: u16,
    pub lifecycle: Vec<LifecycleKind>,
    pub capabilities: Vec<Capability>,
}

What a delegate declares it wants from the node.

#[non_exhaustive] so fields can be added without a source break; build one with DelegateManifest::new.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

manifest_version: u16

Format version; see MANIFEST_VERSION.

lifecycle: Vec<LifecycleKind>

Lifecycle events the delegate wants delivered. The node never sends a LifecycleEvent of a kind that is not listed here.

capabilities: Vec<Capability>

Node-enforced capabilities the delegate asks the user for.

Implementations

impl DelegateManifest

pub fn new(lifecycle: Vec<LifecycleKind>, capabilities: Vec<Capability>) -> Self

A manifest at the current MANIFEST_VERSION.

pub fn wants_lifecycle(&self, kind: LifecycleKind) -> bool

Whether the manifest asks for lifecycle events of this kind.

pub fn wants_capability(&self, cap: Capability) -> bool

Whether the manifest asks for this capability.

pub fn known_capabilities(&self) -> Vec<Capability>

Known capabilities this manifest asks for, deduplicated, in declaration order. Unknown names are dropped.

pub fn to_bytes(&self) -> Vec<u8>

Serialize to the section payload.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, ManifestError>

Parse a section payload.

Tolerant of manifests written by newer stdlibs: unknown fields are ignored, a list field that is not an array (null, or any other shape) reads as empty, and a list entry that is not a name this reader knows (an unknown name, or a non-string value) reads as Unknown rather than failing the manifest, so the known entries next to it still count.

pub fn from_wasm(module: &[u8]) -> Result<Option<Self>, ManifestError>

Read the manifest from a raw WASM module (no version prefix).

Ok(None) means the module has no manifest section: a delegate that asked for nothing, which is every delegate built before manifests existed. Only the section headers are walked; nothing is executed or validated beyond what locating the section needs.

Trait Implementations

impl Clone for DelegateManifest

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DelegateManifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DelegateManifest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DelegateManifest

impl PartialEq for DelegateManifest

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DelegateManifest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DelegateManifest