lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

error.rs (11334B)

      1 //! Normalized transport contract errors.
      2 
      3 use core::fmt;
      4 
      5 /// Transport contract failure.
      6 #[derive(Clone, Debug, PartialEq, Eq)]
      7 pub enum Error {
      8     UnsupportedOperation,
      9     EmptyTransportKind,
     10     InvalidTransportKind,
     11     EmptyTargetUri,
     12     InvalidTargetUri,
     13     EmptyTargetScope,
     14     InvalidTargetScope,
     15     EmptyTargetLabel,
     16     InvalidTargetLabel,
     17     EmptyTargetSet,
     18     TargetSetTooLarge,
     19     DuplicateTargetFingerprint,
     20     InvalidTargetFingerprint,
     21     EmptyFetchRequestId,
     22     InvalidFetchRequestId,
     23     InvalidFetchLimit,
     24     InvalidFetchDeadline,
     25     FetchSelectorTooLarge,
     26     DuplicateFetchKind,
     27     DuplicateFetchAuthor,
     28     InvalidFetchTagKey,
     29     InvalidFetchTagValue,
     30     DuplicateFetchTagValue,
     31     InvalidFetchTimeRange,
     32     EmptyFetchCursor,
     33     InvalidFetchCursor,
     34     InvalidObservedAt,
     35     UnexpectedFetchEvent,
     36     UnexpectedFetchProvenance,
     37     UnexpectedFetchTargetOutcome,
     38     DuplicateFetchTargetOutcome,
     39     FetchPageLimitExceeded,
     40     FetchPageRequestMismatch,
     41     EmptySubscriptionRequestId,
     42     InvalidSubscriptionRequestId,
     43     InvalidSubscriptionLimit,
     44     InvalidSubscriptionDeadline,
     45     SubscriptionCheckpointSetTooLarge,
     46     UnexpectedSubscriptionCheckpoint,
     47     DuplicateSubscriptionCheckpoint,
     48     UnexpectedSubscriptionEvent,
     49     SubscriptionEventCheckpointMismatch,
     50     SubscriptionEndLimitExceeded,
     51     InvalidSubscriptionEnd,
     52     SubscriptionEndRequestMismatch,
     53     SubscriptionUnavailable,
     54     InvalidSatisfactionPolicy,
     55     EmptyRequiredTargetSet,
     56     DuplicateRequiredTargetFingerprint,
     57     RequiredTargetNotRequested,
     58     EmptyDeliveryRequestId,
     59     InvalidDeliveryRequestId,
     60     InvalidDeliveryTimestamp,
     61     InvalidDeliveryDeadline,
     62     InvalidDeliveryTargetSelection,
     63     InvalidDeliveryOutcome,
     64     UnexpectedDeliveryTargetReceipt,
     65     DuplicateDeliveryTargetReceipt,
     66     MissingDeliveryTargetReceipt,
     67     DeliveryTargetReceiptStatusMismatch,
     68     DeliveryTargetReceiptAttemptMismatch,
     69     TransportOutcomeStatusMismatch,
     70     DeliveryReceiptRequestIdMismatch,
     71     DeliveryReceiptTargetSetMismatch,
     72     EmptyPayloadId,
     73     InvalidPayloadId,
     74     EmptyPayloadLabel,
     75     InvalidPayloadLabel,
     76     EmptyPayloadBytes,
     77     InvalidPayloadBytes,
     78     InvalidPayloadDigest,
     79     PayloadDigestMismatch,
     80 }
     81 
     82 impl fmt::Display for Error {
     83     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     84         match self {
     85             Self::UnsupportedOperation => f.write_str("transport operation is unsupported"),
     86             Self::EmptyTransportKind => f.write_str("transport kind is empty"),
     87             Self::InvalidTransportKind => f.write_str("transport kind is invalid"),
     88             Self::EmptyTargetUri => f.write_str("transport target URI is empty"),
     89             Self::InvalidTargetUri => f.write_str("transport target URI is invalid"),
     90             Self::EmptyTargetScope => f.write_str("transport target scope is empty"),
     91             Self::InvalidTargetScope => f.write_str("transport target scope is invalid"),
     92             Self::EmptyTargetLabel => f.write_str("transport target label is empty"),
     93             Self::InvalidTargetLabel => f.write_str("transport target label is invalid"),
     94             Self::EmptyTargetSet => f.write_str("transport target set is empty"),
     95             Self::TargetSetTooLarge => f.write_str("transport target set exceeds its item limit"),
     96             Self::DuplicateTargetFingerprint => {
     97                 f.write_str("transport target set contains duplicate fingerprints")
     98             }
     99             Self::InvalidTargetFingerprint => {
    100                 f.write_str("transport target fingerprint is invalid")
    101             }
    102             Self::EmptyFetchRequestId => f.write_str("transport fetch request id is empty"),
    103             Self::InvalidFetchRequestId => f.write_str("transport fetch request id is invalid"),
    104             Self::InvalidFetchLimit => f.write_str("transport fetch limit is invalid"),
    105             Self::InvalidFetchDeadline => f.write_str("transport fetch deadline is invalid"),
    106             Self::FetchSelectorTooLarge => {
    107                 f.write_str("transport fetch selector exceeds its item limit")
    108             }
    109             Self::DuplicateFetchKind => {
    110                 f.write_str("transport fetch selector contains a duplicate event kind")
    111             }
    112             Self::DuplicateFetchAuthor => {
    113                 f.write_str("transport fetch selector contains a duplicate author")
    114             }
    115             Self::InvalidFetchTagKey => f.write_str("transport fetch selector tag key is invalid"),
    116             Self::InvalidFetchTagValue => {
    117                 f.write_str("transport fetch selector tag value is invalid")
    118             }
    119             Self::DuplicateFetchTagValue => {
    120                 f.write_str("transport fetch selector contains a duplicate tag value")
    121             }
    122             Self::InvalidFetchTimeRange => {
    123                 f.write_str("transport fetch selector time range is invalid")
    124             }
    125             Self::EmptyFetchCursor => f.write_str("transport fetch cursor is empty"),
    126             Self::InvalidFetchCursor => f.write_str("transport fetch cursor is invalid"),
    127             Self::InvalidObservedAt => f.write_str("transport event observation time is invalid"),
    128             Self::UnexpectedFetchEvent => {
    129                 f.write_str("transport fetch page contains an event outside its selector")
    130             }
    131             Self::UnexpectedFetchProvenance => {
    132                 f.write_str("transport fetch page contains unexpected event provenance")
    133             }
    134             Self::UnexpectedFetchTargetOutcome => {
    135                 f.write_str("transport fetch page contains an unexpected target outcome")
    136             }
    137             Self::DuplicateFetchTargetOutcome => {
    138                 f.write_str("transport fetch page contains a duplicate target outcome")
    139             }
    140             Self::FetchPageLimitExceeded => {
    141                 f.write_str("transport fetch page exceeds its requested event limit")
    142             }
    143             Self::FetchPageRequestMismatch => {
    144                 f.write_str("transport fetch page does not match its request")
    145             }
    146             Self::EmptySubscriptionRequestId => {
    147                 f.write_str("transport subscription request id is empty")
    148             }
    149             Self::InvalidSubscriptionRequestId => {
    150                 f.write_str("transport subscription request id is invalid")
    151             }
    152             Self::InvalidSubscriptionLimit => {
    153                 f.write_str("transport subscription event limit is invalid")
    154             }
    155             Self::InvalidSubscriptionDeadline => {
    156                 f.write_str("transport subscription deadline is invalid")
    157             }
    158             Self::SubscriptionCheckpointSetTooLarge => {
    159                 f.write_str("transport subscription checkpoint set exceeds its target limit")
    160             }
    161             Self::UnexpectedSubscriptionCheckpoint => {
    162                 f.write_str("transport subscription contains an unexpected checkpoint")
    163             }
    164             Self::DuplicateSubscriptionCheckpoint => {
    165                 f.write_str("transport subscription contains a duplicate checkpoint")
    166             }
    167             Self::UnexpectedSubscriptionEvent => {
    168                 f.write_str("transport subscription contains an unexpected event")
    169             }
    170             Self::SubscriptionEventCheckpointMismatch => {
    171                 f.write_str("transport subscription event checkpoint does not match provenance")
    172             }
    173             Self::SubscriptionEndLimitExceeded => {
    174                 f.write_str("transport subscription exceeded its requested event limit")
    175             }
    176             Self::InvalidSubscriptionEnd => {
    177                 f.write_str("transport subscription terminal result is invalid")
    178             }
    179             Self::SubscriptionEndRequestMismatch => {
    180                 f.write_str("transport subscription result does not match its request")
    181             }
    182             Self::SubscriptionUnavailable => f.write_str("transport subscription is unavailable"),
    183             Self::InvalidSatisfactionPolicy => {
    184                 f.write_str("transport satisfaction policy is invalid")
    185             }
    186             Self::EmptyRequiredTargetSet => f.write_str("transport required target set is empty"),
    187             Self::DuplicateRequiredTargetFingerprint => {
    188                 f.write_str("transport required target set contains duplicate fingerprints")
    189             }
    190             Self::RequiredTargetNotRequested => {
    191                 f.write_str("transport required target was not requested")
    192             }
    193             Self::EmptyDeliveryRequestId => f.write_str("transport delivery request id is empty"),
    194             Self::InvalidDeliveryRequestId => {
    195                 f.write_str("transport delivery request id is invalid")
    196             }
    197             Self::InvalidDeliveryTimestamp => {
    198                 f.write_str("transport delivery timestamp is invalid")
    199             }
    200             Self::InvalidDeliveryDeadline => f.write_str("transport delivery deadline is invalid"),
    201             Self::InvalidDeliveryTargetSelection => {
    202                 f.write_str("transport delivery target selection is not an exact subset")
    203             }
    204             Self::InvalidDeliveryOutcome => f.write_str("transport delivery outcome is invalid"),
    205             Self::UnexpectedDeliveryTargetReceipt => {
    206                 f.write_str("transport delivery receipt contains an unexpected target")
    207             }
    208             Self::DuplicateDeliveryTargetReceipt => {
    209                 f.write_str("transport delivery receipt contains a duplicate target")
    210             }
    211             Self::MissingDeliveryTargetReceipt => {
    212                 f.write_str("transport delivery receipt is missing a requested target")
    213             }
    214             Self::DeliveryTargetReceiptStatusMismatch => {
    215                 f.write_str("transport delivery target receipt status does not match its outcome")
    216             }
    217             Self::DeliveryTargetReceiptAttemptMismatch => {
    218                 f.write_str("transport delivery target receipt attempt evidence is incoherent")
    219             }
    220             Self::TransportOutcomeStatusMismatch => {
    221                 f.write_str("transport outcome status does not match its outcome kind")
    222             }
    223             Self::DeliveryReceiptRequestIdMismatch => {
    224                 f.write_str("transport delivery receipt request id does not match its request")
    225             }
    226             Self::DeliveryReceiptTargetSetMismatch => {
    227                 f.write_str("transport delivery receipt target set does not match its request")
    228             }
    229             Self::EmptyPayloadId => f.write_str("transport payload id is empty"),
    230             Self::InvalidPayloadId => f.write_str("transport payload id is invalid"),
    231             Self::EmptyPayloadLabel => f.write_str("transport payload label is empty"),
    232             Self::InvalidPayloadLabel => f.write_str("transport payload label is invalid"),
    233             Self::EmptyPayloadBytes => f.write_str("transport payload bytes are empty"),
    234             Self::InvalidPayloadBytes => f.write_str("transport payload bytes are invalid"),
    235             Self::InvalidPayloadDigest => f.write_str("transport payload digest is invalid"),
    236             Self::PayloadDigestMismatch => {
    237                 f.write_str("transport payload digest does not match payload bytes")
    238             }
    239         }
    240     }
    241 }