use alloc::{
boxed::Box,
slice::{Iter, IterMut},
vec::Vec,
};
use core::{clone::Clone, fmt::Debug, slice};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::bolts::{AsMutSlice, AsSlice};
pub trait IntoOwned {
#[must_use]
fn is_owned(&self) -> bool;
#[must_use]
fn into_owned(self) -> Self;
}
pub trait DownsizeSlice {
fn downsize(&mut self, len: usize);
}
impl<'a, T> DownsizeSlice for &'a [T] {
fn downsize(&mut self, len: usize) {
*self = &self[..len];
}
}
impl<'a, T> DownsizeSlice for &'a mut [T] {
fn downsize(&mut self, len: usize) {
let mut value = core::mem::take(self);
value = unsafe { value.get_unchecked_mut(..len) };
let _ = core::mem::replace(self, value);
}
}
#[derive(Clone, Debug)]
pub enum OwnedRef<'a, T>
where
T: 'a + ?Sized,
{
Ref(&'a T),
Owned(Box<T>),
}
impl<'a, T> Serialize for OwnedRef<'a, T>
where
T: 'a + ?Sized + Serialize,
{
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
OwnedRef::Ref(r) => r.serialize(se),
OwnedRef::Owned(b) => b.serialize(se),
}
}
}
impl<'de, 'a, T> Deserialize<'de> for OwnedRef<'a, T>
where
T: 'a + ?Sized,
Box<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).map(OwnedRef::Owned)
}
}
impl<'a, T> AsRef<T> for OwnedRef<'a, T>
where
T: Sized,
{
#[must_use]
fn as_ref(&self) -> &T {
match self {
OwnedRef::Ref(r) => r,
OwnedRef::Owned(v) => v.as_ref(),
}
}
}
impl<'a, T> IntoOwned for OwnedRef<'a, T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self {
OwnedRef::Ref(_) => false,
OwnedRef::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
match self {
OwnedRef::Ref(r) => OwnedRef::Owned(Box::new(r.clone())),
OwnedRef::Owned(v) => OwnedRef::Owned(v),
}
}
}
#[derive(Debug)]
pub enum OwnedRefMut<'a, T: 'a + ?Sized> {
Ref(&'a mut T),
Owned(Box<T>),
}
impl<'a, T: 'a + ?Sized + Serialize> Serialize for OwnedRefMut<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
OwnedRefMut::Ref(r) => r.serialize(se),
OwnedRefMut::Owned(b) => b.serialize(se),
}
}
}
impl<'de, 'a, T: 'a + ?Sized> Deserialize<'de> for OwnedRefMut<'a, T>
where
Box<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).map(OwnedRefMut::Owned)
}
}
impl<'a, T: Sized> AsRef<T> for OwnedRefMut<'a, T> {
#[must_use]
fn as_ref(&self) -> &T {
match self {
OwnedRefMut::Ref(r) => r,
OwnedRefMut::Owned(v) => v.as_ref(),
}
}
}
impl<'a, T: Sized> AsMut<T> for OwnedRefMut<'a, T> {
#[must_use]
fn as_mut(&mut self) -> &mut T {
match self {
OwnedRefMut::Ref(r) => r,
OwnedRefMut::Owned(v) => v.as_mut(),
}
}
}
impl<'a, T> IntoOwned for OwnedRefMut<'a, T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self {
OwnedRefMut::Ref(_) => false,
OwnedRefMut::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
match self {
OwnedRefMut::Ref(r) => OwnedRefMut::Owned(Box::new(r.clone())),
OwnedRefMut::Owned(v) => OwnedRefMut::Owned(v),
}
}
}
#[derive(Clone, Debug)]
enum OwnedSliceInner<'a, T: 'a + Sized> {
RefRaw(*const T, usize),
Ref(&'a [T]),
Owned(Vec<T>),
}
impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedSliceInner<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
OwnedSliceInner::RefRaw(rr, len) => unsafe {
slice::from_raw_parts(*rr, *len).serialize(se)
},
OwnedSliceInner::Ref(r) => r.serialize(se),
OwnedSliceInner::Owned(b) => b.serialize(se),
}
}
}
impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedSliceInner<'a, T>
where
Vec<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).map(OwnedSliceInner::Owned)
}
}
#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Debug, Serialize, Deserialize)]
pub struct OwnedSlice<'a, T: 'a + Sized> {
inner: OwnedSliceInner<'a, T>,
}
impl<'a, T: 'a + Clone> Clone for OwnedSlice<'a, T> {
fn clone(&self) -> Self {
Self {
inner: OwnedSliceInner::Owned(self.as_slice().to_vec()),
}
}
}
impl<'a, T> OwnedSlice<'a, T> {
#[must_use]
pub unsafe fn from_raw_parts(ptr: *const T, len: usize) -> Self {
Self {
inner: OwnedSliceInner::RefRaw(ptr, len),
}
}
pub fn downsize(&mut self, new_len: usize) -> Option<usize> {
match &mut self.inner {
OwnedSliceInner::RefRaw(_rr, len) => {
let tmp = *len;
if new_len <= tmp {
*len = new_len;
Some(tmp)
} else {
None
}
}
OwnedSliceInner::Ref(r) => {
let tmp = r.len();
if new_len <= tmp {
r.downsize(new_len);
Some(tmp)
} else {
None
}
}
OwnedSliceInner::Owned(v) => {
let tmp = v.len();
if new_len <= tmp {
v.truncate(new_len);
Some(tmp)
} else {
None
}
}
}
}
}
impl<'a, 'it, T> IntoIterator for &'it OwnedSlice<'a, T> {
type Item = <Iter<'it, T> as Iterator>::Item;
type IntoIter = Iter<'it, T>;
fn into_iter(self) -> Self::IntoIter {
self.as_slice().iter()
}
}
impl<'a, T> From<Vec<T>> for OwnedSlice<'a, T> {
fn from(vec: Vec<T>) -> Self {
Self {
inner: OwnedSliceInner::Owned(vec),
}
}
}
impl<'a, T> From<&'a Vec<T>> for OwnedSlice<'a, T> {
fn from(vec: &'a Vec<T>) -> Self {
Self {
inner: OwnedSliceInner::Ref(vec),
}
}
}
impl<'a, T> From<&'a [T]> for OwnedSlice<'a, T> {
fn from(r: &'a [T]) -> Self {
Self {
inner: OwnedSliceInner::Ref(r),
}
}
}
impl<'a, T> From<OwnedMutSlice<'a, T>> for OwnedSlice<'a, T> {
fn from(mut_slice: OwnedMutSlice<'a, T>) -> Self {
Self {
inner: match mut_slice.inner {
OwnedMutSliceInner::RefRaw(ptr, len) => OwnedSliceInner::RefRaw(ptr as _, len),
OwnedMutSliceInner::Ref(r) => OwnedSliceInner::Ref(r as _),
OwnedMutSliceInner::Owned(v) => OwnedSliceInner::Owned(v),
},
}
}
}
impl<'a, T: Sized> AsSlice for OwnedSlice<'a, T> {
type Entry = T;
#[must_use]
fn as_slice(&self) -> &[T] {
match &self.inner {
OwnedSliceInner::Ref(r) => r,
OwnedSliceInner::RefRaw(rr, len) => unsafe { slice::from_raw_parts(*rr, *len) },
OwnedSliceInner::Owned(v) => v.as_slice(),
}
}
}
impl<'a, T> IntoOwned for OwnedSlice<'a, T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self.inner {
OwnedSliceInner::RefRaw(_, _) | OwnedSliceInner::Ref(_) => false,
OwnedSliceInner::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
match self.inner {
OwnedSliceInner::RefRaw(rr, len) => Self {
inner: OwnedSliceInner::Owned(unsafe { slice::from_raw_parts(rr, len).to_vec() }),
},
OwnedSliceInner::Ref(r) => Self {
inner: OwnedSliceInner::Owned(r.to_vec()),
},
OwnedSliceInner::Owned(v) => Self {
inner: OwnedSliceInner::Owned(v),
},
}
}
}
impl<'a, T> From<OwnedSlice<'a, T>> for Vec<T>
where
T: Clone,
{
fn from(slice: OwnedSlice<'a, T>) -> Self {
let slice = slice.into_owned();
match slice.inner {
OwnedSliceInner::Owned(vec) => vec,
_ => panic!("Could not own slice!"),
}
}
}
#[derive(Debug)]
pub enum OwnedMutSliceInner<'a, T: 'a + Sized> {
RefRaw(*mut T, usize),
Ref(&'a mut [T]),
Owned(Vec<T>),
}
impl<'a, T: 'a + Sized + Serialize> Serialize for OwnedMutSliceInner<'a, T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
OwnedMutSliceInner::RefRaw(rr, len) => {
unsafe { slice::from_raw_parts_mut(*rr, *len) }.serialize(se)
}
OwnedMutSliceInner::Ref(r) => r.serialize(se),
OwnedMutSliceInner::Owned(b) => b.serialize(se),
}
}
}
impl<'de, 'a, T: 'a + Sized> Deserialize<'de> for OwnedMutSliceInner<'a, T>
where
Vec<T>: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).map(OwnedMutSliceInner::Owned)
}
}
#[allow(clippy::unsafe_derive_deserialize)]
#[derive(Debug, Serialize, Deserialize)]
pub struct OwnedMutSlice<'a, T: 'a + Sized> {
inner: OwnedMutSliceInner<'a, T>,
}
impl<'a, 'it, T> IntoIterator for &'it mut OwnedMutSlice<'a, T> {
type Item = <IterMut<'it, T> as Iterator>::Item;
type IntoIter = IterMut<'it, T>;
fn into_iter(self) -> Self::IntoIter {
self.as_mut_slice().iter_mut()
}
}
impl<'a, 'it, T> IntoIterator for &'it OwnedMutSlice<'a, T> {
type Item = <Iter<'it, T> as Iterator>::Item;
type IntoIter = Iter<'it, T>;
fn into_iter(self) -> Self::IntoIter {
self.as_slice().iter()
}
}
impl<'a, T: 'a + Sized> OwnedMutSlice<'a, T> {
#[must_use]
pub unsafe fn from_raw_parts_mut(ptr: *mut T, len: usize) -> OwnedMutSlice<'a, T> {
if ptr.is_null() || len == 0 {
Self {
inner: OwnedMutSliceInner::Owned(Vec::new()),
}
} else {
Self {
inner: OwnedMutSliceInner::RefRaw(ptr, len),
}
}
}
pub fn downsize(&mut self, new_len: usize) -> Option<usize> {
match &mut self.inner {
OwnedMutSliceInner::RefRaw(_rr, len) => {
let tmp = *len;
if new_len <= tmp {
*len = new_len;
Some(tmp)
} else {
None
}
}
OwnedMutSliceInner::Ref(r) => {
let tmp = r.len();
if new_len <= tmp {
r.downsize(new_len);
Some(tmp)
} else {
None
}
}
OwnedMutSliceInner::Owned(v) => {
let tmp = v.len();
if new_len <= tmp {
v.truncate(new_len);
Some(tmp)
} else {
None
}
}
}
}
}
impl<'a, T: Sized> AsSlice for OwnedMutSlice<'a, T> {
type Entry = T;
#[must_use]
fn as_slice(&self) -> &[T] {
match &self.inner {
OwnedMutSliceInner::RefRaw(rr, len) => unsafe { slice::from_raw_parts(*rr, *len) },
OwnedMutSliceInner::Ref(r) => r,
OwnedMutSliceInner::Owned(v) => v.as_slice(),
}
}
}
impl<'a, T: Sized> AsMutSlice for OwnedMutSlice<'a, T> {
type Entry = T;
#[must_use]
fn as_mut_slice(&mut self) -> &mut [T] {
match &mut self.inner {
OwnedMutSliceInner::RefRaw(rr, len) => unsafe { slice::from_raw_parts_mut(*rr, *len) },
OwnedMutSliceInner::Ref(r) => r,
OwnedMutSliceInner::Owned(v) => v.as_mut_slice(),
}
}
}
impl<'a, T> IntoOwned for OwnedMutSlice<'a, T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self.inner {
OwnedMutSliceInner::RefRaw(_, _) | OwnedMutSliceInner::Ref(_) => false,
OwnedMutSliceInner::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
let vec = match self.inner {
OwnedMutSliceInner::RefRaw(rr, len) => unsafe {
slice::from_raw_parts_mut(rr, len).to_vec()
},
OwnedMutSliceInner::Ref(r) => r.to_vec(),
OwnedMutSliceInner::Owned(v) => v,
};
Self {
inner: OwnedMutSliceInner::Owned(vec),
}
}
}
impl<'a, T: 'a + Clone> Clone for OwnedMutSlice<'a, T> {
fn clone(&self) -> Self {
Self {
inner: OwnedMutSliceInner::Owned(self.as_slice().to_vec()),
}
}
}
impl<'a, T> From<Vec<T>> for OwnedMutSlice<'a, T> {
fn from(vec: Vec<T>) -> Self {
Self {
inner: OwnedMutSliceInner::Owned(vec),
}
}
}
impl<'a, T> From<OwnedMutSlice<'a, T>> for Vec<T>
where
T: Clone,
{
fn from(slice: OwnedMutSlice<'a, T>) -> Self {
let slice = slice.into_owned();
match slice.inner {
OwnedMutSliceInner::Owned(vec) => vec,
_ => panic!("Could not own slice!"),
}
}
}
impl<'a, T> From<&'a mut Vec<T>> for OwnedMutSlice<'a, T> {
fn from(vec: &'a mut Vec<T>) -> Self {
Self {
inner: OwnedMutSliceInner::Ref(vec),
}
}
}
impl<'a, T> From<&'a mut [T]> for OwnedMutSlice<'a, T> {
fn from(r: &'a mut [T]) -> Self {
Self {
inner: OwnedMutSliceInner::Ref(r),
}
}
}
#[allow(clippy::mut_mut)] impl<'a, T> From<&'a mut &'a mut [T]> for OwnedMutSlice<'a, T> {
fn from(r: &'a mut &'a mut [T]) -> Self {
Self {
inner: OwnedMutSliceInner::Ref(r),
}
}
}
#[derive(Clone, Debug)]
pub enum OwnedPtr<T: Sized> {
Ptr(*const T),
Owned(Box<T>),
}
impl<T: Sized + Serialize> Serialize for OwnedPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
self.as_ref().serialize(se)
}
}
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedPtr<T>
where
Vec<T>: Deserialize<'de>,
{
fn deserialize<D>(de: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(OwnedPtr::Owned)
}
}
impl<T: Sized> AsRef<T> for OwnedPtr<T> {
#[must_use]
fn as_ref(&self) -> &T {
match self {
OwnedPtr::Ptr(p) => unsafe { p.as_ref().unwrap() },
OwnedPtr::Owned(v) => v.as_ref(),
}
}
}
impl<T> IntoOwned for OwnedPtr<T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self {
OwnedPtr::Ptr(_) => false,
OwnedPtr::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
match self {
OwnedPtr::Ptr(p) => unsafe { OwnedPtr::Owned(Box::new(p.as_ref().unwrap().clone())) },
OwnedPtr::Owned(v) => OwnedPtr::Owned(v),
}
}
}
#[derive(Clone, Debug)]
pub enum OwnedMutPtr<T: Sized> {
Ptr(*mut T),
Owned(Box<T>),
}
impl<T: Sized + Serialize> Serialize for OwnedMutPtr<T> {
fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
self.as_ref().serialize(se)
}
}
impl<'de, T: Sized + serde::de::DeserializeOwned> Deserialize<'de> for OwnedMutPtr<T>
where
Vec<T>: Deserialize<'de>,
{
fn deserialize<D>(de: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(de).map(OwnedMutPtr::Owned)
}
}
impl<T: Sized> AsRef<T> for OwnedMutPtr<T> {
#[must_use]
fn as_ref(&self) -> &T {
match self {
OwnedMutPtr::Ptr(p) => unsafe { p.as_ref().unwrap() },
OwnedMutPtr::Owned(b) => b.as_ref(),
}
}
}
impl<T: Sized> AsMut<T> for OwnedMutPtr<T> {
fn as_mut(&mut self) -> &mut T {
match self {
OwnedMutPtr::Ptr(p) => unsafe { p.as_mut().unwrap() },
OwnedMutPtr::Owned(b) => b.as_mut(),
}
}
}
impl<T> IntoOwned for OwnedMutPtr<T>
where
T: Sized + Clone,
{
#[must_use]
fn is_owned(&self) -> bool {
match self {
OwnedMutPtr::Ptr(_) => false,
OwnedMutPtr::Owned(_) => true,
}
}
#[must_use]
fn into_owned(self) -> Self {
match self {
OwnedMutPtr::Ptr(p) => unsafe {
OwnedMutPtr::Owned(Box::new(p.as_ref().unwrap().clone()))
},
OwnedMutPtr::Owned(v) => OwnedMutPtr::Owned(v),
}
}
}