Struct ssip_client_async::async_std::AsyncClient

pub struct AsyncClient<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin> { /* private fields */ }

SSIP client on generic async stream

There are two ways to send requests and receive responses:

• Either with the generic AsyncClient::send and AsyncClient::receive
• Or with the specific methods such as AsyncClient::set_rate, …, AsyncClient::get_rate, …

Implementations

impl<R: AsyncBufRead + Unpin, W: AsyncWrite + Unpin> AsyncClient<R, W>

pub async fn send_lines(&mut self, lines: &[String]) -> ClientResult<&mut Self>

Send lines of text (terminated by a single dot).

pub async fn receive(&mut self) -> ClientResult<Response>

Receive one response.

pub async fn send(&mut self, request: Request) -> ClientResult<&mut Self>

Send a request

pub async fn set_client_name( &mut self, client_name: ClientName ) -> ClientResult<&mut Self>

pub async fn speak(&mut self) -> ClientResult<&mut Self>

Initiate communitation to send text to speak

pub async fn speak_char(&mut self, ch: char) -> ClientResult<&mut Self>

Speak a char

pub async fn speak_key(&mut self, key_name: KeyName) -> ClientResult<&mut Self>

Speak a symbolic key name

pub async fn stop(&mut self, scope: MessageScope) -> ClientResult<&mut Self>

Stop current message

pub async fn cancel(&mut self, scope: MessageScope) -> ClientResult<&mut Self>

Cancel current message

pub async fn pause(&mut self, scope: MessageScope) -> ClientResult<&mut Self>

Pause current message

pub async fn resume(&mut self, scope: MessageScope) -> ClientResult<&mut Self>

Resume current message

pub async fn set_priority(&mut self, prio: Priority) -> ClientResult<&mut Self>

Set message priority

pub async fn set_debug(&mut self, value: bool) -> ClientResult<&mut Self>

Set debug mode. Return the log location

pub async fn set_output_module( &mut self, scope: ClientScope, value: &str ) -> ClientResult<&mut Self>

Set output module

pub async fn get_output_module(&mut self) -> ClientResult<&mut Self>

Get the current output module

pub async fn list_output_modules(&mut self) -> ClientResult<&mut Self>

List the available output modules

pub async fn set_language( &mut self, scope: ClientScope, value: &str ) -> ClientResult<&mut Self>

Set language code

pub async fn get_language(&mut self) -> ClientResult<&mut Self>

Get the current language

pub async fn set_ssml_mode(&mut self, mode: bool) -> ClientResult<&mut Self>

Set SSML mode (Speech Synthesis Markup Language)

pub async fn set_punctuation_mode( &mut self, scope: ClientScope, mode: PunctuationMode ) -> ClientResult<&mut Self>

Set punctuation mode

pub async fn set_spelling( &mut self, scope: ClientScope, value: bool ) -> ClientResult<&mut Self>

Set spelling on or off

pub async fn set_capital_letter_recogn( &mut self, scope: ClientScope, mode: CapitalLettersRecognitionMode ) -> ClientResult<&mut Self>

Set capital letters recognition mode

pub async fn set_voice_type( &mut self, scope: ClientScope, value: &str ) -> ClientResult<&mut Self>

Set the voice type (MALE1, FEMALE1, …)

pub async fn get_voice_type(&mut self) -> ClientResult<&mut Self>

Get the current pre-defined voice

pub async fn list_voice_types(&mut self) -> ClientResult<&mut Self>

List the available symbolic voice names

pub async fn set_synthesis_voice( &mut self, scope: ClientScope, value: &str ) -> ClientResult<&mut Self>

Set the voice

pub async fn list_synthesis_voices(&mut self) -> ClientResult<&mut Self>

Lists the available voices for the current synthesizer

pub async fn set_rate( &mut self, scope: ClientScope, value: i8 ) -> ClientResult<&mut Self>

Set the rate of speech. n is an integer value within the range from -100 to 100, lower values meaning slower speech.

pub async fn get_rate(&mut self) -> ClientResult<&mut Self>

Get the current rate of speech.

pub async fn set_pitch( &mut self, scope: ClientScope, value: i8 ) -> ClientResult<&mut Self>

Set the pitch of speech. n is an integer value within the range from -100 to 100.

pub async fn get_pitch(&mut self) -> ClientResult<&mut Self>

Get the current pitch value.

pub async fn set_volume( &mut self, scope: ClientScope, value: i8 ) -> ClientResult<&mut Self>

Set the volume of speech. n is an integer value within the range from -100 to 100.

pub async fn get_volume(&mut self) -> ClientResult<&mut Self>

Get the current volume.

pub async fn set_pause_context( &mut self, scope: ClientScope, value: u32 ) -> ClientResult<&mut Self>

Set the number of (more or less) sentences that should be repeated after a previously paused text is resumed.

pub async fn set_notification( &mut self, ntype: NotificationType, value: bool ) -> ClientResult<&mut Self>

Enable notification events

pub async fn block_begin(&mut self) -> ClientResult<&mut Self>

Open a block

pub async fn block_end(&mut self) -> ClientResult<&mut Self>

End a block

pub async fn set_history( &mut self, scope: ClientScope, value: bool ) -> ClientResult<&mut Self>

Enable or disable history of received messages.

pub async fn history_get_clients(&mut self) -> ClientResult<&mut Self>

Get clients in history.

pub async fn history_get_client_id(&mut self) -> ClientResult<&mut Self>

Get client id in the history.

pub async fn history_get_last(&mut self) -> ClientResult<&mut Self>

Get last message said.

pub async fn history_get_client_messages( &mut self, scope: ClientScope, start: u32, number: u32 ) -> ClientResult<&mut Self>

Get a range of client messages.

pub async fn history_get_last_message_id(&mut self) -> ClientResult<&mut Self>

Get the id of the last message sent by the client.

pub async fn history_get_message( &mut self, msg_id: MessageId ) -> ClientResult<&mut Self>

Return the text of an history message.

pub async fn history_get_cursor(&mut self) -> ClientResult<&mut Self>

Get the id of the message the history cursor is pointing to.

pub async fn history_set_cursor( &mut self, scope: ClientScope, pos: HistoryPosition ) -> ClientResult<&mut Self>

Set the history cursor position.

pub async fn history_move_cursor( &mut self, direction: CursorDirection ) -> ClientResult<&mut Self>

Move the cursor position backward or forward.

pub async fn history_speak( &mut self, msg_id: MessageId ) -> ClientResult<&mut Self>

Speak the message from history.

pub async fn history_sort( &mut self, direction: SortDirection, key: SortKey ) -> ClientResult<&mut Self>

Sort messages in history.

pub async fn history_set_short_message_length( &mut self, length: u32 ) -> ClientResult<&mut Self>

Set the maximum length of short versions of history messages.

pub async fn history_set_ordering( &mut self, ordering: Vec<Ordering> ) -> ClientResult<&mut Self>

Set the ordering of the message types, from the minimum to the maximum.

pub async fn history_search( &mut self, scope: ClientScope, condition: &str ) -> ClientResult<&mut Self>

Search in message history.

pub async fn quit(&mut self) -> ClientResult<&mut Self>

Close the connection

pub async fn check_status( &mut self, expected_code: ReturnCode ) -> ClientResult<&mut Self>

Check status of answer, discard lines.

pub async fn receive_lines( &mut self, expected_code: ReturnCode ) -> ClientResult<Vec<String>>

Receive lines

pub async fn receive_string( &mut self, expected_code: ReturnCode ) -> ClientResult<String>

Receive a single string

pub async fn receive_i8(&mut self) -> ClientResult<u8>

Receive signed 8-bit integer

pub async fn receive_u8(&mut self) -> ClientResult<u8>

Receive unsigned 8-bit integer

pub async fn receive_cursor_pos(&mut self) -> ClientResult<u16>

Receive cursor pos

pub async fn receive_message_id(&mut self) -> ClientResult<MessageId>

Receive message id

pub async fn receive_client_id(&mut self) -> ClientResult<ClientId>

Receive client id

pub async fn receive_synthesis_voices( &mut self ) -> ClientResult<Vec<SynthesisVoice>>

Receive a list of synthesis voices

pub async fn receive_event(&mut self) -> ClientResult<Event>

Receive a notification

pub async fn receive_history_clients( &mut self ) -> ClientResult<Vec<HistoryClientStatus>>

Receive a list of client status from history.

pub async fn check_client_name_set(&mut self) -> ClientResult<&mut Self>

Check the result of set_client_name.

pub async fn check_receiving_data(&mut self) -> ClientResult<&mut Self>

Check if server accept data.