Struct ConnectOptions

pub struct ConnectOptions { /* private fields */ }

The configuration for creating a new connection.

Example

let config = Connection::build("localhost")
    .name("MyUser")
    .channel("Default Channel/Nested");

let con = Connection::new(config);

Implementations

impl ConnectOptions

pub fn new<A: Into<ServerAddress>>(address: A) -> Self

👎Deprecated since 0.2.0: Connection::build should be used instead

Start creating the configuration of a new connection.

Arguments

The address of the server has to be supplied. The address can be a SocketAddr, a string or directly a ServerAddress. A string will automatically be resolved from all formats supported by TeamSpeak. For details, see resolver::resolve.

pub fn connect(self) -> Result<Connection, Error>

Create the connection object from these options.

This function opens a new connection to a server. The connection needs to be polled for events to do something.

Examples

This will open a connection to the TeamSpeak server at localhost.

    let mut con = Connection::build("localhost").connect().unwrap();
    // Wait until connected
    con.events()
        // We are connected when we receive the first BookEvents
        .try_filter(|e| future::ready(matches!(e, StreamItem::BookEvents(_))))
        .next()
        .await
        .unwrap();

pub fn local_address(self, local_address: SocketAddr) -> Self

The address for the socket of our client

Default

The default is 0.0.0:0 when connecting to an IPv4 address and [::]:0 when connecting to an IPv6 address.

pub fn identity(self, identity: Identity) -> Self

Set the identity of the user.

Default

A new identity is generated when connecting.

pub fn server(self, server: UidBuf) -> Self

Check the identity of the server to be equal with the given uid.

If the public key of the server does not match this uid, the connection will be aborted.

Default

Allow the server to have any identity.

pub fn name<S: Into<Cow<'static, str>>>(self, name: S) -> Self

The name of the user.

Default

TeamSpeakUser

pub fn version(self, version: Version) -> Self

The displayed version of the client.

Default

3.2.1 on Linux

pub fn hardware_id<S: Into<Cow<'static, str>>>(self, hwid: S) -> Self

The hardware ID (HWID) of the client.

Default

923f136fb1e22ae6ce95e60255529c00,d13231b1bc33edfecfb9169cc7a63bcc

pub fn channel<S: Into<Cow<'static, str>>>(self, path: S) -> Self

Connect to a specific channel.

Example

let opts = Connection::build("localhost").channel("Default Channel");

Connecting to a channel further down in the hierarchy.

let opts = Connection::build("localhost").channel("Default Channel/Nested");

pub fn channel_id(self, channel: ChannelId) -> Self

Connect to a specific channel.

Setting the channel id is equal to connecting to the channel /<id>.

Example

let opts = Connection::build("localhost").channel_id(ChannelId(2));

pub fn channel_password<S: Into<Cow<'static, str>>>(self, pwd: S) -> Self

Use a password for the given channel when connecting.

Example

let opts = Connection::build("localhost")
    .channel("Secret Channel")
    .channel_password("My secret password");

pub fn password<S: Into<Cow<'static, str>>>(self, pwd: S) -> Self

Use a server password when connecting.

Example

let opts = Connection::build("localhost").password("My secret password");

pub fn input_muted(self, input_muted: bool) -> Self

Connect to the server in a muted state.

Example

let opts = Connection::build("localhost").input_muted(true);

pub fn output_muted(self, output_muted: bool) -> Self

Connect to the server with the output muted.

Example

let opts = Connection::build("localhost").output_muted(true);

pub fn input_hardware_enabled(self, input_hardware_enabled: bool) -> Self

Connect to the server with input hardware disabled state.

Example

let opts = Connection::build("localhost").input_hardware_enabled(true);

pub fn output_hardware_enabled(self, output_hardware_enabled: bool) -> Self

Connect to the server with output hardware disabled stat.

Example

let opts = Connection::build("localhost").output_hardware_enabled(true);

pub fn away<S: Into<Cow<'static, str>>>(self, message: S) -> Self

Connect to the server with an away message.

Example

let opts = Connection::build("localhost").away("Buying groceries");

pub fn log_commands(self, log_commands: bool) -> Self

If the content of all commands should be written to the logger.

Default

false

pub fn log_packets(self, log_packets: bool) -> Self

If the content of all packets in high-level form should be written to the logger.

Default

false

pub fn log_udp_packets(self, log_udp_packets: bool) -> Self

If the content of all udp packets in byte-array form should be written to the logger.

Default

false

pub fn logger(self, logger: Logger) -> Self

Set a custom logger for the connection.

Default

A new logger is created.

pub fn get_address(&self) -> &ServerAddress

pub fn get_local_address(&self) -> Option<&SocketAddr>

pub fn get_identity(&self) -> Option<&Identity>

pub fn get_server(&self) -> Option<&Uid>

pub fn get_name(&self) -> &str

pub fn get_version(&self) -> &Version

pub fn get_hardware_id(&self) -> &str

pub fn get_channel(&self) -> Option<&str>

pub fn get_channel_password(&self) -> Option<&str>

pub fn get_password(&self) -> Option<&str>

pub fn get_input_muted(&self) -> bool

pub fn get_output_muted(&self) -> bool

pub fn get_input_hardware_enabled(&self) -> bool

pub fn get_output_hardware_enabled(&self) -> bool

pub fn get_away(&self) -> Option<&str>

pub fn get_logger(&self) -> Option<&Logger>

pub fn get_log_commands(&self) -> bool

pub fn get_log_packets(&self) -> bool

pub fn get_log_udp_packets(&self) -> bool

Trait Implementations

impl Clone for ConnectOptions

fn clone(&self) -> ConnectOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectOptions

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

Formats the value using the given formatter.