Enum novax_data::AddressError

pub enum AddressError {
    InvalidBech32String,
    CannotConvertToBech32String,
}

Enumerates the errors that can occur within operations related to the Address struct.

This enum encapsulates specific error cases encountered when working with the Address struct, such as converting to and from Bech32 string representation.

When an AddressError occurs, it can be converted into a DataError which serves as a centralized error type for broader error handling.

Variants

• InvalidBech32String: This error occurs when attempting to construct an Address from an invalid Bech32 string.
• CannotConvertToBech32String: This error occurs when attempting to convert an Address to its Bech32 string representation.

Example

let error = AddressError::InvalidBech32String;
let data_error: DataError = error.into();

Variants

InvalidBech32String

Represents an error case where an invalid Bech32 string is provided.

CannotConvertToBech32String

Represents an error case where an Address cannot be converted to its Bech32 string representation.

Trait Implementations

impl Clone for AddressError

fn clone(&self) -> AddressError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AddressError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AddressError

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AddressError> for DataError

Provides a conversion from AddressError to DataError.

This implementation allows for an AddressError to be converted into a DataError, facilitating centralized error handling.

fn from(value: AddressError) -> Self

Converts to this type from the input type.

impl PartialEq for AddressError

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AddressError

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 AddressError