Struct Protocols 

pub struct Protocols(/* private fields */);

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();

Implementation notes

Because the number of distinct Protocols sets at any given time is much smaller than the number of relays, this type is interned in order to save memory and copying time.

This type is an Arc internally; it is cheap to clone.

Implementations

impl Protocols

pub fn new() -> Self

Return a new empty set of protocol versions.

Warning

To the extend possible, avoid using empty lists to represent the capabilities of an unknown target. Instead, if there is a consensus present, use the required-relay-protocols field of the consensus.

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());

Trait Implementations

impl Clone for Protocols

fn clone(&self) -> Protocols

Returns a duplicate of the value.

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 ==.

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