foundation 0.0.1

pub use super::util;
pub use futures::future::ok;
pub use futures::{ Future, Stream };
pub use hyper::{ Body, Headers, HttpVersion, StatusCode, Uri, Method };
pub use hyper::client::{ Client, Request };
pub use hyper::header::{ Authorization, Accept, ContentType, ETag, IfNoneMatch, UserAgent, qitem };
pub use hyper::mime::Mime;
pub use hyper_rustls::HttpsConnector;
pub use serde::de::DeserializeOwned;
pub use std::cell::RefCell;
pub use std::rc::Rc;
pub use tokio_core::reactor::Core;
pub use util::url_join;

use std::error::Error;
use std::fmt;

pub trait Executor {
    fn execute<T>(self) -> Result<(Headers, StatusCode, Option<T>), FoundationError>
        where T: DeserializeOwned;
}

#[derive(Debug, PartialEq, Eq)]
pub enum FoundationError {
    CoreRun,
    Io(String),
    UriError(String),
    Deserialization(String),
    CoreLock(String),
    Custom(String),
}

impl fmt::Display for FoundationError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        write!(fmt, "{}", self.description())
    }
}

impl Error for FoundationError {
    fn description(&self) -> &str {
        use self::FoundationError::*;
        match *self {
            CoreRun => "While executing the request an error was encountered",
            Io(ref s) => &s,
            UriError(ref s) => &s,
            Deserialization(ref s) => &s,
            CoreLock(ref s) => &s,
            Custom(ref s) => &s,
        }
    }
}

impl From<::std::io::Error> for FoundationError {
    fn from(e: ::std::io::Error) -> Self {
        FoundationError::Io(e.to_string())
    }
}

impl From<::std::cell::BorrowMutError> for FoundationError {
    fn from(e: ::std::cell::BorrowMutError) -> Self {
        FoundationError::CoreLock(e.to_string())
    }
}

impl From<::hyper::error::UriError> for FoundationError {
    fn from(e: ::hyper::error::UriError) -> Self {
        FoundationError::UriError(e.to_string())
    }
}