Struct CommunityChannel 

pub struct CommunityChannel { /* private fields */ }

One channel of a Community, as Community::channels reports it.

Deliberately includes channels this bot cannot read: a private channel whose key hasn’t arrived is enumerable but unreadable, and a bot that can’t see the difference has no way to tell “nobody has talked to me” from “I was granted access and never got the key”.

Implementations

impl CommunityChannel

pub fn id(&self) -> &str

The channel id (32-byte hex) — what Community::channel takes.

pub fn name(&self) -> &str

The channel’s display name. Empty for a private channel recorded before its metadata folded.

Examples found in repository

examples/concordia.rs (line 401)

async fn print_channels(bot: &VectorBot, label: &str) {
    for community in bot.communities().await {
        let channels = community.channels().await;
        if channels.is_empty() {
            continue;
        }
        let rendered: Vec<String> = channels
            .iter()
            .map(|ch| match (ch.is_private(), ch.is_readable()) {
                (true, false) => format!("#{} (locked)", ch.name()),
                (true, true) => format!("#{} (private)", ch.name()),
                _ => format!("#{}", ch.name()),
            })
            .collect();
        println!("── {label} in {}: {}", short(community.id()), rendered.join(", "));
    }
}

pub fn is_private(&self) -> bool

Whether this channel is private (independently keyed, readable only by granted role-holders).

Examples found in repository

examples/concordia.rs (line 400)

async fn print_channels(bot: &VectorBot, label: &str) {
    for community in bot.communities().await {
        let channels = community.channels().await;
        if channels.is_empty() {
            continue;
        }
        let rendered: Vec<String> = channels
            .iter()
            .map(|ch| match (ch.is_private(), ch.is_readable()) {
                (true, false) => format!("#{} (locked)", ch.name()),
                (true, true) => format!("#{} (private)", ch.name()),
                _ => format!("#{}", ch.name()),
            })
            .collect();
        println!("── {label} in {}: {}", short(community.id()), rendered.join(", "));
    }
}

pub fn is_readable(&self) -> bool

Whether this bot can actually read it. False only for a private channel whose key hasn’t been delivered yet — see Community::channels.

Examples found in repository

examples/concordia.rs (line 400)

async fn print_channels(bot: &VectorBot, label: &str) {
    for community in bot.communities().await {
        let channels = community.channels().await;
        if channels.is_empty() {
            continue;
        }
        let rendered: Vec<String> = channels
            .iter()
            .map(|ch| match (ch.is_private(), ch.is_readable()) {
                (true, false) => format!("#{} (locked)", ch.name()),
                (true, true) => format!("#{} (private)", ch.name()),
                _ => format!("#{}", ch.name()),
            })
            .collect();
        println!("── {label} in {}: {}", short(community.id()), rendered.join(", "));
    }
}

pub fn epoch(&self) -> u64

The channel’s current key generation. Climbs on every rekey; 0 means a private channel we hold no key for.

Trait Implementations

impl Clone for CommunityChannel

fn clone(&self) -> CommunityChannel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommunityChannel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommunityChannel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.