use serde_core::de::value::{
BorrowedBytesDeserializer, BorrowedStrDeserializer, EnumAccessDeserializer,
SeqAccessDeserializer,
};
use serde_core::de::{
self, Deserialize, Deserializer, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, Visitor,
};
use serde_core::ser::{Serialize, Serializer};
use std::cmp::Ordering;
use std::fmt;
use std::hash::{Hash, Hasher};
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut, Range};
#[derive(Clone, Default)]
pub struct Spanned<T> {
value: T,
span: Option<Range<usize>>,
}
pub(crate) const TOKEN: &str = "$soml::Spanned";
pub(crate) const START: &str = "$soml::Spanned::start";
pub(crate) const END: &str = "$soml::Spanned::end";
pub(crate) const VALUE: &str = "$soml::Spanned::value";
impl<T> Spanned<T> {
#[must_use]
pub const fn new(value: T) -> Self {
Self { value, span: None }
}
#[must_use]
pub const fn span(&self) -> Option<Range<usize>> {
match &self.span {
Some(span) => Some(span.start..span.end),
None => None,
}
}
#[must_use]
pub const fn get_ref(&self) -> &T {
&self.value
}
pub const fn get_mut(&mut self) -> &mut T {
&mut self.value
}
#[must_use]
pub fn into_inner(self) -> T {
self.value
}
}
impl<T> Deref for Spanned<T> {
type Target = T;
fn deref(&self) -> &T {
&self.value
}
}
impl<T> DerefMut for Spanned<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.value
}
}
impl<T> From<T> for Spanned<T> {
fn from(value: T) -> Self {
Self::new(value)
}
}
impl<T: fmt::Debug> fmt::Debug for Spanned<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Spanned")
.field("value", &self.value)
.field("span", &self.span)
.finish()
}
}
impl<T: fmt::Display> fmt::Display for Spanned<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.value.fmt(formatter)
}
}
impl<T: PartialEq> PartialEq for Spanned<T> {
fn eq(&self, other: &Self) -> bool {
self.value == other.value
}
}
impl<T: Eq> Eq for Spanned<T> {}
impl<T: PartialOrd> PartialOrd for Spanned<T> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.value.partial_cmp(&other.value)
}
}
impl<T: Ord> Ord for Spanned<T> {
fn cmp(&self, other: &Self) -> Ordering {
self.value.cmp(&other.value)
}
}
impl<T: Hash> Hash for Spanned<T> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.value.hash(state);
}
}
impl<T: Serialize> Serialize for Spanned<T> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.value.serialize(serializer)
}
}
macro_rules! visit_scalars {
($($method:ident: $type:ty),*) => {
$(
fn $method<E: de::Error>(self, value: $type) -> Result<Spanned<T>, E> {
T::deserialize(value.into_deserializer()).map(Spanned::new)
}
)*
};
}
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Spanned<T> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct SpannedVisitor<T>(PhantomData<T>);
impl<'de, T: Deserialize<'de>> Visitor<'de> for SpannedVisitor<T> {
type Value = Spanned<T>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a value")
}
fn visit_newtype_struct<D: Deserializer<'de>>(
self,
deserializer: D,
) -> Result<Spanned<T>, D::Error> {
T::deserialize(deserializer).map(Spanned::new)
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Spanned<T>, A::Error> {
let mut start = None;
let mut end = None;
while let Some(key) = map.next_key::<&str>()? {
match key {
START => start = Some(map.next_value()?),
END => end = Some(map.next_value()?),
VALUE => {
let value = map.next_value()?;
return Ok(Spanned {
value,
span: start.zip(end).map(|(start, end)| start..end),
});
}
_ => return Err(de::Error::custom("expected a spanned value")),
}
}
Err(de::Error::custom("expected a spanned value"))
}
fn visit_seq<A: SeqAccess<'de>>(self, sequence: A) -> Result<Spanned<T>, A::Error> {
T::deserialize(SeqAccessDeserializer::new(sequence)).map(Spanned::new)
}
fn visit_enum<A: EnumAccess<'de>>(self, data: A) -> Result<Spanned<T>, A::Error> {
T::deserialize(EnumAccessDeserializer::new(data)).map(Spanned::new)
}
fn visit_borrowed_str<E: de::Error>(self, value: &'de str) -> Result<Spanned<T>, E> {
T::deserialize(BorrowedStrDeserializer::new(value)).map(Spanned::new)
}
fn visit_borrowed_bytes<E: de::Error>(self, value: &'de [u8]) -> Result<Spanned<T>, E> {
T::deserialize(BorrowedBytesDeserializer::new(value)).map(Spanned::new)
}
fn visit_unit<E: de::Error>(self) -> Result<Spanned<T>, E> {
T::deserialize(().into_deserializer()).map(Spanned::new)
}
fn visit_none<E: de::Error>(self) -> Result<Spanned<T>, E> {
self.visit_unit()
}
fn visit_some<D: Deserializer<'de>>(
self,
deserializer: D,
) -> Result<Spanned<T>, D::Error> {
self.visit_newtype_struct(deserializer)
}
visit_scalars! {
visit_bool: bool, visit_i8: i8, visit_i16: i16, visit_i32: i32, visit_i64: i64, visit_i128: i128,
visit_u8: u8, visit_u16: u16, visit_u32: u32, visit_u64: u64, visit_u128: u128,
visit_f32: f32, visit_f64: f64, visit_char: char, visit_str: &str, visit_string: String,
visit_bytes: &[u8], visit_byte_buf: Vec<u8>
}
}
deserializer.deserialize_newtype_struct(TOKEN, SpannedVisitor(PhantomData))
}
}