#![no_std]
extern crate alloc;
#[cfg(feature="std")]
extern crate std;
#[macro_use]
mod common;
pub mod istring;
pub mod small;
pub mod ibytes;
pub mod tiny;
pub use crate::istring::IString;
pub use crate::ibytes::IBytes;
pub use crate::small::{SmallBytes, SmallString};
pub use crate::tiny::{TinyBytes, TinyString};
#[derive(Debug)]
pub struct FromUtf8Error<T> {
bytes: T,
error: core::str::Utf8Error,
}
impl<T: core::ops::Deref<Target=[u8]>> FromUtf8Error<T> {
pub fn as_bytes(&self) -> &[u8] {
&*self.bytes
}
pub fn into_bytes(self) -> T {
self.bytes
}
pub fn utf8_error(&self) -> core::str::Utf8Error {
self.error
}
}
#[cfg(feature="std")]
impl<T: std::fmt::Debug> std::fmt::Display for FromUtf8Error<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
self.error.fmt(f)
}
}
#[cfg(feature="std")]
impl<T: std::fmt::Debug> std::error::Error for FromUtf8Error<T> {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
self.error.source()
}
}
#[cfg(feature="serialize")]
use serde::{Serialize, Serializer, Deserialize, Deserializer};
#[cfg(feature="serialize")]
impl Serialize for IString {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>
{
self.as_str().serialize(serializer)
}
}
#[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for IString {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de> {
let s = alloc::string::String::deserialize(deserializer)?;
let mut s = IString::from(s);
s.shrink();
Ok(s)
}
}
#[cfg(feature="serialize")]
impl Serialize for SmallString {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>
{
self.as_str().serialize(serializer)
}
}
#[cfg(feature="serialize")]
impl<'de> Deserialize<'de> for SmallString {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de> {
let s = alloc::string::String::deserialize(deserializer)?;
Ok(SmallString::from(s))
}
}
#[cfg(feature="serialize")]
impl Serialize for TinyString {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>
{
self.as_str().serialize(serializer)
}
}