Enum Fragment 

pub enum Fragment<'a> {
    Owned(OwnedFragment),
    Borrowed(BorrowedFragment<'a>),
    None,
}

Core enum for fragment types

Variants

Owned(OwnedFragment)

Borrowed(BorrowedFragment<'a>)

None

Implementations

impl Fragment<'_>

pub fn owned_internal(text: impl Into<String>) -> Fragment<'_>

pub fn owned_empty() -> Fragment<'_>

pub fn borrowed_internal(text: &str) -> Fragment<'_>

pub fn none() -> Fragment<'_>

pub fn testing_empty() -> Fragment<'static>

impl<'a> Fragment<'a>

pub fn text(&self) -> &str

Get the text value of the fragment

pub fn line(&self) -> StatementLine

Get line position

pub fn column(&self) -> StatementColumn

Get column position

pub fn into_owned(self) -> OwnedFragment

Convert to owned variant

pub fn to_static(self) -> Fragment<'static>

Convert to owned Fragment with ’static lifetime while preserving location info

pub fn as_borrowed(&'a self) -> Fragment<'a>

Create a borrowed view of this fragment

pub fn sub_fragment(&self, offset: usize, length: usize) -> OwnedFragment

Get a sub-fragment starting at the given offset with the given length

pub fn merge_all( fragments: impl IntoIterator<Item = Fragment<'a>>, ) -> Fragment<'a>

Merge multiple fragments (in any order) into one encompassing fragment

Trait Implementations

impl<'a> AsRef<str> for Fragment<'a>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Fragment<'a>

fn clone(&self) -> Fragment<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Fragment<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Fragment<'a>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a str> for Fragment<'a>

fn from(s: &'a str) -> Fragment<'a>

Converts to this type from the input type.

impl From<String> for Fragment<'static>

fn from(s: String) -> Fragment<'static>

Converts to this type from the input type.

impl<'a> Hash for Fragment<'a>

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

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoFragment<'a> for &'a Fragment<'a>

fn into_fragment(self) -> Fragment<'a>

impl<'a> IntoFragment<'a> for Fragment<'a>

fn into_fragment(self) -> Fragment<'a>

impl<'a, 'b> LazyFragment<'a> for &'b Fragment<'a>

where 'a: 'b,

fn fragment(&self) -> Fragment<'a>

impl<'a> LazyFragment<'a> for Fragment<'a>

where Fragment<'a>: Copy,

fn fragment(&self) -> Fragment<'a>

impl PartialEq<&str> for Fragment<'_>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for &Fragment<'_>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for Fragment<'_>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for Fragment<'_>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq for Fragment<'a>

fn eq(&self, other: &Fragment<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for Fragment<'a>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Fragment<'a>