pocketstation 1.0.0

Source-aware desktop audio Session SDK
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::abi::session::abi::{PksSessionStatus, PksSessionStatusCode};

#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
pub enum AbiError {
    #[error("output pointer is null")]
    NullArgument,
    #[error("requested ABI major is unsupported")]
    UnsupportedAbiMajor,
    #[error("requested ABI minor is newer than this engine")]
    UnsupportedAbiMinor,
    #[error("record struct_size is smaller than required")]
    InvalidStructSize,
    #[error("handle is invalid")]
    InvalidHandle,
    #[error("handle is stale")]
    StaleHandle,
    #[error("handle table has no free slot")]
    NoCapacity,
    #[error("pointer alignment does not satisfy the record contract")]
    MisalignedPointer,
    #[error("argument is invalid")]
    InvalidArgument,
    #[error("handle belongs to another engine")]
    ForeignHandle,
    #[error("operation is invalid for the current lifecycle state")]
    InvalidLifecycleState,
    #[error("bounded queue is empty")]
    WouldBlock,
    #[error("native Session engine operation failed")]
    BackendFailure,
    #[error("operation was cancelled")]
    Cancelled,
    #[error("index is outside the bounded result")]
    IndexOutOfRange,
}

impl AbiError {
    pub const fn status(self) -> PksSessionStatus {
        match self {
            Self::NullArgument => PksSessionStatus::new(PksSessionStatusCode::NullArgument, 0),
            Self::UnsupportedAbiMajor => {
                PksSessionStatus::new(PksSessionStatusCode::UnsupportedAbiMajor, 0)
            }
            Self::UnsupportedAbiMinor => {
                PksSessionStatus::new(PksSessionStatusCode::UnsupportedAbiMinor, 0)
            }
            Self::InvalidStructSize => {
                PksSessionStatus::new(PksSessionStatusCode::InvalidStructSize, 0)
            }
            Self::InvalidHandle => PksSessionStatus::new(PksSessionStatusCode::InvalidHandle, 0),
            Self::StaleHandle => PksSessionStatus::new(PksSessionStatusCode::StaleHandle, 0),
            Self::NoCapacity => PksSessionStatus::new(PksSessionStatusCode::NoCapacity, 0),
            Self::MisalignedPointer => {
                PksSessionStatus::new(PksSessionStatusCode::MisalignedPointer, 0)
            }
            Self::InvalidArgument => {
                PksSessionStatus::new(PksSessionStatusCode::InvalidArgument, 0)
            }
            Self::ForeignHandle => PksSessionStatus::new(PksSessionStatusCode::ForeignHandle, 0),
            Self::InvalidLifecycleState => {
                PksSessionStatus::new(PksSessionStatusCode::InvalidLifecycleState, 0)
            }
            Self::WouldBlock => PksSessionStatus::new(PksSessionStatusCode::WouldBlock, 0),
            Self::BackendFailure => PksSessionStatus::new(PksSessionStatusCode::BackendFailure, 0),
            Self::Cancelled => PksSessionStatus::new(PksSessionStatusCode::Cancelled, 0),
            Self::IndexOutOfRange => {
                PksSessionStatus::new(PksSessionStatusCode::IndexOutOfRange, 0)
            }
        }
    }
}