Enum Value

pub enum Value<N: Node> {
    Boolean(bool),
    Number(f64),
    String(String),
    Nodeset(Vec<N>),
}

The primary types of values that an XPath expression returns as a result.

Variants

Boolean(bool)

Number(f64)

A IEEE-754 double-precision floating point number.

String(String)

Nodeset(Vec<N>)

A collection of not-necessarily-unique nodes.

Implementations

impl<N: Node> Value<N>

pub(crate) fn boolean(&self) -> bool

https://www.w3.org/TR/1999/REC-xpath-19991116/#function-boolean

pub(crate) fn number(&self) -> f64

https://www.w3.org/TR/1999/REC-xpath-19991116/#function-number

pub(crate) fn string(&self) -> String

https://www.w3.org/TR/1999/REC-xpath-19991116/#function-string

Trait Implementations

impl<N: Debug + Node> Debug for Value<N>

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

Formats the value using the given formatter.

impl<'a, N: Node> From<&'a str> for Value<N>

fn from(other: &'a str) -> Self

Converts to this type from the input type.

impl<N: Node> From<String> for Value<N>

fn from(other: String) -> Self

Converts to this type from the input type.

impl<N: Node> From<Vec<N>> for Value<N>

fn from(other: Vec<N>) -> Self

Converts to this type from the input type.

impl<N: Node> From<bool> for Value<N>

fn from(other: bool) -> Self

Converts to this type from the input type.

impl<N: Node> From<f64> for Value<N>

fn from(other: f64) -> Self

Converts to this type from the input type.

impl<N: Node> PartialEq<&str> for Value<N>

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<N: Node> PartialEq<String> for Value<N>

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<N: Node> PartialEq<Value<N>> for &str

fn eq(&self, other: &Value<N>) -> 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<N: Node> PartialEq<Value<N>> for String

fn eq(&self, other: &Value<N>) -> 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<N: Node> PartialEq<Value<N>> for Vec<N>

fn eq(&self, other: &Value<N>) -> 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<N: Node> PartialEq<Value<N>> for bool

fn eq(&self, other: &Value<N>) -> 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<N: Node> PartialEq<Value<N>> for f64

fn eq(&self, other: &Value<N>) -> 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<N: Node> PartialEq<Vec<N>> for Value<N>

fn eq(&self, other: &Vec<N>) -> 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<N: Node> PartialEq<bool> for Value<N>

fn eq(&self, other: &bool) -> 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<N: Node> PartialEq<f64> for Value<N>

fn eq(&self, other: &f64) -> 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<N: Node> PartialEq for Value<N>

fn eq(&self, other: &Value<N>) -> 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.