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
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

//! Error handling module

use std::fmt;
use std::error::Error as StdError;
use std::ffi::CStr;
use std::os::raw::c_int;
use faiss_sys::*;

/// Type alias for results of functions in this crate.
pub type Result<T> = ::std::result::Result<T, Error>;

/// The main error type.
#[derive(Debug, Clone, PartialEq)]
pub enum Error {
    /// The error came from a native Faiss exception.
    Native(NativeError),
    /// Invalid index type cast. 
    BadCast,
    /// Invalid index description.
    IndexDescription,
    /// Invalid file path.
    BadFilePath,
}

impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(self.description())
    }
}

impl StdError for Error {
    fn description(&self) -> &str {
        match *self {
            Error::Native(ref e) => &e.msg,
            Error::BadCast => "Invalid index type cast",
            Error::IndexDescription => "Invalid index description",
            Error::BadFilePath => "Invalid file path",
        }
    }
}

/// An error derived from a native Faiss exception.
#[derive(Debug, Clone, PartialEq)]
pub struct NativeError {
    /// The error code retrieved from the C API
    code: c_int,
    /// The exception's message
    msg: String,
}

impl NativeError {
    /// Getter for the internal error code.
    pub fn code(&self) -> c_int {
        self.code
    }

    /// Getter for the exception's message. Same as `description()`.
    pub fn msg(&self) -> &str {
        &self.msg
    }
}

impl NativeError {
    /// Create a native error value by taking the error from
    /// the last failed operation.
    ///
    /// # Panics
    ///
    /// The operation is meant to be used immediately after
    /// a operation which returned a non-zero error code.
    /// This function might panic if no operation was made
    /// or the last operation was successful.
    pub fn from_last_error(code: c_int) -> Self {
        unsafe {
            let e: *const _ = faiss_get_last_error();
            assert!(!e.is_null());
            let cstr = CStr::from_ptr(e);
            let msg: String = cstr.to_string_lossy().into_owned();
            NativeError { code, msg }
        }
    }
}

impl fmt::Display for NativeError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(&self.msg)
    }
}

impl StdError for NativeError {
    fn description(&self) -> &str {
        &self.msg
    }
}

impl From<NativeError> for Error {
    fn from(e: NativeError) -> Self {
        Error::Native(e)
    }
}