`impl<T> Spanned<T>`

fn new(range: Range<usize>, value: T) -> Self

Create a spanned value encompassing the given byte range.

Example

Transposing a Spanned<Enum<T>> into Enum<Spanned<T>>:

use serde::de::{Deserialize, Deserializer};
use serde_untagged::UntaggedEnumVisitor;
use toml::Spanned;

pub enum Dependency {
    Simple(Spanned<String>),
    Detailed(Spanned<DetailedDependency>),
}

impl<'de> Deserialize<'de> for Dependency {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        enum DependencyKind {
            Simple(String),
            Detailed(DetailedDependency),
        }

        impl<'de> Deserialize<'de> for DependencyKind {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                UntaggedEnumVisitor::new()
                    .expecting(
                        "a version string like \"0.9.8\" or a \
                            detailed dependency like { version = \"0.9.8\" }",
                    )
                    .string(|value| Ok(DependencyKind::Simple(value.to_owned())))
                    .map(|value| value.deserialize().map(DependencyKind::Detailed))
                    .deserialize(deserializer)
            }
        }

        let spanned: Spanned<DependencyKind> = Deserialize::deserialize(deserializer)?;
        let range = spanned.span();
        Ok(match spanned.into_inner() {
            DependencyKind::Simple(simple) => Dependency::Simple(Spanned::new(range, simple)),
            DependencyKind::Detailed(detailed) => Dependency::Detailed(Spanned::new(range, detailed)),
        })
    }
}
#
# type DetailedDependency = std::collections::BTreeMap<String, String>;

fn span(self: &Self) -> Range<usize>

Byte range

fn into_inner(self: Self) -> T

Consumes the spanned value and returns the contained value.

fn get_ref(self: &Self) -> &T

Returns a reference to the contained value.

fn get_mut(self: &mut Self) -> &mut T

Returns a mutable reference to the contained value.

`impl Borrow for Spanned<Cow<'_, str>>`

fn borrow(self: &Self) -> &str

`impl Borrow for Spanned<String>`

fn borrow(self: &Self) -> &str

`impl<'de, T> Deserialize for Spanned<T>`

fn deserialize<D>(deserializer: D) -> Result<Self, <D as >::Error> where D: Deserializer<'de>

`impl<T> Any for Spanned<T>`

fn type_id(self: &Self) -> TypeId

`impl<T> AsMut for Spanned<T>`

fn as_mut(self: &mut Self) -> &mut T

`impl<T> AsRef for Spanned<T>`

fn as_ref(self: &Self) -> &T

`impl<T> Borrow for Spanned<T>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Spanned<T>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Spanned<T>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> DeserializeOwned for Spanned<T>`

`impl<T> Freeze for Spanned<T>`

`impl<T> From for Spanned<T>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> RefUnwindSafe for Spanned<T>`

`impl<T> Send for Spanned<T>`

`impl<T> Sync for Spanned<T>`

`impl<T> ToOwned for Spanned<T>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for Spanned<T>`

fn to_string(self: &Self) -> String

`impl<T> Unpin for Spanned<T>`

`impl<T> UnsafeUnpin for Spanned<T>`

`impl<T> UnwindSafe for Spanned<T>`

`impl<T, U> Into for Spanned<T>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Spanned<T>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Spanned<T>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<T: $crate::clone::Clone> Clone for Spanned<T>`

fn clone(self: &Self) -> Spanned<T>

`impl<T: $crate::fmt::Debug> Debug for Spanned<T>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<T: Eq> Eq for Spanned<T>`

`impl<T: Hash> Hash for Spanned<T>`

fn hash<H: Hasher>(self: &Self, state: &mut H)

`impl<T: Ord> Ord for Spanned<T>`

fn cmp(self: &Self, other: &Self) -> Ordering

`impl<T: PartialEq> PartialEq for Spanned<T>`

fn eq(self: &Self, other: &Self) -> bool

`impl<T: PartialOrd> PartialOrd for Spanned<T>`

fn partial_cmp(self: &Self, other: &Self) -> Option<Ordering>

`impl<T: core::fmt::Display> Display for Spanned<T>`

fn fmt(self: &Self, fmt: &mut Formatter<'_>) -> Result

`impl<T: serde::ser::Serialize> Serialize for Spanned<T>`

fn serialize<S>(self: &Self, serializer: S) -> Result<<S as >::Ok, <S as >::Error> where S: Serializer

Struct `Spanned`

Implementations