Enum Function

pub enum Function {
    Known(u64, Option<FunctionName>),
    Named(FunctionName),
}

A function identifier used in Gordian Envelope expressions.

In Gordian Envelope, a function appears as the subject of an expression envelope, with its parameters as assertions on that envelope.

Functions can be identified in two ways:

1. By a numeric ID (for well-known functions)
2. By a string name (for application-specific or less common functions)

When encoded in CBOR, functions are tagged with #6.40006.

Examples

A numeric function:

use bc_envelope::prelude::*;

// Define a function with a numeric ID
let add_function = Function::new_known(1, Some("add".to_string()));

A named function:

use bc_envelope::prelude::*;

// Define a function with a string name
let verify_function = Function::new_named("verifySignature");

A function with static name:

use bc_envelope::prelude::*;

// Define a function with a numeric ID and static name
const ADD: Function = Function::new_with_static_name(1, "add");

Variants

Known(u64, Option<FunctionName>)

A well-known function identified by a numeric ID, with an optional name.

Named(FunctionName)

A function identified by a name.

Implementations

impl Function

pub fn new_known(value: u64, name: Option<String>) -> Self

Creates a new function with a numeric ID and an optional string name.

This creates a “known” function, which is identified primarily by its numeric ID. The optional name is used for display purposes.

Parameters

• value - The numeric ID of the function
• name - An optional name for the function

Returns

A new Function instance

Examples

use bc_envelope::prelude::*;

// Create a function with ID 1 and name "add"
let add_function = Function::new_known(1, Some("add".to_string()));

pub fn new_named(name: &str) -> Self

Creates a new function identified by a string name.

This creates a “named” function, which is identified by its string name. This method cannot be used to declare a function at compile-time, as it creates a dynamic string.

Parameters

• name - The string name of the function

Returns

A new Function instance

Examples

use bc_envelope::prelude::*;

// Create a named function
let verify_function = Function::new_named("verifySignature");

pub const fn new_with_static_name(value: u64, name: &'static str) -> Self

Creates a new function with a numeric ID and a static string name.

This creates a “known” function, which is identified primarily by its numeric ID. The static name is used for display purposes. This method can be used to declare a function at compile-time, as it uses a static string reference.

Parameters

• value - The numeric ID of the function
• name - A static string name for the function

Returns

A new Function instance

Examples

use bc_envelope::prelude::*;

// Define a function constant
const ADD: Function = Function::new_with_static_name(1, "add");

pub const fn new_static_named(name: &'static str) -> Self

Creates a new function identified by a static string name.

This creates a “named” function, which is identified by its string name. This method can be used to declare a function at compile-time, as it uses a static string reference.

Parameters

• name - A static string name for the function

Returns

A new Function instance

Examples

use bc_envelope::prelude::*;

// Define a named function constant
const VERIFY: Function = Function::new_static_named("verifySignature");

pub fn name(&self) -> String

Returns the display name of the function.

For known functions with a name, returns the name. For known functions without a name, returns the numeric ID as a string. For named functions, returns the name enclosed in quotes.

Returns

A string representation of the function name

Examples

use bc_envelope::prelude::*;

let add = Function::new_known(1, Some("add".to_string()));
assert_eq!(add.name(), "add");

let unknown = Function::new_known(42, None);
assert_eq!(unknown.name(), "42");

let verify = Function::new_named("verifySignature");
assert_eq!(verify.name(), "\"verifySignature\"");

pub fn named_name(&self) -> Option<String>

Returns the name of a named function, if available.

This method returns the raw string name for named functions, without quotes. For known functions (numeric IDs), it returns None.

Returns

An Option containing the function name string if this is a named function, or None if it’s a known (numeric) function.

Examples

use bc_envelope::prelude::*;

let add = Function::new_known(1, Some("add".to_string()));
assert_eq!(add.named_name(), None);

let verify = Function::new_named("verifySignature");
assert_eq!(verify.named_name(), Some("verifySignature".to_string()));

Trait Implementations

impl CBORTagged for Function

Implementation of the CBORTagged trait for Function.

Functions are tagged with #6.40006 (TAG_FUNCTION).

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags associated with this type.

impl CBORTaggedDecodable for Function

Implementation of the CBORTaggedDecodable trait for Function.

Unsigned integers are decoded as known functions. Text strings are decoded as named functions.

fn from_untagged_cbor(untagged_cbor: CBOR) -> Result<Self>

Creates an instance of this type by decoding it from untagged CBOR.

fn from_tagged_cbor(cbor: CBOR) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from tagged CBOR.

fn from_tagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded tagged CBOR.

fn from_untagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded untagged CBOR.

impl CBORTaggedEncodable for Function

Implementation of the CBORTaggedEncodable trait for Function.

Known functions are encoded as unsigned integers. Named functions are encoded as text strings.

fn untagged_cbor(&self) -> CBOR

Returns the untagged CBOR encoding of this instance.

fn tagged_cbor(&self) -> CBOR

Returns the tagged CBOR encoding of this instance.

fn tagged_cbor_data(&self) -> Vec<u8>

Returns the tagged value in CBOR binary representation.

impl Clone for Function

fn clone(&self) -> Function

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.

impl Display for Function

Implements display for Function.

Uses the description method with no functions store.

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

Formats the value using the given formatter.

impl EnvelopeEncodable for Function

Implements the EnvelopeEncodable trait for Function.

This allows a Function to be directly converted to an Envelope.

fn into_envelope(self) -> Envelope

Converts this value into a Gordian Envelope.

fn to_envelope(&self) -> Envelope

where Self: Clone,

Converts a reference to this value into a Gordian Envelope.

impl From<&Function> for Function

Allows creating a Function from a reference to a Function.

This clones the function.

fn from(function: &Function) -> Self

Converts to this type from the input type.

impl From<&str> for Function

Allows creating a Function from a string reference.

This creates a named function with the given name.

fn from(name: &str) -> Self

Converts to this type from the input type.

impl From<Function> for CBOR

Allows creating a CBOR value from a Function.

fn from(value: Function) -> Self

Converts to this type from the input type.

impl From<u64> for Function

Allows creating a Function from a u64.

This creates a known function with the given numeric ID and no name.

fn from(value: u64) -> Self

Converts to this type from the input type.

impl Hash for Function

Implementation of hash for Function.

Known functions are hashed by their numeric ID. Named functions are hashed by their name.

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 PartialEq for Function

Implementation of equality for Function.

Known functions are equal if they have the same numeric ID (names are ignored). Named functions are equal if they have the same name. Known and named functions are never equal to each other.

fn eq(&self, other: &Self) -> 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 TryFrom<CBOR> for Function

Allows creating a Function from a CBOR value.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(cbor: CBOR) -> Result<Self>

Performs the conversion.

impl TryFrom<Envelope> for Function

Implements conversion from Envelope to Function.

This attempts to extract a Function from an Envelope leaf.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(envelope: Envelope) -> Result<Self>

Performs the conversion.

impl Eq for Function