fn handle_response(&self, message: Message) -> bool {
        match message {
            Message::Success(text) => print_success(&text),
            Message::Failure(text) => print_error(&text),
            Message::StatusResponse(state) => print_state(state, &self.opt.cmd),
            Message::LogResponse(task_logs) => print_logs(task_logs, &self.opt.cmd, &self.settings),
            Message::Stream(text) => {
                print!("{}", text);
                io::stdout().flush().unwrap();
                return true;
            }
            _ => error!("Received unhandled response message"),
        };

        false
    }
/// Most returned messages can be handled in a generic fashion.
/// However, some commands require continuous receiving of messages (streaming).
///
/// If this function returns `Ok(true)`, the parent function will continue to receive
/// and handle messages from the daemon. Otherwise the client will simply exit.
Most returned messages can be handled in a generic fashion.
However, some commands require continuous receiving of messages (streaming).

If this function returns `Ok(true)`, the parent function will continue to receive
and handle messages from the daemon. Otherwise the client will simply exit.
Most returned messages can be handled in a generic fashion . However some commands require continuous receiving of messages ( streaming ) . If this function returns ` Ok ( true ) ` the parent function will continue to receive and handle messages from the daemon . Otherwise the client will simply exit .
fn handle_response(&self, message: Message) -> bool {
        match message {
            Message::Success(text) => print_success(&text),
            Message::Failure(text) => print_error(&text),
            Message::StatusResponse(state) => print_state(state, &self.opt.cmd),
            Message::LogResponse(task_logs) => print_logs(task_logs, &self.opt.cmd, &self.settings),
            Message::Stream(text) => {
                print!("{}", text);
                io::stdout().flush().unwrap();
                return true;
            }
            _ => error!("Received unhandled response message"),
        };
        false
    }
fn handle_response ( & self , message : Message ) -> bool { match message { Message :: Success ( text ) => print_success ( & text ) , Message :: Failure ( text ) => print_error ( & text ) , Message :: StatusResponse ( state ) => print_state ( state , & self . opt . cmd ) , Message :: LogResponse ( task_logs ) => print_logs ( task_logs , & self . opt . cmd , & self . settings ) , Message :: Stream ( text ) => { print ! ( " " text ) ; io :: stdout ( ) . flush ( ) . unwrap ( ) ; return true ; } _ => error ! ( " " ) , } ; false }
Most returned messages can be handled in a generic fashion.
Most returned messages can be handled in a generic fashion .
&self
message
Message