Enum PredicateType

#[repr(u8)]
pub enum PredicateType {
    XFlags = 0,
    Hop = 1,
    XStamp = 2,
    Xbits0 = 3,
    Xbits1 = 4,
    Xbits2 = 5,
    Xbits3 = 6,
    Recv = 7,
    Type = 8,
    Hash = 9,
    Group = 10,
    Domain = 11,
    Pubkey = 12,
    Stamp = 13,
    Size = 14,
    DataSize = 15,
    LinksLen = 16,
    NParts = 17,
    Prefix = 18,
    Path = 19,
}

A list of all supported query predicates

Variants

XFlags = 0

“xflags”

(mutable) xflags e.g. [b2:00000000] ( implies EMPTY)

Hop = 1

“xhop”

(mutable) number of hops e.g. [u16:5] ( implies EMPTY)

XStamp = 2

“xstamp”

(mutable) variable stamp e.g. [now] ( implies EMPTY)

Xbits0 = 3

“xbits0”

(mutable) user defined bits e.g. [u32:0] ( implies EMPTY)

Xbits1 = 4

“xbits1”

(mutable) user defined bits e.g. [u32:0] ( implies EMPTY)

Xbits2 = 5

“xbits2”

(mutable) user defined bits e.g. [u32:0] ( implies EMPTY)

Xbits3 = 6

“xbits3”

(mutable) user defined bits e.g. [u32:0] ( implies EMPTY)

Recv = 7

“recv”

the recv time of a packet e.g. [now:+1D] ( implies DATA)

Type = 8

“type”

the field type bits - implied by other predicates e.g. [b2:00000001] ( implies EMPTY)

Hash = 9

“hash”

the point hash e.g. [b:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA] ( implies DATA)

Group = 10

“group”

group id e.g. [#:pub] ( implies LINK)

Domain = 11

“domain”

domain - if fewer than 16 bytes, prepadded with e.g. [a:example] ( implies LINK)

Pubkey = 12

“pubkey”

public key used to sign point e.g. [@:me:local] ( implies SIGNATURE)

Stamp = 13

“stamp”

a stamp - usually microseconds since epoch e.g. [now:-1H] ( implies LINK)

Size = 14

“size”

exact size of the point when using lk_serialize or lk_deserialize - includes xheader and hash e.g. [u16:4] ( implies DATA)

DataSize = 15

“data_size”

the byte size of the data field e.g. [u16:0] ( implies LINK)

LinksLen = 16

“links_len”

the number of links in a packet e.g. [u16:0] ( implies LINK)

NParts = 17

“nparts”

the total number of path parts - max 8 e.g. [u8:0] ( implies LINK)

Prefix = 18

“prefix”

all points with path starting with prefix - only accepts ‘=’ op e.g. /hello/world ( implies LINK)

Path = 19

“path”

exact path - only accepts ‘=’ op e.g. /hello/world ( implies LINK)

Implementations

impl PredicateType

pub const ALL: [PredicateType; 20]

pub const PREDICATES: [PredicateType; 20]

pub fn try_from_id(id: &[u8]) -> Option<PredicateType>

pub const fn info(self) -> PredInfo

impl PredicateType

pub const fn fixed_size(self) -> Option<usize>

pub fn as_u8(&self) -> u8

pub fn iter_all() -> impl Iterator<Item = PredicateType>

pub fn try_canonical(self, abl: ABList) -> Result<Vec<ABE>, Error>

pub fn canonical(self, abl: &ABList) -> Vec<ABE>

pub fn try_into_fieldenum(self) -> Result<FieldEnum, FieldEnum>

Trait Implementations

impl Clone for PredicateType

fn clone(&self) -> PredicateType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PredicateType

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

Formats the value using the given formatter.

impl Display for PredicateType

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

Formats the value using the given formatter.

impl FromStr for PredicateType

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<PredicateType, <PredicateType as FromStr>::Err>

Parses a string s to return a value of this type.

impl Ord for PredicateType

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PredicateType

fn eq(&self, other: &PredicateType) -> 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 PartialOrd for PredicateType

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<FieldEnum> for PredicateType

type Error = ()

The type returned in the event of a conversion error.

fn try_from(f: FieldEnum) -> Result<PredicateType, ()>

Performs the conversion.

impl TryInto<FieldEnum> for PredicateType

type Error = FieldEnum

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<FieldEnum, <PredicateType as TryInto<FieldEnum>>::Error>

Performs the conversion.

impl Copy for PredicateType

impl Eq for PredicateType

impl StructuralPartialEq for PredicateType