Enum AddressError

pub enum AddressError {
    InvalidBech32String {
        invalid_value: String,
    },
    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: 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.

Variants

InvalidBech32String

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

Fields

invalid_value: String

The invalid Bech32 string that led to the error. Storing this string helps in diagnosing the specific input that failed to parse, facilitating easier troubleshooting.

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

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 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