async fn handle_complex_command(&mut self) -> Result<bool> {
        // This match handles all "complex" commands.
        match &self.opt.cmd {
            SubCommand::Edit { task_id, path } => {
                let message = edit(&mut self.socket, *task_id, *path).await?;
                self.handle_response(message);
                Ok(true)
            }
            SubCommand::Restart {
                task_ids,
                start_immediately,
                stashed,
                edit,
                path,
            } => {
                restart(
                    &mut self.socket,
                    task_ids.clone(),
                    *start_immediately,
                    *stashed,
                    *edit,
                    *path,
                )
                .await?;
                Ok(true)
            }
            SubCommand::Follow { task_id, err } => {
                // Simple log output follows for local logs don't need any communication with the daemon.
                // Thereby we handle this separately over here.
                if self.settings.client.read_local_logs {
                    local_follow(
                        &mut self.socket,
                        self.settings.shared.pueue_directory.clone(),
                        task_id,
                        *err,
                    )
                    .await?;
                    return Ok(true);
                }
                Ok(false)
            }
            _ => Ok(false),
        }
    }
/// Handle all complex client-side functionalities.
/// Complex functionalities need some special handling and are contained
/// in their own functions with their own communication code.
/// Such functionalities includes reading local files, data streaming
/// and sending multiple messages.
///
/// Returns `true`, if the current command has been handled by this function.
/// This indicates that the client can now shut down.
Handle all complex client-side functionalities.
Complex functionalities need some special handling and are contained
in their own functions with their own communication code.
Such functionalities includes reading local files, data streaming
and sending multiple messages.

Returns `true`, if the current command has been handled by this function.
This indicates that the client can now shut down.
Handle all complex client - side functionalities . Complex functionalities need some special handling and are contained in their own functions with their own communication code . Such functionalities includes reading local files data streaming and sending multiple messages . Returns ` true ` if the current command has been handled by this function . This indicates that the client can now shut down .
async fn handle_complex_command(&mut self) -> Result<bool> {
        // This match handles all "complex" commands.
        match &self.opt.cmd {
            SubCommand::Edit { task_id, path } => {
                let message = edit(&mut self.socket, *task_id, *path).await?;
                self.handle_response(message);
                Ok(true)
            }
            SubCommand::Restart {
                task_ids,
                start_immediately,
                stashed,
                edit,
                path,
            } => {
                restart(
                    &mut self.socket,
                    task_ids.clone(),
                    *start_immediately,
                    *stashed,
                    *edit,
                    *path,
                )
                .await?;
                Ok(true)
            }
            SubCommand::Follow { task_id, err } => {
                // Simple log output follows for local logs don't need any communication with the daemon.
                // Thereby we handle this separately over here.
                if self.settings.client.read_local_logs {
                    local_follow(
                        &mut self.socket,
                        self.settings.shared.pueue_directory.clone(),
                        task_id,
                        *err,
                    )
                    .await?;
                    return Ok(true);
                }
                Ok(false)
            }
            _ => Ok(false),
        }
    }
async fn handle_complex_command ( & mut self ) -> Result < bool > { // This match handles all "complex" commands. match & self . opt . cmd { SubCommand :: Edit { task_id , path } => { let message = edit ( & mut self . socket , * task_id , * path ) . await ? ; self . handle_response ( message ) ; Ok ( true ) } SubCommand :: Restart { task_ids , start_immediately , stashed , edit , path , } => { restart ( & mut self . socket , task_ids . clone ( ) , * start_immediately , * stashed , * edit , * path , ) . await ? ; Ok ( true ) } SubCommand :: Follow { task_id , err } => { // Simple log output follows for local logs don't need any communication with the daemon. // Thereby we handle this separately over here. if self . settings . client . read_local_logs { local_follow ( & mut self . socket , self . settings . shared . pueue_directory . clone ( ) , task_id , * err , ) . await ? ; return Ok ( true ) ; } Ok ( false ) } _ => Ok ( false ) , } }
Handle all complex client-side functionalities.
Handle all complex client - side functionalities .
&mut self