refactor

veilid-core/src/xx/mod.rs

@@ -11,7 +11,7 @@ mod log_thru;
 mod must_join_handle;
 mod must_join_single_future;
 mod mutable_future;
-// mod single_future;
+mod network_result;
 mod single_shot_eventual;
 mod split_url;
 mod tick_task;
@@ -69,8 +69,6 @@ cfg_if! {
         pub use async_lock::Mutex as AsyncMutex;
         pub use async_lock::MutexGuard as AsyncMutexGuard;
         pub use no_std_net::{ SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs, IpAddr, Ipv4Addr, Ipv6Addr };
-        pub type SystemPinBoxFuture<T> = PinBox<dyn Future<Output = T> + Send + 'static>;
-        pub type SystemPinBoxFutureLifetime<'a, T> = PinBox<dyn Future<Output = T> + Send + 'a>;
         pub use async_executors::JoinHandle as LowLevelJoinHandle;
     } else {
         pub use std::string::String;
@@ -108,8 +106,6 @@ cfg_if! {
             }
         }
         pub use std::net::{ SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs, IpAddr, Ipv4Addr, Ipv6Addr };
-        pub type SystemPinBoxFuture<T> = PinBox<dyn Future<Output = T> + Send + 'static>;
-        pub type SystemPinBoxFutureLifetime<'a, T> = PinBox<dyn Future<Output = T> + Send + 'a>;
     }
 }
 
@@ -125,7 +121,7 @@ pub use ip_extra::*;
 pub use must_join_handle::*;
 pub use must_join_single_future::*;
 pub use mutable_future::*;
-// pub use single_future::*;
+pub use network_result::*;
 pub use single_shot_eventual::*;
 pub use tick_task::*;
 pub use timeout_or::*;

veilid-core/src/xx/network_result.rs

@@ -0,0 +1,214 @@
+use super::*;
+use core::fmt::{Debug, Display};
+use core::result::Result;
+use std::error::Error;
+use std::io;
+
+//////////////////////////////////////////////////////////////////
+// Non-fallible network results conversions
+
+pub trait NetworkResultExt<T> {
+    fn into_network_result(self) -> NetworkResult<T>;
+}
+
+impl<T> NetworkResultExt<T> for Result<T, TimeoutError> {
+    fn into_network_result(self) -> NetworkResult<T> {
+        self.ok()
+            .map(|v| NetworkResult::<T>::Value(v))
+            .unwrap_or(NetworkResult::<T>::Timeout)
+    }
+}
+
+pub trait IoNetworkResultExt<T> {
+    fn into_network_result(self) -> io::Result<NetworkResult<T>>;
+}
+
+impl<T> IoNetworkResultExt<T> for io::Result<T> {
+    fn into_network_result(self) -> io::Result<NetworkResult<T>> {
+        match self {
+            Ok(v) => Ok(NetworkResult::Value(v)),
+            #[cfg(feature = "io_error_more")]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset
+                | io::ErrorKind::HostUnreachable
+                | io::ErrorKind::NetworkUnreachable => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+            #[cfg(not(feature = "io_error_more"))]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+        }
+    }
+}
+
+pub trait NetworkResultResultExt<T, E> {
+    fn into_result_network_result(self) -> Result<NetworkResult<T>, E>;
+}
+
+impl<T, E> NetworkResultResultExt<T, E> for NetworkResult<Result<T, E>> {
+    fn into_result_network_result(self) -> Result<NetworkResult<T>, E> {
+        match self {
+            NetworkResult::Timeout => Ok(NetworkResult::<T>::Timeout),
+            NetworkResult::NoConnection(e) => Ok(NetworkResult::<T>::NoConnection(e)),
+            NetworkResult::Value(Ok(v)) => Ok(NetworkResult::<T>::Value(v)),
+            NetworkResult::Value(Err(e)) => Err(e),
+        }
+    }
+}
+
+pub trait FoldedNetworkResultExt<T> {
+    fn folded(self) -> io::Result<NetworkResult<T>>;
+}
+
+impl<T> FoldedNetworkResultExt<T> for io::Result<TimeoutOr<T>> {
+    fn folded(self) -> io::Result<NetworkResult<T>> {
+        match self {
+            Ok(TimeoutOr::Timeout) => Ok(NetworkResult::Timeout),
+            Ok(TimeoutOr::Value(v)) => Ok(NetworkResult::Value(v)),
+            #[cfg(feature = "io_error_more")]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset
+                | io::ErrorKind::HostUnreachable
+                | io::ErrorKind::NetworkUnreachable => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+            #[cfg(not(feature = "io_error_more"))]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+        }
+    }
+}
+
+impl<T> FoldedNetworkResultExt<T> for io::Result<NetworkResult<T>> {
+    fn folded(self) -> io::Result<NetworkResult<T>> {
+        match self {
+            Ok(v) => Ok(v),
+            #[cfg(feature = "io_error_more")]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset
+                | io::ErrorKind::HostUnreachable
+                | io::ErrorKind::NetworkUnreachable => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+            #[cfg(not(feature = "io_error_more"))]
+            Err(e) => match e.kind() {
+                io::ErrorKind::TimedOut => Ok(NetworkResult::Timeout),
+                io::ErrorKind::ConnectionAborted
+                | io::ErrorKind::ConnectionRefused
+                | io::ErrorKind::ConnectionReset => Ok(NetworkResult::NoConnection(e)),
+                _ => Err(e),
+            },
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////
+// Non-fallible network result
+
+pub enum NetworkResult<T> {
+    Timeout,
+    NoConnection(io::Error),
+    Value(T),
+}
+
+impl<T> NetworkResult<T> {
+    pub fn timeout() -> Self {
+        Self::Timeout
+    }
+    pub fn no_connection(e: io::Error) -> Self {
+        Self::NoConnection(e)
+    }
+    pub fn value(value: T) -> Self {
+        Self::Value(value)
+    }
+
+    pub fn is_timeout(&self) -> bool {
+        matches!(self, Self::Timeout)
+    }
+    pub fn is_no_connection(&self) -> bool {
+        matches!(self, Self::NoConnection(_))
+    }
+    pub fn is_value(&self) -> bool {
+        matches!(self, Self::Value(_))
+    }
+
+    pub fn into_result(self) -> Result<T, io::Error> {
+        match self {
+            Self::Timeout => Err(io::Error::new(io::ErrorKind::TimedOut, "Timed out")),
+            Self::NoConnection(e) => Err(e),
+            Self::Value(v) => Ok(v),
+        }
+    }
+}
+
+impl<T> From<NetworkResult<T>> for Option<T> {
+    fn from(t: NetworkResult<T>) -> Self {
+        match t {
+            NetworkResult::Value(v) => Some(v),
+            _ => None,
+        }
+    }
+}
+
+// impl<T: Clone> Clone for NetworkResult<T> {
+//     fn clone(&self) -> Self {
+//         match self {
+//             Self::Timeout => Self::Timeout,
+//             Self::NoConnection(e) => Self::NoConnection(e.clone()),
+//             Self::Value(t) => Self::Value(t.clone()),
+//         }
+//     }
+// }
+
+impl<T: Debug> Debug for NetworkResult<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Timeout => write!(f, "Timeout"),
+            Self::NoConnection(e) => f.debug_tuple("NoConnection").field(e).finish(),
+            Self::Value(v) => f.debug_tuple("Value").field(v).finish(),
+        }
+    }
+}
+impl<T: Display> Display for NetworkResult<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Timeout => write!(f, ""),
+            Self::NoConnection(e) => write!(f, "No connection: {}", e.kind()),
+            Self::Value(v) => write!(f, "{}", v),
+        }
+    }
+}
+impl<T: Debug + Display> Error for NetworkResult<T> {}
+
+//////////////////////////////////////////////////////////////////
+// Non-fallible network result macros
+
+#[macro_export]
+macro_rules! network_result_try {
+    ($r: expr) => {
+        match $r {
+            NetworkResult::Timeout => return Ok(NetworkResult::Timeout),
+            NetworkResult::NoConnection(e) => return Ok(NetworkResult::NoConnection(e)),
+            NetworkResult::Value(v) => v,
+        }
+    };
+}

veilid-core/src/xx/timeout_or.rs

@@ -40,7 +40,9 @@ pub trait TimeoutOrExt<T> {
 
 impl<T> TimeoutOrExt<T> for Result<T, TimeoutError> {
     fn into_timeout_or(self) -> TimeoutOr<T> {
-        self.ok().map(|v| TimeoutOr::<T>::Value(v)).unwrap_or(TimeoutOr::<T>::Timeout)
+        self.ok()
+            .map(|v| TimeoutOr::<T>::Value(v))
+            .unwrap_or(TimeoutOr::<T>::Timeout)
     }
 }
 
@@ -62,17 +64,16 @@ pub trait TimeoutOrResultExt<T, E> {
     fn into_result(self) -> Result<TimeoutOr<T>, E>;
 }
 
-impl<T,E> TimeoutOrResultExt<T, E> for TimeoutOr<Result<T,E>> {
+impl<T, E> TimeoutOrResultExt<T, E> for TimeoutOr<Result<T, E>> {
     fn into_result(self) -> Result<TimeoutOr<T>, E> {
         match self {
-            TimeoutOr::<Result::<T,E>>::Timeout => Ok(TimeoutOr::<T>::Timeout),
-            TimeoutOr::<Result::<T,E>>::Value(Ok(v)) => Ok(TimeoutOr::<T>::Value(v)),
-            TimeoutOr::<Result::<T,E>>::Value(Err(e)) => Err(e),   
+            TimeoutOr::<Result<T, E>>::Timeout => Ok(TimeoutOr::<T>::Timeout),
+            TimeoutOr::<Result<T, E>>::Value(Ok(v)) => Ok(TimeoutOr::<T>::Value(v)),
+            TimeoutOr::<Result<T, E>>::Value(Err(e)) => Err(e),
         }
     }
 }
 
-
 //////////////////////////////////////////////////////////////////
 // Non-fallible timeout
 
@@ -139,3 +140,16 @@ impl<T: Display> Display for TimeoutOr<T> {
     }
 }
 impl<T: Debug + Display> Error for TimeoutOr<T> {}
+
+//////////////////////////////////////////////////////////////////
+// Non-fallible timeoue macros
+
+#[macro_export]
+macro_rules! timeout_or_try {
+    ($r: expr) => {
+        match $r {
+            TimeoutOr::Timeout => return Ok(TimeoutOr::Timeout),
+            TimeoutOr::Value(v) => v,
+        }
+    };
+}