Struct mpd_protocol::response::Response

pub struct Response { /* fields omitted */ }

Response to a command, consisting of an abitrary amount of frames, which are responses to individual commands, and optionally a single error.

Since an error terminates a command list, there can only be one error in a response.

Methods

impl Response

pub fn new(frames: Vec<Frame>, error: Option<Error>) -> Self

Construct a new response.

use mpd_protocol::response::{Response, Frame};

let r = Response::new(vec![Frame::empty()], None);
assert_eq!(1, r.len());
assert!(r.is_success());

Panics

Panics if it is attempted to construct an empty response (i.e. both frames and error are empty). This should not occur during normal operation.

use mpd_protocol::response::Response;

// This panics:
Response::new(Vec::new(), None);

pub fn empty() -> Self

Construct a new "empty" response. This is the simplest possible succesful response, consisting of a single empty frame.

use mpd_protocol::response::Response;

let r = Response::empty();
assert_eq!(1, r.len());
assert!(r.is_success());

pub fn is_error(&self) -> bool

Returns true if the response resulted in an error.

Even if this returns true, there may still be succesful frames in the response when the response is to a command list.

use mpd_protocol::response::{Response, Error};

let r = Response::new(Vec::new(), Some(Error::default()));
assert!(r.is_error());

pub fn is_success(&self) -> bool

Returns true if the response was entirely succesful (i.e. no errors).

use mpd_protocol::response::{Response, Frame};

let r = Response::new(vec![Frame::empty()], None);
assert!(r.is_success());

pub fn len(&self) -> usize

Get the number of succesful frames in the response.

May be 0 if the response only consists of an error.

use mpd_protocol::response::Response;

let r = Response::empty();
assert_eq!(r.len(), 1);

pub fn next_frame(self) -> Result<(Frame, Option<Self>), Error>

Get the next frame or error from the response as a Result.

Includes the remaining portion of the response. A possible error always occurs as the last element, since it terminates command lists.

use mpd_protocol::response::{Response, Frame};

let r = Response::new(vec![Frame::empty(), Frame::empty()], None);
let res = r.next_frame().unwrap();
assert_eq!(Frame::empty(), res.0);

assert_eq!(Ok((Frame::empty(), None)), res.1.unwrap().next_frame());

pub fn single_frame(self) -> Result<Frame, Error>

Treat the response as consisting of a single frame or error.

Frames or errors beyond the first, if they exist, are silently discarded.

use mpd_protocol::response::{Frame, Response};

let r = Response::empty();
assert_eq!(Ok(Frame::empty()), r.single_frame());

pub fn frames(self) -> impl Iterator<Item = Result<Frame, Error>>

Creates an iterator over all frames and errors in the response.

use mpd_protocol::response::{Frame, Response};

let mut first = vec![(String::from("hello"), String::from("world"))];

let second = vec![(String::from("foo"), String::from("bar"))];

let mut iter = Response::new(vec![Frame {
    values: first.clone(),
    binary: None,
}, Frame {
    values: second.clone(),
    binary: None,
}], None).frames();

assert_eq!(Some(Ok(Frame {
    values: first,
    binary: None,
})), iter.next());

assert_eq!(Some(Ok(Frame {
    values: second,
    binary: None,
})), iter.next());

assert_eq!(None, iter.next());

Trait Implementations

impl Debug for Response

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

Formats the value using the given formatter.

impl Eq for Response

impl PartialEq<Response> for Response

fn eq(&self, other: &Response) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Response) -> bool

This method tests for !=.

impl StructuralEq for Response

impl StructuralPartialEq for Response