Rust API

server.Server.set_hooks

Rust

Python Unavailable
TypeScript Unavailable
Rust
Go Unavailable
Java Unavailable
.NET Unavailable
C++ Unavailable
Swift Unavailable

Module: server
Declared in: Server
Package: libtmux
Source: crates/libtmux/src/server/settings.rs

set_hooks ( self , name : &str , hooks : &IndexedHooks , replace : ReplaceMode ) → Result<(), Error> method [source] ¶ method [source] ¶ set_hooks

Write a whole hook at once.

ReplaceMode::Replace clears the hook first, so only what is written remains; ReplaceMode::Merge leaves entries at indices the write does not name.

Sent as at most two tmux invocations rather than one per index: the first command alone, then the rest together. That is not atomic: tmux applies a shared invocation in order and stops at the first refusal, so a rejected entry leaves the ones before it written.

Errors

Returns an error when tmux rejects the name or any command.

Cancel safety

Under ReplaceMode::Replace the clear and the entries are one invocation, so a drop leaves the hook as it was or fully written, never cleared and unwritten; tmux reports one status for that group, so a refusal there cannot name which command drew it. Under ReplaceMode::Merge the first entry is sent on its own, so a drop after it leaves that entry written and the rest not.

Examples

use std::collections::BTreeMap;
use libtmux::{IndexedHooks, ReplaceMode, TmuxText};

let guard = libtmux::test::TestServer::new().await?;
let server = guard.server();

let mut entries = BTreeMap::new();
entries.insert(0, TmuxText::from(b"display-message first".to_vec()));
entries.insert(3, TmuxText::from(b"display-message fourth".to_vec()));

server
    .set_hooks("alert-bell", &IndexedHooks::from(entries), ReplaceMode::Replace)
    .await?;

let written = server.hook("alert-bell").await?.expect("the hook is set");
assert_eq!(written.len(), 2);
assert!(written.get(1).is_none(), "the gap is kept");

guard.shutdown().await?;

0 declared, 0 inherited