Enum Response 

pub enum Response {
    Acknowledge,
    Data {
        address: Address,
        value: u8,
    },
    Version {
        product: String,
        version: String,
    },
    Error(RolandError),
}

Response types from VR-6HD

Variants

Acknowledge

Acknowledge (ack)

Data

Data response (DTH)

Fields

address: Address

SysEx address

value: u8

Parameter value

Version

Version information (VER)

Fields

product: String

Product name

version: String

Version string

Error(RolandError)

Error response (ERR)

Implementations

impl Response

pub fn parse(response: &str) -> Result<Self, RolandError>

Parse response from string slice

Handles both Telnet (no STX) and RS-232 (with STX) formats.

Requires alloc for String allocation in Version response.

Examples found in repository

examples/telnet_client.rs (line 122)

    fn read_response(&mut self) -> Result<Response, TelnetError> {
        let mut buf = [0u8; 1024];

        // Read data
        let n = self.stream.read(&mut buf)?;

        if n == 0 {
            return Err(TelnetError::ConnectionClosed);
        }

        // Append to buffer
        self.buffer.extend_from_slice(&buf[..n]);

        // Try to parse response
        // Responses typically end with ';' or control characters
        let response_str = String::from_utf8_lossy(&self.buffer);

        // Look for complete response (ends with ';' or is a control character)
        if response_str.ends_with(';') ||
           response_str.contains('\x06') || // ACK
           response_str.contains('\x11') || // XON
           response_str.contains('\x13')
        {
            // XOFF
            let response = Response::parse(&response_str)?;
            self.buffer.clear();
            Ok(response)
        } else {
            // Incomplete response, wait a bit and try again
            std::thread::sleep(Duration::from_millis(100));
            self.read_response()
        }
    }

Trait Implementations

impl Clone for Response

fn clone(&self) -> Response

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Response

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

Formats the value using the given formatter.

impl PartialEq for Response

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Response

impl StructuralPartialEq for Response