Struct ascom_alpaca::ASCOMErrorCode

pub struct ASCOMErrorCode(/* private fields */);

Alpaca representation of an ASCOM error code.

Implementations

impl ASCOMErrorCode

pub const fn new_for_driver(driver_code: u16) -> Self

Generate ASCOM error code from a zero-based driver error code.

Will panic if the driver error code is larger than the maximum allowed (2815).

You’ll typically want to define an enum for your driver errors and use this in a single place - in the From conversion from your driver error type to the ASCOMError.

Example

use ascom_alpaca::{ASCOMError, ASCOMErrorCode};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum MyDriverError {
    #[error("Port communication error: {0}")]
    PortError(#[from] std::io::Error),
    #[error("Initialization error: {0}")]
    InitializationError(String),
}

// this allows you to then use `my_driver.method()?` when implementing Alpaca traits
// and it will convert your driver error to an ASCOM error automatically
impl From<MyDriverError> for ASCOMError {
    fn from(error: MyDriverError) -> Self {
        ASCOMError::new(
            ASCOMErrorCode::new_for_driver(match error {
                MyDriverError::PortError(_) => 0,
                MyDriverError::InitializationError(_) => 1,
            }),
            error,
        )
    }
}

pub const fn as_driver_error(self) -> Result<u16, u16>

Get the driver-specific error code.

Returns Ok with 0-based driver error code if this is a driver error. Returns Err with raw error code if not a driver error.

pub const fn raw(self) -> u16

Get the raw error code.

impl ASCOMErrorCode

pub const OK: Self = _

pub const ACTION_NOT_IMPLEMENTED: Self = _

The requested action is not implemented in this driver

pub const INVALID_OPERATION: Self = _

The requested operation can not be undertaken at this time

pub const INVALID_VALUE: Self = _

Invalid value

pub const INVALID_WHILE_PARKED: Self = _

The attempted operation is invalid because the mount is currently in a Parked state

pub const INVALID_WHILE_SLAVED: Self = _

The attempted operation is invalid because the mount is currently in a Slaved state

pub const NOT_CONNECTED: Self = _

The communications channel is not connected

pub const NOT_IMPLEMENTED: Self = _

Property or method not implemented

pub const NOT_IN_CACHE: Self = _

The requested item is not present in the ASCOM cache

pub const SETTINGS: Self = _

Settings error

pub const UNSPECIFIED: Self = _

Unspecified error

pub const VALUE_NOT_SET: Self = _

A value has not been set

Trait Implementations

impl Clone for ASCOMErrorCode

fn clone(&self) -> ASCOMErrorCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ASCOMErrorCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ASCOMErrorCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ASCOMErrorCode

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

Formats the value using the given formatter.

impl PartialEq for ASCOMErrorCode

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<u16> for ASCOMErrorCode

fn try_from(raw: u16) -> Result<Self>

Convert a raw error code into an ASCOMErrorCode if it’s in the valid range.

type Error = Report

The type returned in the event of a conversion error.

impl Copy for ASCOMErrorCode

impl Eq for ASCOMErrorCode

impl StructuralEq for ASCOMErrorCode

impl StructuralPartialEq for ASCOMErrorCode