# Struct pest::Position

source · [−]

    pub struct Position<'i> { /* private fields */ }

Expand description

A cursor position in a `&str` which provides useful methods to manually parse that string.

## Implementations

source

### impl<'i> Position<'i>

source

#### pub fn new(input: &str, pos: usize) -> Option<Position<'_>>

Attempts to create a new `Position` at the given position. If the specified position is an invalid index, or the specified position is not a valid UTF8 boundary, then None is returned.

##### Examples

    let cheart = '💖';
    let heart = "💖";
    assert_eq!(Position::new(heart, 1), None);
    assert_ne!(Position::new(heart, cheart.len_utf8()), None);

source

#### pub fn from_start(input: &'i str) -> Position<'i>

Creates a `Position` at the start of a `&str`.

##### Examples

    let start = Position::from_start("");
    assert_eq!(start.pos(), 0);

source

#### pub fn pos(&self) -> usize

Returns the byte position of this `Position` as a `usize`.

##### Examples

    let input = "ab";
    let mut start = Position::from_start(input);

    assert_eq!(start.pos(), 0);

source

#### pub fn span(&self, other: &Position<'i>) -> Span<'i>

Creates a `Span` from two `Position`s.

##### Panics

Panics if the positions come from different inputs.

##### Examples

    let input = "ab";
    let start = Position::from_start(input);
    let span = start.span(&start.clone());

    assert_eq!(span.start(), 0);
    assert_eq!(span.end(), 0);

source

#### pub fn line_col(&self) -> (usize, usize)

Returns the line and column number of this `Position`.

##### Examples

    enum Rule {}

    let input = "\na";
    let mut state: Box<pest::ParserState<'_, Rule>> = pest::ParserState::new(input);
    let mut result = state.match_string("\na");
    assert!(result.is_ok());
    assert_eq!(result.unwrap().position().line_col(), (2, 2));

source

#### pub fn line_of(&self) -> &'i str

Returns the entire line of the input that contains this `Position`.

##### Examples

    enum Rule {}

    let input = "\na";
    let mut state: Box<pest::ParserState<'_, Rule>> = pest::ParserState::new(input);
    let mut result = state.match_string("\na");
    assert!(result.is_ok());
    assert_eq!(result.unwrap().position().line_of(), "a");

## Trait Implementations

source

### impl<'i> Clone for Position<'i>

source

#### fn clone(&self) -> Position<'i>

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl<'i> Debug for Position<'i>

source

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

Formats the value using the given formatter. Read more

source

### impl<'i> Hash for Position<'i>

source

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

Feeds this value into the given `Hasher`. Read more

1.3.0 · source

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

Feeds a slice of this type into the given `Hasher`. Read more

source

### impl<'i> Ord for Position<'i>

source

#### fn cmp(&self, other: &Position<'i>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more

1.21.0 · source

#### fn max(self, other: Self) -> Self

Compares and returns the maximum of two values. Read more

1.21.0 · source

#### fn min(self, other: Self) -> Self

Compares and returns the minimum of two values. Read more

1.50.0 · source

#### fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,

Restrict a value to a certain interval. Read more

source

### impl<'i> PartialEq<Position<'i>> for Position<'i>

source

#### fn eq(&self, other: &Position<'i>) -> bool

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

1.0.0 · source

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

This method tests for `!=`.

source

### impl<'i> PartialOrd<Position<'i>> for Position<'i>

source

#### fn partial_cmp(&self, other: &Position<'i>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more

1.0.0 · source

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

1.0.0 · source

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

1.0.0 · source

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

1.0.0 · source

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

source

### impl<'i> Copy for Position<'i>

source

### impl<'i> Eq for Position<'i>

## Auto Trait Implementations

### impl<'i> RefUnwindSafe for Position<'i>

### impl<'i> Send for Position<'i>

### impl<'i> Sync for Position<'i>

### impl<'i> Unpin for Position<'i>

### impl<'i> UnwindSafe for Position<'i>

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

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

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.

source

### impl<T> RuleType for T where
T: Copy + Debug + Eq + Hash + Ord,