use super::{deserialize, serialize, Deserialize, Serialize};
use serde;
use std::{
any, borrow::{Borrow, BorrowMut}, boxed, error, fmt, marker, ops::{self, Deref, DerefMut}, rc, sync
};
#[derive(Clone, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Box<T: ?Sized>(boxed::Box<T>);
impl<T> Box<T> {
pub fn new(t: T) -> Self {
Self(boxed::Box::new(t))
}
}
impl<T: ?Sized> Box<T> {
pub fn into_box(self) -> boxed::Box<T> {
self.0
}
}
impl Box<dyn Any> {
pub fn into_any(self) -> boxed::Box<dyn any::Any> {
self.0.into_any()
}
}
#[allow(clippy::use_self)]
impl Box<dyn Any + Send> {
pub fn into_any_send(self) -> boxed::Box<dyn any::Any + Send> {
unsafe {
boxed::Box::from_raw(boxed::Box::into_raw(<Box<dyn Any>>::into_any(self)) as *mut _)
}
}
}
#[allow(clippy::use_self)]
impl Box<dyn Any + Sync> {
pub fn into_any_sync(self) -> boxed::Box<dyn any::Any + Sync> {
unsafe {
boxed::Box::from_raw(boxed::Box::into_raw(<Box<dyn Any>>::into_any(self)) as *mut _)
}
}
}
#[allow(clippy::use_self)]
impl Box<dyn Any + Send + Sync> {
pub fn into_any_send_sync(self) -> boxed::Box<dyn any::Any + Send + Sync> {
unsafe {
boxed::Box::from_raw(boxed::Box::into_raw(<Box<dyn Any>>::into_any(self)) as *mut _)
}
}
}
impl dyn Any + Send {
pub fn into_any_send(self: boxed::Box<Self>) -> boxed::Box<dyn any::Any + Send> {
<Box<dyn Any + Send>>::into_any_send(Box(self))
}
}
impl dyn Any + Sync {
pub fn into_any_sync(self: boxed::Box<Self>) -> boxed::Box<dyn any::Any + Sync> {
<Box<dyn Any + Sync>>::into_any_sync(Box(self))
}
}
impl dyn Any + Send + Sync {
pub fn into_any_send_sync(self: boxed::Box<Self>) -> boxed::Box<dyn any::Any + Send + Sync> {
<Box<dyn Any + Send + Sync>>::into_any_send_sync(Box(self))
}
}
impl<T: ?Sized + marker::Unsize<U>, U: ?Sized> ops::CoerceUnsized<Box<U>> for Box<T> {}
impl<T: ?Sized> Deref for Box<T> {
type Target = boxed::Box<T>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T: ?Sized> DerefMut for Box<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<T: ?Sized> AsRef<boxed::Box<T>> for Box<T> {
fn as_ref(&self) -> &boxed::Box<T> {
&self.0
}
}
impl<T: ?Sized> AsMut<boxed::Box<T>> for Box<T> {
fn as_mut(&mut self) -> &mut boxed::Box<T> {
&mut self.0
}
}
impl<T: ?Sized> AsRef<T> for Box<T> {
fn as_ref(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> AsMut<T> for Box<T> {
fn as_mut(&mut self) -> &mut T {
&mut *self.0
}
}
impl<T: ?Sized> Borrow<T> for Box<T> {
fn borrow(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> BorrowMut<T> for Box<T> {
fn borrow_mut(&mut self) -> &mut T {
&mut *self.0
}
}
impl<T: ?Sized> From<boxed::Box<T>> for Box<T> {
fn from(t: boxed::Box<T>) -> Self {
Self(t)
}
}
impl<T> From<T> for Box<T> {
fn from(t: T) -> Self {
Self(boxed::Box::new(t))
}
}
impl<T: error::Error> error::Error for Box<T> {
fn description(&self) -> &str {
error::Error::description(&**self)
}
#[allow(deprecated)]
fn cause(&self) -> Option<&dyn error::Error> {
error::Error::cause(&**self)
}
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
error::Error::source(&**self)
}
}
impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<T: fmt::Display + ?Sized> fmt::Display for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<A, F: ?Sized> ops::FnOnce<A> for Box<F>
where
F: FnOnce<A>,
{
type Output = F::Output;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
self.0.call_once(args)
}
}
impl<A, F: ?Sized> ops::FnMut<A> for Box<F>
where
F: FnMut<A>,
{
extern "rust-call" fn call_mut(&mut self, args: A) -> Self::Output {
self.0.call_mut(args)
}
}
impl<A, F: ?Sized> ops::Fn<A> for Box<F>
where
F: Fn<A>,
{
extern "rust-call" fn call(&self, args: A) -> Self::Output {
self.0.call(args)
}
}
impl<T: Serialize + ?Sized + 'static> serde::ser::Serialize for Box<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(&self.0, serializer)
}
}
impl<'de, T: Deserialize + ?Sized + 'static> serde::de::Deserialize<'de> for Box<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserialize(deserializer).map(Self)
}
}
#[derive(Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Rc<T: ?Sized>(rc::Rc<T>);
impl<T> Rc<T> {
pub fn new(t: T) -> Self {
Self(rc::Rc::new(t))
}
}
impl<T: ?Sized + marker::Unsize<U>, U: ?Sized> ops::CoerceUnsized<Rc<U>> for Rc<T> {}
impl<T: ?Sized> Deref for Rc<T> {
type Target = rc::Rc<T>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T: ?Sized> DerefMut for Rc<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<T: ?Sized> AsRef<rc::Rc<T>> for Rc<T> {
fn as_ref(&self) -> &rc::Rc<T> {
&self.0
}
}
impl<T: ?Sized> AsMut<rc::Rc<T>> for Rc<T> {
fn as_mut(&mut self) -> &mut rc::Rc<T> {
&mut self.0
}
}
impl<T: ?Sized> AsRef<T> for Rc<T> {
fn as_ref(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> Borrow<T> for Rc<T> {
fn borrow(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> From<rc::Rc<T>> for Rc<T> {
fn from(t: rc::Rc<T>) -> Self {
Self(t)
}
}
impl<T: ?Sized> Into<rc::Rc<T>> for Rc<T> {
fn into(self) -> rc::Rc<T> {
self.0
}
}
impl<T> From<T> for Rc<T> {
fn from(t: T) -> Self {
Self(rc::Rc::new(t))
}
}
impl<T: ?Sized> Clone for Rc<T> {
fn clone(&self) -> Self {
Self(self.0.clone())
}
}
impl<T: fmt::Debug + ?Sized> fmt::Debug for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<T: fmt::Display + ?Sized> fmt::Display for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<T: Serialize + ?Sized + 'static> serde::ser::Serialize for Rc<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(&self.0, serializer)
}
}
impl<'de, T: Deserialize + ?Sized + 'static> serde::de::Deserialize<'de> for Rc<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserialize(deserializer).map(Self)
}
}
#[derive(Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Arc<T: ?Sized>(sync::Arc<T>);
impl<T> Arc<T> {
pub fn new(t: T) -> Self {
Self(sync::Arc::new(t))
}
}
impl<T: ?Sized + marker::Unsize<U>, U: ?Sized> ops::CoerceUnsized<Arc<U>> for Arc<T> {}
impl<T: ?Sized> Deref for Arc<T> {
type Target = sync::Arc<T>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T: ?Sized> DerefMut for Arc<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<T: ?Sized> AsRef<sync::Arc<T>> for Arc<T> {
fn as_ref(&self) -> &sync::Arc<T> {
&self.0
}
}
impl<T: ?Sized> AsMut<sync::Arc<T>> for Arc<T> {
fn as_mut(&mut self) -> &mut sync::Arc<T> {
&mut self.0
}
}
impl<T: ?Sized> AsRef<T> for Arc<T> {
fn as_ref(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> Borrow<T> for Arc<T> {
fn borrow(&self) -> &T {
&*self.0
}
}
impl<T: ?Sized> From<sync::Arc<T>> for Arc<T> {
fn from(t: sync::Arc<T>) -> Self {
Self(t)
}
}
impl<T: ?Sized> Into<sync::Arc<T>> for Arc<T> {
fn into(self) -> sync::Arc<T> {
self.0
}
}
impl<T> From<T> for Arc<T> {
fn from(t: T) -> Self {
Self(sync::Arc::new(t))
}
}
impl<T: ?Sized> Clone for Arc<T> {
fn clone(&self) -> Self {
Self(self.0.clone())
}
}
impl<T: fmt::Debug + ?Sized> fmt::Debug for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<T: fmt::Display + ?Sized> fmt::Display for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
self.0.fmt(f)
}
}
impl<T: Serialize + ?Sized + 'static> serde::ser::Serialize for Arc<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(&self.0, serializer)
}
}
impl<'de, T: Deserialize + ?Sized + 'static> serde::de::Deserialize<'de> for Arc<T> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserialize(deserializer).map(Self)
}
}
pub trait Any: any::Any + Serialize + Deserialize {
fn as_any(&self) -> &dyn any::Any;
fn as_any_mut(&mut self) -> &mut dyn any::Any;
fn into_any(self: boxed::Box<Self>) -> boxed::Box<dyn any::Any>;
}
impl<T> Any for T
where
T: any::Any + Serialize + Deserialize,
{
fn as_any(&self) -> &dyn any::Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn any::Any {
self
}
fn into_any(self: boxed::Box<Self>) -> boxed::Box<dyn any::Any> {
self
}
}
impl AsRef<Self> for dyn Any {
fn as_ref(&self) -> &Self {
self
}
}
impl AsRef<Self> for dyn Any + Send {
fn as_ref(&self) -> &Self {
self
}
}
impl serde::ser::Serialize for dyn Any {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Any + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl serde::ser::Serialize for dyn Any + Send {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + Send + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Any + Send + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
pub trait Error: error::Error + Serialize + Deserialize {}
impl<T: ?Sized> Error for T where T: error::Error + Serialize + Deserialize {}
impl<'a> AsRef<Self> for dyn Error + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a> AsRef<Self> for dyn Error + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
#[allow(clippy::use_self)]
impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for Box<dyn Error + 'a> {
fn from(err: E) -> Self {
Box::new(err)
}
}
#[allow(clippy::use_self)]
impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for boxed::Box<dyn Error + 'a> {
fn from(err: E) -> Self {
boxed::Box::new(err)
}
}
impl serde::ser::Serialize for dyn Error {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Error + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl serde::ser::Serialize for dyn Error + Send {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + Send + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Error + Send + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
pub trait Display: fmt::Display + Serialize + Deserialize {}
impl<T: ?Sized> Display for T where T: fmt::Display + Serialize + Deserialize {}
impl<'a> AsRef<Self> for dyn Display + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a> AsRef<Self> for dyn Display + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl serde::ser::Serialize for dyn Display {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Display + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl serde::ser::Serialize for dyn Display + Send {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + Send + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Display + Send + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
pub trait Debug: fmt::Debug + Serialize + Deserialize {}
impl<T: ?Sized> Debug for T where T: fmt::Debug + Serialize + Deserialize {}
impl<'a> AsRef<Self> for dyn Debug + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a> AsRef<Self> for dyn Debug + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl serde::ser::Serialize for dyn Debug {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Debug + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl serde::ser::Serialize for dyn Debug + Send {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + Send + 'static> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Debug + Send + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
pub trait FnOnce<Args>: ops::FnOnce<Args> + Serialize + Deserialize {}
impl<T: ?Sized, Args> FnOnce<Args> for T where T: ops::FnOnce<Args> + Serialize + Deserialize {}
impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnOnce<Args, Output = Output> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn FnOnce<Args, Output = Output> + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn FnOnce<Args, Output = Output> + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize
for dyn FnOnce<Args, Output = Output> + Send
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn FnOnce<Args, Output = Output> + Send + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn FnOnce<Args, Output = Output> + Send + 'static>>::deserialize(deserializer)
.map(|x| x.0)
}
}
pub trait FnMut<Args>: ops::FnMut<Args> + Serialize + Deserialize {}
impl<T: ?Sized, Args> FnMut<Args> for T where T: ops::FnMut<Args> + Serialize + Deserialize {}
impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnMut<Args, Output = Output> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn FnMut<Args, Output = Output> + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn FnMut<Args, Output = Output> + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize
for dyn FnMut<Args, Output = Output> + Send
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn FnMut<Args, Output = Output> + Send + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn FnMut<Args, Output = Output> + Send + 'static>>::deserialize(deserializer)
.map(|x| x.0)
}
}
pub trait Fn<Args>: ops::Fn<Args> + Serialize + Deserialize {}
impl<T: ?Sized, Args> Fn<Args> for T where T: ops::Fn<Args> + Serialize + Deserialize {}
impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + Send + 'a {
fn as_ref(&self) -> &Self {
self
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn Fn<Args, Output = Output> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn Fn<Args, Output = Output> + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Fn<Args, Output = Output> + 'static>>::deserialize(deserializer).map(|x| x.0)
}
}
impl<Args: 'static, Output: 'static> serde::ser::Serialize
for dyn Fn<Args, Output = Output> + Send
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serialize(self, serializer)
}
}
impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
for boxed::Box<dyn Fn<Args, Output = Output> + Send + 'static>
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
<Box<dyn Fn<Args, Output = Output> + Send + 'static>>::deserialize(deserializer)
.map(|x| x.0)
}
}