Enum novax_data::DataError

pub enum DataError {
    Address(AddressError),
    Utils(UtilsError),
}

Enumerates the centralized error handling types across different operations.

DataError serves as a unified error type that aggregates different error types from various operations into a single enum. This centralization facilitates error handling across different parts of the codebase.

Variants

• Address(AddressError): Encapsulates errors that occur during address-related operations, as represented by the AddressError enum.
• Utils(UtilsError): Encapsulates errors that occur within utility functions, as represented by the UtilsError enum.

Example

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

match data_error {
    DataError::Address(err) => println!("Address error: {:?}", err),
    DataError::Utils(err) => println!("Utils error: {:?}", err),
}

Variants

Address(AddressError)

Represents an error from address-related operations.

Utils(UtilsError)

Represents an error from utility functions.

Trait Implementations

impl Clone for DataError

fn clone(&self) -> DataError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataError

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 From<UtilsError> for DataError

Provides a conversion from UtilsError to DataError.

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

fn from(value: UtilsError) -> Self

Converts to this type from the input type.

impl PartialEq for DataError

fn eq(&self, other: &DataError) -> 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 DataError

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 DataError