wayland-backend: Low-Level Wayland Protocol Backends

[dependencies]
wayland-backend = "0.3.15"

wayland_backend
├── rs             // Pure-Rust backend
│   ├── client     // Client-side rs implementation
│   └── server     // Server-side rs implementation
├── sys            // System (libwayland) backend (feature-gated)
│   ├── client     // Client-side sys implementation
│   └── server     // Server-side sys implementation
├── client         // Re-export: sys::client if client_system, else rs::client
├── server         // Re-export: sys::server if server_system, else rs::server
└── protocol       // Shared protocol types (Message, Interface, Argument, …)

pub struct Backend { /* private */ }

pub struct ObjectId { /* private */ }

impl ObjectId {
    pub fn is_null(&self) -> bool;
    pub fn null() -> ObjectId;
    pub fn interface(&self) -> &'static Interface;
    pub fn protocol_id(&self) -> u32;
}

// AsAny is a private sealed supertrait; in practice, implement the three methods below.
pub trait ObjectData: Any + Send + Sync {
    fn event(
        self: Arc<Self>,
        backend: &Backend,
        msg: Message<ObjectId, OwnedFd>,
    ) -> Option<Arc<dyn ObjectData>>;

    fn destroyed(&self, object_id: ObjectId);

    /// Optional — defaults to printing "ObjectData { ... }"
    fn debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result;

    /// Optional — used to back `Proxy::data()` in wayland-client; defaults to `self`
    fn data_as_any(&self) -> &dyn Any;
}

pub struct WeakBackend { /* private */ }

impl WeakBackend {
    pub fn upgrade(&self) -> Option<Backend>;
}

pub struct ReadEventsGuard { /* private */ }

impl ReadEventsGuard {
    pub fn connection_fd(&self) -> BorrowedFd<'_>;
    pub fn read(self) -> Result<usize, WaylandError>;
}

pub struct Backend<D: 'static> { /* private */ }

impl<D> Backend<D> {
    pub fn new() -> Result<Self, InitError>;
    pub fn handle(&self) -> Handle;
    pub fn flush(&self, client: Option<ClientId>) -> std::io::Result<()>;
    pub fn poll_fd(&self) -> BorrowedFd<'_>;
    pub fn dispatch_single_client(&self, data: &mut D, client_id: ClientId) -> std::io::Result<usize>;
    pub fn dispatch_all_clients(&self, data: &mut D) -> std::io::Result<usize>;
}

pub struct Handle { /* private */ }

pub trait ObjectData<D>: Any + Send + Sync {
    fn request(
        self: Arc<Self>,
        handle: &Handle,
        data: &mut D,
        client_id: ClientId,
        msg: Message<ObjectId, OwnedFd>,
    ) -> Option<Arc<dyn ObjectData<D>>>;

    fn destroyed(
        self: Arc<Self>,
        handle: &Handle,
        data: &mut D,
        client_id: ClientId,
        object_id: ObjectId,
    );

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

pub trait GlobalHandler<D>: Any + Send + Sync {
    // Returns true by default — override to implement access control
    fn can_view(
        &self,
        client_id: ClientId,
        client_data: &Arc<dyn ClientData>,
        global_id: GlobalId,
    ) -> bool;

    fn bind(
        self: Arc<Self>,
        handle: &Handle,
        data: &mut D,
        client_id: ClientId,
        global_id: GlobalId,
        object_id: ObjectId,
    ) -> Arc<dyn ObjectData<D>>;
}

pub trait ClientData: Any + Send + Sync {
    fn initialized(&self, client_id: ClientId) {}
    fn disconnected(&self, client_id: ClientId, reason: DisconnectReason) {}
}

pub struct Message<Id, Fd> {
    pub sender_id: Id,
    pub opcode: u16,
    pub args: SmallVec<[Argument<Id, Fd>; 4]>,
}

impl<Id, Fd> Message<Id, Fd> {
    pub fn map_fd<T>(self, f: impl FnMut(Fd) -> T) -> Message<Id, T>;
}

pub enum Argument<Id, Fd> {
    Int(i32),
    Uint(u32),
    Fixed(i32),       // 1/256 precision fixed-point
    Str(Option<Box<CString>>),
    Object(Id),
    NewId(Id),
    Array(Box<Vec<u8>>),
    Fd(Fd),
}

pub struct Interface {
    pub name: &'static str,
    pub version: u32,
    pub requests: &'static [MessageDesc],
    pub events: &'static [MessageDesc],
    pub c_interface: Option<&'static CWlInterface>,
}

use wayland_backend::{message, protocol::{Message, Argument}};

let msg: Message<ObjectId, _> = message!(
    display_id,   // sender_id: ObjectId
    0,            // opcode: u16
    [Argument::Uint(1)],
);

macro_rules! message {
    ($sender_id:expr, $opcode:expr, [$($args:expr),* $(,)?] $(,)?) => { ... }
}

[dependencies]
wayland-backend = { version = "0.3.15", features = ["log"] }
log = "0.4"