Struct Selector 

pub struct Selector {
    pub user: Option<String>,
    pub session: Option<String>,
    pub host: Option<String>,
    pub repo: Option<String>,
    pub worktree: Option<String>,
    pub claim: Option<String>,
    pub lead: Option<bool>,
    pub person: Option<bool>,
    pub other: Option<Value>,
}

Picks sessions by who they are, where they work, and what they hold. Each field that is set must match. Set one or more fields.

The derive of serde is remote = "Self": it gives the read and the write of the fields of this build as functions, and the impls below add the selector other. So the tolerant reader holds this struct itself, not a second copy of its fields (01M49W17GGV1K5FZEKJRPV0GNA).

Fields

user: Option<String>

The user, for example mike.

session: Option<String>

The session ID from the session part of a session URI.

host: Option<String>

The host, for example pangolin.

repo: Option<String>

The repository as OWNER/REPO, for example como-technologies/riff.

worktree: Option<String>

The worktree, for example issue-6.

claim: Option<String>

A claimed work item, for example issue-6.

lead: Option<bool>

True picks the lead of its user in its repository. Use it with user and repo.

person: Option<bool>

True picks the terminals of a person: they have no session ID. False picks the agent sessions. Use user=USER,person=true to reach a person and no agent session of that person.

other: Option<Value>

The JSON of a selector that this build does not know, as it came. Each field above is then empty, and the selector matches no session.

Implementations

impl Selector

pub fn serialize<__S>( __self: &Selector, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl<'de> Selector

pub fn deserialize<__D>(__deserializer: __D) -> Result<Selector, __D::Error>

where __D: Deserializer<'de>,

impl Selector

pub fn is_other(&self) -> bool

True for a selector other: a selector that this build does not know.

pub fn session(id: &str) -> Self

A selector for one session.

pub fn lead(user: &str, repo: &str) -> Self

A selector for the lead of user in the repository repo.

pub fn is_empty(&self) -> bool

True when the selector names no field.

pub fn matches(&self, uri: &SessionUri) -> bool

True when each named field matches the session. A selector other matches no session.

Trait Implementations

impl Clone for Selector

fn clone(&self) -> Selector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Selector

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

Formats the value using the given formatter.

impl Default for Selector

fn default() -> Selector

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Selector

A build reads each selector that it does not know as a selector other: an object with a field or a value that it does not know, and each other form of JSON (01M3XSF90E9JYYTC13D9THY4WE).

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Selector

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

The FIELD=VALUE pairs. A selector other shows its JSON.

impl FromStr for Selector

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

Parses FIELD=VALUE pairs with commas between them.

use riff_core::selector::Selector;

let s: Selector = "user=mike,claim=issue-6".parse()?;
assert_eq!(s.to_string(), "user=mike,claim=issue-6");
let lead: Selector = "user=mike,lead=true".parse()?;
assert_eq!(lead.lead, Some(true));
let person: Selector = "user=mike,person=true".parse()?;
assert_eq!(person.person, Some(true));
assert!("lead=yes".parse::<Selector>().is_err());
assert!("person=yes".parse::<Selector>().is_err());
assert!("".parse::<Selector>().is_err());
assert!("colour=blue".parse::<Selector>().is_err());

type Err = NameError

The associated error which can be returned from parsing.

impl JsonSchema for Selector

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Selector

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

A selector other writes its JSON as it came.

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

Serialize this value into the given Serde serializer.

impl Eq for Selector

impl StructuralPartialEq for Selector