Struct pear::input::Extent

pub struct Extent<T> {
    pub start: usize,
    pub end: usize,
    pub values: T,
}

Fields

start: usize

end: usize

values: T

Implementations

impl<T: ?Sized + ToOwned> Extent<&T>

pub fn into_owned(self) -> Extent<T::Owned>

Trait Implementations

impl<T: Clone> Clone for Extent<T>

fn clone(&self) -> Extent<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Extent<T>

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

Formats the value using the given formatter.

impl<T> Deref for Extent<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Length> From<T> for Extent<T>

fn from(values: T) -> Self

Converts to this type from the input type.

impl<T> Length for Extent<T>

fn len(&self) -> usize

Returns the length of self.

fn is_empty(&self) -> bool

Returns true iff the length of self is equal to zero.

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 0]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 1]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 10]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 11]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 12]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 13]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 14]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 15]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 16]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 17]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 18]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 19]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 2]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 20]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 21]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 22]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 23]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 24]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 25]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 26]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 27]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 28]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 29]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 3]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 30]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 31]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 32]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 4]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 5]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 6]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 7]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 8]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<Extent<&[T]>> for &[T; 9]

fn eq(&self, other: &Extent<&[T]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Extent<&str>> for &str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq<T> for Extent<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq for Extent<T>

fn eq(&self, other: &Extent<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Show> Show for Extent<T>

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

impl<T: Copy> Copy for Extent<T>

impl<T: Eq> Eq for Extent<T>

impl<T> StructuralPartialEq for Extent<T>