2023-04-27 22:45:09 +00:00
|
|
|
// Copyright 2023 The Pigweed Authors
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
|
|
// the License at
|
|
|
|
//
|
|
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
// License for the specific language governing permissions and limitations under
|
|
|
|
// the License.
|
|
|
|
|
|
|
|
//! # pw_status
|
|
|
|
//!
|
|
|
|
//! Rust error types using error codes compatible with Pigweed's
|
|
|
|
//! [pw_status](https://pigweed.dev/pw_status). In order to keep the interface
|
|
|
|
//! idiomatic for Rust, `PW_STATUS_OK` is omitted from the Error enum and a
|
|
|
|
//! `StatusCode` trait is provided to turn a `Result` into a canonical
|
|
|
|
//! status code.
|
|
|
|
//!
|
|
|
|
//! For an in depth explanation of the values of the `Error` enum, see
|
|
|
|
//! the [Pigweed status codes documentation](https://pigweed.dev/pw_status/#status-codes).
|
|
|
|
//!
|
|
|
|
//! # Example
|
|
|
|
//!
|
|
|
|
//! ```
|
|
|
|
//! use pw_status::{Error, Result};
|
|
|
|
//!
|
|
|
|
//! fn div(numerator: u32, denominator: u32) -> Result<u32> {
|
|
|
|
//! if denominator == 0 {
|
|
|
|
//! Err(Error::FailedPrecondition)
|
|
|
|
//! } else {
|
|
|
|
//! Ok(numerator / denominator)
|
|
|
|
//! }
|
|
|
|
//! }
|
|
|
|
//!
|
|
|
|
//! assert_eq!(div(4, 2), Ok(2));
|
|
|
|
//! assert_eq!(div(4, 0), Err(Error::FailedPrecondition));
|
|
|
|
//! ```
|
|
|
|
|
2023-06-27 22:10:41 +00:00
|
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
2023-04-27 22:45:09 +00:00
|
|
|
|
|
|
|
/// Status code for no error.
|
|
|
|
pub const OK: u32 = 0;
|
|
|
|
|
|
|
|
#[cfg_attr(feature = "std", derive(Debug))]
|
|
|
|
#[derive(Eq, PartialEq)]
|
|
|
|
/// Error type compatible with Pigweed's [pw_status](https://pigweed.dev/pw_status).
|
|
|
|
///
|
|
|
|
/// For an in depth explanation of the values of the `Error` enum, see
|
|
|
|
/// the [Pigweed status codes documentation](https://pigweed.dev/pw_status/#status-codes).
|
|
|
|
pub enum Error {
|
|
|
|
Cancelled = 1,
|
|
|
|
Unknown = 2,
|
|
|
|
InvalidArgument = 3,
|
|
|
|
DeadlineExceeded = 4,
|
|
|
|
NotFound = 5,
|
|
|
|
AlreadyExists = 6,
|
|
|
|
PermissionDenied = 7,
|
|
|
|
ResourceExhausted = 8,
|
|
|
|
FailedPrecondition = 9,
|
|
|
|
Aborted = 10,
|
|
|
|
OutOfRange = 11,
|
|
|
|
Unimplemented = 12,
|
|
|
|
Internal = 13,
|
|
|
|
Unavailable = 14,
|
|
|
|
DataLoss = 15,
|
|
|
|
Unauthenticated = 16,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub type Result<T> = core::result::Result<T, Error>;
|
|
|
|
|
|
|
|
/// Convert a Result into an status code.
|
|
|
|
pub trait StatusCode {
|
|
|
|
/// Return a pigweed compatible status code.
|
|
|
|
fn status_code(self) -> u32;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> StatusCode for Result<T> {
|
|
|
|
fn status_code(self) -> u32 {
|
|
|
|
match self {
|
|
|
|
Ok(_) => OK,
|
|
|
|
Err(e) => e as u32,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
|
|
fn test_status_code() {
|
|
|
|
assert_eq!(Result::Ok(()).status_code(), 0);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Cancelled).status_code(), 1);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Unknown).status_code(), 2);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::InvalidArgument).status_code(), 3);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::DeadlineExceeded).status_code(), 4);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::NotFound).status_code(), 5);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::AlreadyExists).status_code(), 6);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::PermissionDenied).status_code(), 7);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::ResourceExhausted).status_code(), 8);
|
|
|
|
assert_eq!(
|
|
|
|
Result::<()>::Err(Error::FailedPrecondition).status_code(),
|
|
|
|
9
|
|
|
|
);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Aborted).status_code(), 10);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::OutOfRange).status_code(), 11);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Unimplemented).status_code(), 12);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Internal).status_code(), 13);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Unavailable).status_code(), 14);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::DataLoss).status_code(), 15);
|
|
|
|
assert_eq!(Result::<()>::Err(Error::Unauthenticated).status_code(), 16);
|
|
|
|
}
|
|
|
|
}
|