use crate::base::{ErrorCode, HasErrorCode, ParameterValueRaw};
use snafu::{ensure, OptionExt, ResultExt};
use std::collections::VecDeque;
use std::io::{Read, Write};
use crate::{
error, Endian, ErrorCodeReaderExt, ErrorCodeWriterExt,
HasFixedCommandId, IsRequest, IsResponse, IsValidResponseFor,
MessageExt, ParameterValueReaderExt, ParameterValueWriteMode,
ParameterValueWriterExt, ReadExt, ReadFromPayload, Result,
TryFromResponse, TryInto, WithFixedPayloadLength, WriteExt,
};
#[derive(Clone, Debug, PartialEq)]
pub struct Request {
pub values: Vec<ParameterValueRaw>,
}
impl IsRequest for Request {
type Response = Response;
}
impl From<Request> for super::Request {
fn from(m: Request) -> Self {
super::Request::UploadJobParameters(m)
}
}
impl Request {
const ADDITIONAL_FIXED_PAYLOAD_LENGTH: u16 = u16::FIXED_PAYLOAD_LENGTH;
fn verify_payload_length(received: u16, required: u16) -> Result<()> {
ensure!(
required == received,
error::InvalidPayloadLength {
message_type: "upload_job_parameters_request",
received,
required
}
);
Ok(())
}
}
impl HasFixedCommandId for Request {
const COMMAND_ID: u16 = 0x2804;
}
impl MessageExt for Request {
fn payload_length(&self) -> u16 {
Self::ADDITIONAL_FIXED_PAYLOAD_LENGTH
+ ParameterValueRaw::FIXED_PAYLOAD_LENGTH
* self.values.len() as u16
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
w.write_u16::<Endian>(self.values.len() as u16)?;
for value in &self.values {
w.write_parameter_value(
value,
&ParameterValueWriteMode::Type,
)?;
}
for value in &self.values {
w.write_parameter_value(
value,
&ParameterValueWriteMode::Value,
)?;
}
Ok(())
}
}
impl ReadFromPayload for Request {
fn read_from_payload<R: Read>(
r: &mut R,
payload_length: u16,
) -> Result<Self> {
let count = r.read_u16::<Endian>()?;
let remaining_payload_length =
count * ParameterValueRaw::FIXED_PAYLOAD_LENGTH;
let required_payload_length = Self::ADDITIONAL_FIXED_PAYLOAD_LENGTH
+ remaining_payload_length;
Self::verify_payload_length(
payload_length,
required_payload_length,
)?;
let mut types = VecDeque::new();
for _ in 0..count {
types.push_back(r.read_type()?);
}
let mut values = Vec::new();
for i in 0..count {
let t = types.pop_front().context(
error::InvalidJobParametersPayload { parameter_index: i },
)?;
let v = r.read_value()?;
values.push((t, v).try_into().context(error::Io)?);
}
Ok(Self { values })
}
}
#[cfg(test)]
mod test_request {
use super::*;
use crate::base::ModuleChannelReference;
#[test]
fn write_to_empty() {
let mut buffer = Vec::new();
let options: u8 = 0x45;
let sequence: u8 = 0x93;
let values = Vec::new();
let message = Request { values };
message.write_to(&mut buffer, options, sequence).unwrap();
assert_eq!(
buffer,
[
0x45,
0x93,
0x04,
0x28,
0x02,
0x00,
0x00,
0x00,
]
);
}
#[test]
fn write_to_single_boolean() {
let mut buffer = Vec::new();
let options: u8 = 0x45;
let sequence: u8 = 0x93;
let values = vec![true.into()];
let length = {
let fixed = 4u16;
let per_value = 9u16;
let value_count = 1u16;
fixed + per_value * value_count
};
assert_eq!(length, 0x000D);
assert_eq!(0x000D, 13);
let message = Request { values };
message.write_to(&mut buffer, options, sequence).unwrap();
assert_eq!(
buffer,
vec![
0x45,
0x93,
0x04,
0x28,
0x0B,
0x00,
0x01,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
]
);
}
#[test]
fn write_to_three_items() {
use crate::base::ParameterValue;
let mut buffer = Vec::new();
let options: u8 = 0x45;
let sequence: u8 = 0x93;
let module_id = 0x4532;
let channel_id = 0x1921;
let values = vec![
0x1234u16.into(),
true.into(),
ParameterValue::UInt8Channel(ModuleChannelReference {
module_id,
channel_id,
}),
];
let length = {
let fixed = 4u16;
let per_value = 9u16;
let value_count = 3u16;
fixed + per_value * value_count
};
assert_eq!(length, 0x001F);
assert_eq!(0x001F, 31);
let message = Request { values };
message.write_to(&mut buffer, options, sequence).unwrap();
assert_eq!(
buffer,
vec![
0x45,
0x93,
0x04,
0x28,
0x1D,
0x00,
0x03,
0x00,
0x06,
0x00,
0x15,
0x34,
0x12,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x21,
0x19,
0x32,
0x45,
0x00,
0x00,
0x00,
0x00,
]
);
}
#[test]
fn from_payload_empty() {
let buffer = vec![
0x00,
0x00,
];
let len = buffer.len() as u16;
let message =
Request::read_from_payload(&mut buffer.as_slice(), len)
.unwrap();
let values = Vec::new();
assert_eq!(message, Request { values });
}
#[test]
fn from_payload_single_bool() {
let buffer = vec![
0x01,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
];
let len = buffer.len() as u16;
let message =
Request::read_from_payload(&mut buffer.as_slice(), len)
.unwrap();
let values = vec![true.into()];
assert_eq!(message, Request { values });
}
#[test]
fn read_from_three_items() {
use crate::base::ParameterValue;
let buffer = vec![
0x03,
0x00,
0x06,
0x00,
0x15,
0x34,
0x12,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x21,
0x19,
0x32,
0x45,
0x00,
0x00,
0x00,
0x00,
];
let len = buffer.len() as u16;
let message =
Request::read_from_payload(&mut buffer.as_slice(), len)
.unwrap();
let module_id = 0x4532;
let channel_id = 0x1921;
let values = vec![
0x1234u16.into(),
true.into(),
ParameterValue::UInt8Channel(ModuleChannelReference {
module_id,
channel_id,
}),
];
assert_eq!(message, Request { values });
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Response {
pub error: ErrorCode,
}
impl IsResponse for Response {
type Request = Request;
}
impl IsValidResponseFor for Response {
fn is_valid_response_for(&self, _request: &Request) -> bool {
true
}
}
impl HasErrorCode for Response {
fn error_code(&self) -> ErrorCode {
self.error
}
}
impl TryFromResponse for Response {
fn try_from_response(r: super::Response) -> Result<Self> {
if let super::Response::UploadJobParameters(r) = r {
Ok(r)
} else {
error::UnexpectedResponseType.fail()
}
}
}
impl From<Response> for super::Response {
fn from(m: Response) -> Self {
super::Response::UploadJobParameters(m)
}
}
impl WithFixedPayloadLength for Response {
const FIXED_PAYLOAD_LENGTH: u16 = ErrorCode::FIXED_PAYLOAD_LENGTH;
}
impl HasFixedCommandId for Response {
const COMMAND_ID: u16 = 0x2805;
}
impl MessageExt for Response {
fn payload_length(&self) -> u16 {
Self::FIXED_PAYLOAD_LENGTH
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
w.write_error_code(self.error)?;
Ok(())
}
}
impl ReadFromPayload for Response {
fn read_from_payload<R: Read>(
r: &mut R,
payload_length: u16,
) -> Result<Self> {
Self::verify_payload_length(
payload_length,
"upload_job_parameters_response",
)?;
let error = r.read_error_code()?;
Ok(Self { error })
}
}
#[cfg(test)]
mod test_response {
use super::*;
#[test]
fn write_to() {
let mut buffer = Vec::new();
let options: u8 = 0x45;
let sequence: u8 = 0x93;
let message = Response {
error: ErrorCode::InvalidState,
};
message.write_to(&mut buffer, options, sequence).unwrap();
assert_eq!(
buffer,
[
0x45,
0x93,
0x05,
0x28,
0x02,
0x00,
0x07,
0x01,
]
);
}
#[test]
fn read_from_payload() {
let buffer = vec![0x07, 0x01];
let len = buffer.len() as u16;
let message =
Response::read_from_payload(&mut buffer.as_slice(), len)
.unwrap();
assert_eq!(
message,
Response {
error: ErrorCode::InvalidState,
}
);
}
}