Peer Types & PeerRef

Note

This project is no longer maintained or supported. Its original purpose for personal SDK/APK experimentation and learning has been fulfilled.

Instead, please use ferogram, which will receive future development and updates. Development may proceed at a slower pace.

layer-client provides typed wrappers over the raw tl::enums::User and tl::enums::Chat types, plus PeerRef: a flexible peer argument accepted by every Client method.

PeerRef: flexible peer argument

Every Client method that previously required a bare tl::enums::Peer now accepts impl Into<PeerRef>. That means you can pass:

#![allow(unused)]
fn main() {
// @username string (with or without @)
client.send_message_to_peer("@durov", "hi").await?;
client.send_message_to_peer("durov",  "hi").await?;

// "me" / "self": always resolves to the logged-in account
client.send_message_to_peer("me", "Note to self").await?;

// Positive i64: Telegram user ID
client.send_message_to_peer(12345678_i64, "hi").await?;

// Negative i64: Bot-API channel ID (-100… prefix)
client.iter_messages(-1001234567890_i64);

// Negative i64: Bot-API basic-group ID (small negative)
client.mark_as_read(-123456_i64).await?;

// Already-resolved TL peer: zero overhead, no network call
use layer_client::tl;
let peer = tl::enums::Peer::User(tl::types::PeerUser { user_id: 123 });
client.send_message_to_peer(peer, "hi").await?;
}

PeerRef variants

Bot-API ID encoding

Resolving manually

#![allow(unused)]
fn main() {
use layer_client::PeerRef;

let peer_ref = PeerRef::from("@someuser");
let peer: tl::enums::Peer = peer_ref.resolve(&client).await?;
}

User: user account wrapper

#![allow(unused)]
fn main() {
use layer_client::types::User;

// Wrap from raw TL
if let Some(user) = User::from_raw(raw_tl_user) {
    println!("ID: {}", user.id());
    println!("Name: {}", user.full_name());
    println!("Username: {:?}", user.username());
    println!("Is bot: {}", user.bot());
    println!("Is premium: {}", user.premium());
}
}

User accessor methods

User implements Display as "Full Name (@username)" or "Full Name [user_id]".

Group: basic group wrapper

#![allow(unused)]
fn main() {
use layer_client::types::Group;

if let Some(group) = Group::from_raw(raw_tl_chat) {
    println!("ID: {}", group.id());
    println!("Title: {}", group.title());
    println!("Members: {}", group.participants_count());
    println!("I am creator: {}", group.creator());
}
}

Group accessor methods

Channel: channel / supergroup wrapper

#![allow(unused)]
fn main() {
use layer_client::types::{Channel, ChannelKind};

if let Some(channel) = Channel::from_raw(raw_tl_chat) {
    println!("ID: {}", channel.id());
    println!("Title: {}", channel.title());
    println!("Username: {:?}", channel.username());
    println!("Kind: {:?}", channel.kind());
    println!("Members: {:?}", channel.participants_count());
}
}

Channel accessor methods

ChannelKind enum

#![allow(unused)]
fn main() {
use layer_client::types::ChannelKind;

match channel.kind() {
    ChannelKind::Broadcast  => { /* Posts only, no member replies */ }
    ChannelKind::Megagroup  => { /* All members can post */ }
    ChannelKind::Gigagroup  => { /* Large public broadcast group */ }
}
}

Chat: unified chat enum

Chat unifies Group and Channel into one enum with shared accessors:

#![allow(unused)]
fn main() {
use layer_client::types::Chat;

if let Some(chat) = Chat::from_raw(raw_tl_chat) {
    println!("ID: {}", chat.id());
    println!("Title: {}", chat.title());

    match &chat {
        Chat::Group(g)   => println!("Basic group, {} members", g.participants_count()),
        Chat::Channel(c) => println!("{:?} channel", c.kind()),
    }
}
}

Chat methods