Struct Protocols

pub struct Protocols {
    pub(crate) recognized: [u64; 13],
    pub(crate) unrecognized: Vec<SubprotocolEntry>,
}

A set of supported or required subprotocol versions.

This type supports both recognized subprotocols (listed in ProtoKind), and unrecognized subprotocols (stored by name).

To construct an instance, use the FromStr trait:

use tor_protover::Protocols;
let p: Result<Protocols,_> = "Link=1-3 LinkAuth=2-3 Relay=1-2".parse();

Fields

recognized: [u64; 13]

A mapping from protocols’ integer encodings to bit-vectors.

unrecognized: Vec<SubprotocolEntry>

A vector of unrecognized protocol versions, in sorted order.

Every entry in this list has supported != 0.

Implementations

impl Protocols

pub fn new() -> Self

Return a new empty set of protocol versions.

pub(crate) fn supports_recognized_ver(&self, proto: usize, ver: u8) -> bool

Helper: return true iff this protocol set contains the version ver of the protocol represented by the integer proto.

pub(crate) fn supports_unrecognized_ver(&self, proto: &str, ver: u8) -> bool

Helper: return true iff this protocol set contains version ver of the unrecognized protocol represented by the string proto.

Requires that proto is not the name of a recognized protocol.

pub fn is_empty(&self) -> bool

Return true if this list of protocols is empty.

pub fn supports_known_subver(&self, proto: ProtoKind, ver: u8) -> bool

Check whether a known protocol version is supported.

use tor_protover::*;
let protos: Protocols = "Link=1-3 HSDir=2,4-5".parse().unwrap();

assert!(protos.supports_known_subver(ProtoKind::Link, 2));
assert!(protos.supports_known_subver(ProtoKind::HSDir, 4));
assert!(! protos.supports_known_subver(ProtoKind::HSDir, 3));
assert!(! protos.supports_known_subver(ProtoKind::LinkAuth, 3));

pub fn supports_subver(&self, proto: &str, ver: u8) -> bool

Check whether a protocol version identified by a string is supported.

use tor_protover::*;
let protos: Protocols = "Link=1-3 Foobar=7".parse().unwrap();

assert!(protos.supports_subver("Link", 2));
assert!(protos.supports_subver("Foobar", 7));
assert!(! protos.supports_subver("Link", 5));
assert!(! protos.supports_subver("Foobar", 6));
assert!(! protos.supports_subver("Wombat", 3));

pub fn supports_named_subver(&self, protover: NamedSubver) -> bool

Check whether a protocol version is supported.

use tor_protover::*;
let protos: Protocols = "Link=1-5 Desc=2-4".parse().unwrap();
assert!(protos.supports_named_subver(named::DESC_FAMILY_IDS)); // Desc=4
assert!(! protos.supports_named_subver(named::CONFLUX_BASE)); // Conflux=1

pub fn supports_numbered_subver(&self, protover: NumberedSubver) -> bool

Check whether a numbered subprotocol capability is supported.

use tor_protover::*;
let protos: Protocols = "Link=1-5 Desc=2-4".parse().unwrap();
assert!(protos.supports_numbered_subver(NumberedSubver::new(ProtoKind::Desc, 4)));
assert!(! protos.supports_numbered_subver(NumberedSubver::new(ProtoKind::Conflux, 1)));

pub fn difference(&self, other: &Protocols) -> Protocols

Return a Protocols holding every protocol flag that is present in self but not other.

use tor_protover::*;
let protos: Protocols = "Desc=2-4 Microdesc=1-5".parse().unwrap();
let protos2: Protocols = "Desc=3 Microdesc=3".parse().unwrap();
assert_eq!(protos.difference(&protos2),
           "Desc=2,4 Microdesc=1-2,4-5".parse().unwrap());

pub fn union(&self, other: &Protocols) -> Protocols

Return a Protocols holding every protocol flag that is present in self or other or both.

use tor_protover::*;
let protos: Protocols = "Desc=2-4 Microdesc=1-5".parse().unwrap();
let protos2: Protocols = "Desc=3 Microdesc=10".parse().unwrap();
assert_eq!(protos.union(&protos2),
           "Desc=2-4 Microdesc=1-5,10".parse().unwrap());

pub fn intersection(&self, other: &Protocols) -> Protocols

Return a Protocols holding every protocol flag that is present in both self and other.

use tor_protover::*;
let protos: Protocols = "Desc=2-4 Microdesc=1-5".parse().unwrap();
let protos2: Protocols = "Desc=3 Microdesc=10".parse().unwrap();
assert_eq!(protos.intersection(&protos2),
           "Desc=3".parse().unwrap());

pub(crate) fn add( &mut self, foundmask: &mut u64, ent: SubprotocolEntry, ) -> Result<(), ParseError>

Parsing helper: Try to add a new entry ent to this set of protocols.

Uses foundmask, a bit mask saying which recognized protocols we’ve already found entries for. Returns an error if ent is for a protocol we’ve already added.

Does not preserve sorting order; the caller must call self.unrecognized.sort() before returning.

Trait Implementations

impl Clone for Protocols

fn clone(&self) -> Protocols

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Protocols

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

Formats the value using the given formatter.

impl Default for Protocols

fn default() -> Protocols

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Protocols

where Self: FromStr, <Self as FromStr>::Err: Display,

fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Protocols

The Display trait formats a protocol set in the format expected by Tor consensus documents.

use tor_protover::*;
let protos: Protocols = "Link=1,2,3 Foobar=7 Relay=2".parse().unwrap();
assert_eq!(format!("{}", protos),
           "Foobar=7 Link=1-3 Relay=2");

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

Formats the value using the given formatter.

impl FromIterator<NamedSubver> for Protocols

fn from_iter<T: IntoIterator<Item = NamedSubver>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for Protocols

A Protocols set can be parsed from a string according to the format used in Tor consensus documents.

A protocols set is represented by a space-separated list of entries. Each entry is of the form Name=Versions, where Name is the name of a protocol, and Versions is a comma-separated list of version numbers and version ranges. Each version range is a pair of integers separated by -.

No protocol name may be listed twice. No version may be listed twice for a single protocol. All versions must be in range 0 through 63 inclusive.

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseError>

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

impl Hash for Protocols

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

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 PartialEq for Protocols

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

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

const 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 Serialize for Protocols

where Self: Display,

fn serialize<__S>(&self, serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Protocols

impl StructuralPartialEq for Protocols