mod imports {
pub use crate::Message;
}
use std::io::{Read, Write};
use crate::{base, error, Endian, Error, ReadExt, Result, WriteExt};
pub mod clear_job_set;
pub mod initialize_module;
pub mod job_position_at;
pub mod job_stopped;
pub mod measurement_data;
pub mod query_command_set_version;
pub mod query_device_capability;
pub mod query_device_firmware_version;
pub mod query_device_manufacturer;
pub mod query_device_uuid;
pub mod query_frame_format_version;
pub mod query_job;
pub mod query_job_parameters;
pub mod query_job_set_info;
pub mod query_module_state;
pub mod read_raw_value_from_parameter;
pub mod read_value_from_module_channel;
pub mod read_value_from_parameter;
pub mod start_job;
pub mod start_module;
pub mod stop_job;
pub mod stop_module;
pub mod uninitialize_module;
pub mod upload_job;
pub mod upload_job_parameters;
pub mod write_value_to_module_channel;
pub mod write_value_to_parameter;
pub trait HasFixedCommandId: HasCommandId {
const COMMAND_ID: u16;
}
pub trait HasCommandId {
fn command_id(&self) -> u16;
}
impl<T: HasFixedCommandId> HasCommandId for T {
fn command_id(&self) -> u16 {
Self::COMMAND_ID
}
}
pub(crate) trait MessageExt: HasCommandId {
fn write_to(
&self,
w: &mut Write,
options: u8,
sequence: u8,
) -> Result<()> {
self.write_header(w, options, sequence)?;
self.write_payload(w)?;
Ok(())
}
fn write_header(
&self,
w: &mut Write,
options: u8,
sequence: u8,
) -> Result<()> {
w.write_u8(options)?;
w.write_u8(sequence)?;
w.write_u16::<Endian>(self.command_id())?;
w.write_u16::<Endian>(self.payload_length())?;
Ok(())
}
fn payload_length(&self) -> u16;
fn write_payload(&self, w: &mut Write) -> Result<()>;
}
pub(crate) trait ResponseExt:
MessageExt + base::HasErrorCode
{
}
impl<R> ResponseExt for R where R: MessageExt + base::HasErrorCode {}
pub trait AsResult: Sized {
fn as_result(self) -> Result<Self>;
}
impl<R> AsResult for R
where
R: Sized + base::HasErrorCode,
{
fn as_result(self) -> Result<Self> {
match self.error_code() {
base::ErrorCode::Success => Ok(self),
error_code => error::Xio { error_code }.fail()?,
}
}
}
pub(crate) trait ReadFromPayload: Sized {
fn read_from_payload<R: Read>(
r: &mut R,
payload_length: u16,
) -> Result<Self>;
}
pub trait IsRequest: Sized {
type Response: IsResponse<Request = Self>;
}
pub trait IsResponse: Sized {
type Request: IsRequest<Response = Self>;
}
pub trait IsValidResponseFor: IsResponse {
fn is_valid_response_for(&self, request: &Self::Request) -> bool;
}
impl IsRequest for Request {
type Response = Response;
}
impl IsResponse for Response {
type Request = Request;
}
impl IsRequest for Vec<Request> {
type Response = Vec<Response>;
}
impl IsResponse for Vec<Response> {
type Request = Vec<Request>;
}
#[derive(Clone, Debug)]
pub enum Request {
ClearJobSet(clear_job_set::Request),
InitializeModule(initialize_module::Request),
QueryCommandSetVersion(query_command_set_version::Request),
QueryDeviceCapability(query_device_capability::Request),
QueryDeviceFirmwareVersion(query_device_firmware_version::Request),
QueryDeviceManufacturer(query_device_manufacturer::Request),
QueryDeviceUuid(query_device_uuid::Request),
QueryFrameFormatVersion(query_frame_format_version::Request),
QueryJobParameters(query_job_parameters::Request),
QueryJob(query_job::Request),
QueryJobSetInfo(query_job_set_info::Request),
QueryModuleState(query_module_state::Request),
ReadRawValueFromParameter(read_raw_value_from_parameter::Request),
ReadValueFromModuleChannel(read_value_from_module_channel::Request),
ReadValueFromParameter(read_value_from_parameter::Request),
StartJob(start_job::Request),
StartModule(start_module::Request),
StopJob(stop_job::Request),
StopModule(stop_module::Request),
UninitializeModule(uninitialize_module::Request),
UploadJobParameters(upload_job_parameters::Request),
UploadJob(upload_job::Request),
WriteValueToModuleChannel(write_value_to_module_channel::Request),
WriteValueToParameter(write_value_to_parameter::Request),
}
impl Request {
fn run_on_inner<F: FnOnce(&MessageExt) -> T, T>(&self, f: F) -> T {
match *self {
Request::ClearJobSet(ref r) => f(r),
Request::InitializeModule(ref r) => f(r),
Request::QueryCommandSetVersion(ref r) => f(r),
Request::QueryDeviceCapability(ref r) => f(r),
Request::QueryDeviceFirmwareVersion(ref r) => f(r),
Request::QueryDeviceManufacturer(ref r) => f(r),
Request::QueryDeviceUuid(ref r) => f(r),
Request::QueryFrameFormatVersion(ref r) => f(r),
Request::QueryJobParameters(ref r) => f(r),
Request::QueryJob(ref r) => f(r),
Request::QueryJobSetInfo(ref r) => f(r),
Request::QueryModuleState(ref r) => f(r),
Request::ReadRawValueFromParameter(ref r) => f(r),
Request::ReadValueFromModuleChannel(ref r) => f(r),
Request::ReadValueFromParameter(ref r) => f(r),
Request::StartJob(ref r) => f(r),
Request::StartModule(ref r) => f(r),
Request::StopJob(ref r) => f(r),
Request::StopModule(ref r) => f(r),
Request::UninitializeModule(ref r) => f(r),
Request::UploadJobParameters(ref r) => f(r),
Request::UploadJob(ref r) => f(r),
Request::WriteValueToModuleChannel(ref r) => f(r),
Request::WriteValueToParameter(ref r) => f(r),
}
}
}
impl HasCommandId for Request {
fn command_id(&self) -> u16 {
self.run_on_inner(|msg| msg.command_id())
}
}
impl MessageExt for Request {
fn payload_length(&self) -> u16 {
self.run_on_inner(|msg| msg.payload_length())
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
self.run_on_inner(|msg| msg.write_payload(w))
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Response {
ClearJobSet(clear_job_set::Response),
InitializeModule(initialize_module::Response),
QueryCommandSetVersion(query_command_set_version::Response),
QueryDeviceCapability(query_device_capability::Response),
QueryDeviceFirmwareVersion(query_device_firmware_version::Response),
QueryDeviceManufacturer(query_device_manufacturer::Response),
QueryDeviceUuid(query_device_uuid::Response),
QueryFrameFormatVersion(query_frame_format_version::Response),
QueryJobParameters(query_job_parameters::Response),
QueryJob(query_job::Response),
QueryJobSetInfo(query_job_set_info::Response),
QueryModuleState(query_module_state::Response),
ReadRawValueFromParameter(read_raw_value_from_parameter::Response),
ReadValueFromModuleChannel(read_value_from_module_channel::Response),
ReadValueFromParameter(read_value_from_parameter::Response),
StartJob(start_job::Response),
StartModule(start_module::Response),
StopJob(stop_job::Response),
StopModule(stop_module::Response),
UninitializeModule(uninitialize_module::Response),
UploadJobParameters(upload_job_parameters::Response),
UploadJob(upload_job::Response),
WriteValueToModuleChannel(write_value_to_module_channel::Response),
WriteValueToParameter(write_value_to_parameter::Response),
}
impl Response {
fn run_on_inner<F: FnOnce(&ResponseExt) -> T, T>(&self, f: F) -> T {
match *self {
Response::ClearJobSet(ref r) => f(r),
Response::InitializeModule(ref r) => f(r),
Response::QueryCommandSetVersion(ref r) => f(r),
Response::QueryDeviceCapability(ref r) => f(r),
Response::QueryDeviceFirmwareVersion(ref r) => f(r),
Response::QueryDeviceManufacturer(ref r) => f(r),
Response::QueryDeviceUuid(ref r) => f(r),
Response::QueryFrameFormatVersion(ref r) => f(r),
Response::QueryJobParameters(ref r) => f(r),
Response::QueryJob(ref r) => f(r),
Response::QueryJobSetInfo(ref r) => f(r),
Response::QueryModuleState(ref r) => f(r),
Response::ReadRawValueFromParameter(ref r) => f(r),
Response::ReadValueFromModuleChannel(ref r) => f(r),
Response::ReadValueFromParameter(ref r) => f(r),
Response::StartJob(ref r) => f(r),
Response::StartModule(ref r) => f(r),
Response::StopJob(ref r) => f(r),
Response::StopModule(ref r) => f(r),
Response::UninitializeModule(ref r) => f(r),
Response::UploadJobParameters(ref r) => f(r),
Response::UploadJob(ref r) => f(r),
Response::WriteValueToModuleChannel(ref r) => f(r),
Response::WriteValueToParameter(ref r) => f(r),
}
}
}
impl IsValidResponseFor for Response {
fn is_valid_response_for(&self, request: &Request) -> bool {
match (request, self) {
(
&Request::ClearJobSet(ref request),
&Response::ClearJobSet(ref response),
) => response.is_valid_response_for(&request),
(
&Request::InitializeModule(ref request),
&Response::InitializeModule(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryCommandSetVersion(ref request),
&Response::QueryCommandSetVersion(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryDeviceCapability(ref request),
&Response::QueryDeviceCapability(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryDeviceFirmwareVersion(ref request),
&Response::QueryDeviceFirmwareVersion(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryDeviceManufacturer(ref request),
&Response::QueryDeviceManufacturer(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryDeviceUuid(ref request),
&Response::QueryDeviceUuid(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryFrameFormatVersion(ref request),
&Response::QueryFrameFormatVersion(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryJobParameters(ref request),
&Response::QueryJobParameters(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryJob(ref request),
&Response::QueryJob(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryJobSetInfo(ref request),
&Response::QueryJobSetInfo(ref response),
) => response.is_valid_response_for(&request),
(
&Request::QueryModuleState(ref request),
&Response::QueryModuleState(ref response),
) => response.is_valid_response_for(&request),
(
&Request::ReadRawValueFromParameter(ref request),
&Response::ReadRawValueFromParameter(ref response),
) => response.is_valid_response_for(&request),
(
&Request::ReadValueFromModuleChannel(ref request),
&Response::ReadValueFromModuleChannel(ref response),
) => response.is_valid_response_for(&request),
(
&Request::ReadValueFromParameter(ref request),
&Response::ReadValueFromParameter(ref response),
) => response.is_valid_response_for(&request),
(
&Request::StartJob(ref request),
&Response::StartJob(ref response),
) => response.is_valid_response_for(&request),
(
&Request::StartModule(ref request),
&Response::StartModule(ref response),
) => response.is_valid_response_for(&request),
(
&Request::StopJob(ref request),
&Response::StopJob(ref response),
) => response.is_valid_response_for(&request),
(
&Request::StopModule(ref request),
&Response::StopModule(ref response),
) => response.is_valid_response_for(&request),
(
&Request::UninitializeModule(ref request),
&Response::UninitializeModule(ref response),
) => response.is_valid_response_for(&request),
(
&Request::UploadJobParameters(ref request),
&Response::UploadJobParameters(ref response),
) => response.is_valid_response_for(&request),
(
&Request::UploadJob(ref request),
&Response::UploadJob(ref response),
) => response.is_valid_response_for(&request),
(
&Request::WriteValueToModuleChannel(ref request),
&Response::WriteValueToModuleChannel(ref response),
) => response.is_valid_response_for(&request),
(
&Request::WriteValueToParameter(ref request),
&Response::WriteValueToParameter(ref response),
) => response.is_valid_response_for(&request),
_ => false,
}
}
}
impl base::HasErrorCode for Response {
fn error_code(&self) -> base::ErrorCode {
self.run_on_inner(|f| f.error_code())
}
}
pub trait TryFromResponse: Sized {
fn try_from_response(r: Response) -> Result<Self>;
}
impl HasCommandId for Response {
fn command_id(&self) -> u16 {
self.run_on_inner(|msg| msg.command_id())
}
}
impl MessageExt for Response {
fn payload_length(&self) -> u16 {
self.run_on_inner(|msg| msg.payload_length())
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
self.run_on_inner(|msg| msg.write_payload(w))
}
}
#[derive(Clone, Debug)]
pub enum Notification {
JobPositionAt(job_position_at::Notification),
JobStopped(job_stopped::Notification),
MeasurementData(measurement_data::Notification),
}
impl Notification {
fn run_on_inner<F: FnOnce(&MessageExt) -> T, T>(&self, f: F) -> T {
match *self {
Notification::JobPositionAt(ref r) => f(r),
Notification::JobStopped(ref r) => f(r),
Notification::MeasurementData(ref r) => f(r),
}
}
}
impl HasCommandId for Notification {
fn command_id(&self) -> u16 {
self.run_on_inner(|msg| msg.command_id())
}
}
impl MessageExt for Notification {
fn payload_length(&self) -> u16 {
self.run_on_inner(|msg| msg.payload_length())
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
self.run_on_inner(|msg| msg.write_payload(w))
}
}
#[derive(Clone, Debug)]
pub enum Message {
Request(Request),
Response(Response),
Notification(Notification),
}
impl Message {
fn rd<R: Read, T: ReadFromPayload>(
r: &mut R,
payload_length: u16,
) -> Result<T> {
T::read_from_payload(r, payload_length)
}
pub(crate) fn read_from<R: Read>(r: &mut R) -> Result<(u8, Self)> {
let (_options, seq, command_id, payload_length) =
Self::read_header(r)?;
use crate::Message::Notification as Nt;
use crate::Message::Request as Rq;
use crate::Message::Response as Rs;
let l = payload_length;
match command_id {
clear_job_set::Request::COMMAND_ID => {
Ok((seq, Rq(Request::ClearJobSet(Self::rd(r, l)?))))
}
clear_job_set::Response::COMMAND_ID => {
Ok((seq, Rs(Response::ClearJobSet(Self::rd(r, l)?))))
}
initialize_module::Request::COMMAND_ID => {
Ok((seq, Rq(Request::InitializeModule(Self::rd(r, l)?))))
}
initialize_module::Response::COMMAND_ID => {
Ok((seq, Rs(Response::InitializeModule(Self::rd(r, l)?))))
}
job_position_at::Notification::COMMAND_ID => {
Ok((seq, Nt(Notification::JobPositionAt(Self::rd(r, l)?))))
}
job_stopped::Notification::COMMAND_ID => {
Ok((seq, Nt(Notification::JobStopped(Self::rd(r, l)?))))
}
measurement_data::Notification::COMMAND_ID => Ok((
seq,
Nt(Notification::MeasurementData(Self::rd(r, l)?)),
)),
query_command_set_version::Request::COMMAND_ID => Ok((
seq,
Rq(Request::QueryCommandSetVersion(Self::rd(r, l)?)),
)),
query_command_set_version::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryCommandSetVersion(Self::rd(r, l)?)),
)),
query_device_capability::Request::COMMAND_ID => Ok((
seq,
Rq(Request::QueryDeviceCapability(Self::rd(r, l)?)),
)),
query_device_capability::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryDeviceCapability(Self::rd(r, l)?)),
)),
query_device_firmware_version::Request::COMMAND_ID => Ok((
seq,
Rq(Request::QueryDeviceFirmwareVersion(Self::rd(r, l)?)),
)),
query_device_firmware_version::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryDeviceFirmwareVersion(Self::rd(r, l)?)),
)),
query_device_manufacturer::Request::COMMAND_ID => Ok((
seq,
Rq(Request::QueryDeviceManufacturer(Self::rd(r, l)?)),
)),
query_device_manufacturer::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryDeviceManufacturer(Self::rd(r, l)?)),
)),
query_device_uuid::Request::COMMAND_ID => {
Ok((seq, Rq(Request::QueryDeviceUuid(Self::rd(r, l)?))))
}
query_device_uuid::Response::COMMAND_ID => {
Ok((seq, Rs(Response::QueryDeviceUuid(Self::rd(r, l)?))))
}
query_frame_format_version::Request::COMMAND_ID => Ok((
seq,
Rq(Request::QueryFrameFormatVersion(Self::rd(r, l)?)),
)),
query_frame_format_version::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryFrameFormatVersion(Self::rd(r, l)?)),
)),
query_job_parameters::Request::COMMAND_ID => {
Ok((seq, Rq(Request::QueryJobParameters(Self::rd(r, l)?))))
}
query_job_parameters::Response::COMMAND_ID => Ok((
seq,
Rs(Response::QueryJobParameters(Self::rd(r, l)?)),
)),
query_job::Request::COMMAND_ID => {
Ok((seq, Rq(Request::QueryJob(Self::rd(r, l)?))))
}
query_job::Response::COMMAND_ID => {
Ok((seq, Rs(Response::QueryJob(Self::rd(r, l)?))))
}
query_job_set_info::Request::COMMAND_ID => {
Ok((seq, Rq(Request::QueryJobSetInfo(Self::rd(r, l)?))))
}
query_job_set_info::Response::COMMAND_ID => {
Ok((seq, Rs(Response::QueryJobSetInfo(Self::rd(r, l)?))))
}
query_module_state::Request::COMMAND_ID => {
Ok((seq, Rq(Request::QueryModuleState(Self::rd(r, l)?))))
}
query_module_state::Response::COMMAND_ID => {
Ok((seq, Rs(Response::QueryModuleState(Self::rd(r, l)?))))
}
read_raw_value_from_parameter::Request::COMMAND_ID => Ok((
seq,
Rq(Request::ReadRawValueFromParameter(Self::rd(r, l)?)),
)),
read_raw_value_from_parameter::Response::COMMAND_ID => Ok((
seq,
Rs(Response::ReadRawValueFromParameter(Self::rd(r, l)?)),
)),
read_value_from_module_channel::Request::COMMAND_ID => Ok((
seq,
Rq(Request::ReadValueFromModuleChannel(Self::rd(r, l)?)),
)),
read_value_from_module_channel::Response::COMMAND_ID => Ok((
seq,
Rs(Response::ReadValueFromModuleChannel(Self::rd(r, l)?)),
)),
read_value_from_parameter::Request::COMMAND_ID => Ok((
seq,
Rq(Request::ReadValueFromParameter(Self::rd(r, l)?)),
)),
read_value_from_parameter::Response::COMMAND_ID => Ok((
seq,
Rs(Response::ReadValueFromParameter(Self::rd(r, l)?)),
)),
start_job::Request::COMMAND_ID => {
Ok((seq, Rq(Request::StartJob(Self::rd(r, l)?))))
}
start_job::Response::COMMAND_ID => {
Ok((seq, Rs(Response::StartJob(Self::rd(r, l)?))))
}
start_module::Request::COMMAND_ID => {
Ok((seq, Rq(Request::StartModule(Self::rd(r, l)?))))
}
start_module::Response::COMMAND_ID => {
Ok((seq, Rs(Response::StartModule(Self::rd(r, l)?))))
}
stop_job::Request::COMMAND_ID => {
Ok((seq, Rq(Request::StopJob(Self::rd(r, l)?))))
}
stop_job::Response::COMMAND_ID => {
Ok((seq, Rs(Response::StopJob(Self::rd(r, l)?))))
}
stop_module::Request::COMMAND_ID => {
Ok((seq, Rq(Request::StopModule(Self::rd(r, l)?))))
}
stop_module::Response::COMMAND_ID => {
Ok((seq, Rs(Response::StopModule(Self::rd(r, l)?))))
}
uninitialize_module::Request::COMMAND_ID => {
Ok((seq, Rq(Request::UninitializeModule(Self::rd(r, l)?))))
}
uninitialize_module::Response::COMMAND_ID => Ok((
seq,
Rs(Response::UninitializeModule(Self::rd(r, l)?)),
)),
upload_job_parameters::Request::COMMAND_ID => Ok((
seq,
Rq(Request::UploadJobParameters(Self::rd(r, l)?)),
)),
upload_job_parameters::Response::COMMAND_ID => Ok((
seq,
Rs(Response::UploadJobParameters(Self::rd(r, l)?)),
)),
upload_job::Request::COMMAND_ID => {
Ok((seq, Rq(Request::UploadJob(Self::rd(r, l)?))))
}
upload_job::Response::COMMAND_ID => {
Ok((seq, Rs(Response::UploadJob(Self::rd(r, l)?))))
}
write_value_to_module_channel::Request::COMMAND_ID => Ok((
seq,
Rq(Request::WriteValueToModuleChannel(Self::rd(r, l)?)),
)),
write_value_to_module_channel::Response::COMMAND_ID => Ok((
seq,
Rs(Response::WriteValueToModuleChannel(Self::rd(r, l)?)),
)),
write_value_to_parameter::Request::COMMAND_ID => Ok((
seq,
Rq(Request::WriteValueToParameter(Self::rd(r, l)?)),
)),
write_value_to_parameter::Response::COMMAND_ID => Ok((
seq,
Rs(Response::WriteValueToParameter(Self::rd(r, l)?)),
)),
_ => error::UnknownCommandId { command_id }.fail()?,
}
}
fn read_header<R: Read>(r: &mut R) -> Result<(u8, u8, u16, u16)> {
Ok((
r.read_u8()?,
r.read_u8()?,
r.read_u16::<Endian>()?,
r.read_u16::<Endian>()?,
))
}
fn run_on_inner<F: FnOnce(&MessageExt) -> T, T>(&self, f: F) -> T {
match *self {
Message::Request(ref r) => f(r),
Message::Response(ref r) => f(r),
Message::Notification(ref r) => f(r),
}
}
}
impl HasCommandId for Message {
fn command_id(&self) -> u16 {
self.run_on_inner(|msg| msg.command_id())
}
}
impl MessageExt for Message {
fn payload_length(&self) -> u16 {
self.run_on_inner(|msg| msg.payload_length())
}
fn write_payload(&self, w: &mut Write) -> Result<()> {
self.run_on_inner(|msg| msg.write_payload(w))
}
}
pub trait ProcessResponses {
type Error: From<Error>;
fn get_next_request(
&mut self,
) -> ::std::result::Result<Request, Self::Error>;
fn process_responses(
&mut self,
responses: &[Response],
) -> ::std::result::Result<(), Self::Error> {
for response in responses {
self.process_response(response)?;
}
Ok(())
}
fn process_response(
&mut self,
response: &Response,
) -> ::std::result::Result<(), Self::Error> {
use crate::Request as Rq;
use crate::Response as Rs;
let request = self.get_next_request()?;
match (&request, response) {
(Rq::ClearJobSet(ref rq), &Rs::ClearJobSet(ref rs)) => {
self.process_clear_job_set_response(rq, rs)
}
(
Rq::InitializeModule(ref rq),
&Rs::InitializeModule(ref rs),
) => self.process_initialize_module_response(rq, rs),
(
Rq::QueryCommandSetVersion(ref rq),
&Rs::QueryCommandSetVersion(ref rs),
) => self.process_query_command_set_version_response(rq, rs),
(
Rq::QueryDeviceCapability(ref rq),
&Rs::QueryDeviceCapability(ref rs),
) => self.process_query_device_capability_response(rq, rs),
(
Rq::QueryDeviceFirmwareVersion(ref rq),
&Rs::QueryDeviceFirmwareVersion(ref rs),
) => {
self.process_query_device_firmware_version_response(rq, rs)
}
(
Rq::QueryDeviceManufacturer(ref rq),
&Rs::QueryDeviceManufacturer(ref rs),
) => self.process_query_device_manufacturer_response(rq, rs),
(
Rq::QueryDeviceUuid(ref rq),
&Rs::QueryDeviceUuid(ref rs),
) => self.process_query_device_uuid_response(rq, rs),
(
Rq::QueryFrameFormatVersion(ref rq),
&Rs::QueryFrameFormatVersion(ref rs),
) => self.process_query_frame_format_version_response(rq, rs),
(
Rq::QueryJobParameters(ref rq),
&Rs::QueryJobParameters(ref rs),
) => self.process_query_job_parameters_response(rq, rs),
(Rq::QueryJob(ref rq), &Rs::QueryJob(ref rs)) => {
self.process_query_job_response(rq, rs)
}
(
Rq::QueryJobSetInfo(ref rq),
&Rs::QueryJobSetInfo(ref rs),
) => self.process_query_job_set_info_response(rq, rs),
(
Rq::QueryModuleState(ref rq),
&Rs::QueryModuleState(ref rs),
) => self.process_query_module_state_response(rq, rs),
(
Rq::ReadRawValueFromParameter(ref rq),
&Rs::ReadRawValueFromParameter(ref rs),
) => {
self.process_read_raw_value_from_parameter_response(rq, rs)
}
(
Rq::ReadValueFromModuleChannel(ref rq),
&Rs::ReadValueFromModuleChannel(ref rs),
) => self
.process_read_value_from_module_channel_response(rq, rs),
(
Rq::ReadValueFromParameter(ref rq),
&Rs::ReadValueFromParameter(ref rs),
) => self.process_read_value_from_parameter_response(rq, rs),
(Rq::StartJob(ref rq), &Rs::StartJob(ref rs)) => {
self.process_start_job_response(rq, rs)
}
(Rq::StartModule(ref rq), &Rs::StartModule(ref rs)) => {
self.process_start_module_response(rq, rs)
}
(Rq::StopJob(ref rq), &Rs::StopJob(ref rs)) => {
self.process_stop_job_response(rq, rs)
}
(Rq::StopModule(ref rq), &Rs::StopModule(ref rs)) => {
self.process_stop_module_response(rq, rs)
}
(
Rq::UninitializeModule(ref rq),
&Rs::UninitializeModule(ref rs),
) => self.process_uninitialize_module_response(rq, rs),
(
Rq::UploadJobParameters(ref rq),
&Rs::UploadJobParameters(ref rs),
) => self.process_upload_job_parameters_response(rq, rs),
(Rq::UploadJob(ref rq), &Rs::UploadJob(ref rs)) => {
self.process_upload_job_response(rq, rs)
}
(
Rq::WriteValueToModuleChannel(ref rq),
&Rs::WriteValueToModuleChannel(ref rs),
) => {
self.process_write_value_to_module_channel_response(rq, rs)
}
(
Rq::WriteValueToParameter(ref rq),
&Rs::WriteValueToParameter(ref rs),
) => self.process_write_value_to_parameter_response(rq, rs),
_ => error::UnmatchedResponse {
request: request.clone(),
response: response.clone(),
}
.fail()?,
}
}
fn process_clear_job_set_response(
&mut self,
_request: &clear_job_set::Request,
response: &clear_job_set::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_initialize_module_response(
&mut self,
_request: &initialize_module::Request,
response: &initialize_module::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_command_set_version_response(
&mut self,
_request: &query_command_set_version::Request,
response: &query_command_set_version::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_device_capability_response(
&mut self,
_request: &query_device_capability::Request,
response: &query_device_capability::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_device_firmware_version_response(
&mut self,
_request: &query_device_firmware_version::Request,
response: &query_device_firmware_version::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_device_manufacturer_response(
&mut self,
_request: &query_device_manufacturer::Request,
response: &query_device_manufacturer::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_device_uuid_response(
&mut self,
_request: &query_device_uuid::Request,
response: &query_device_uuid::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_frame_format_version_response(
&mut self,
_request: &query_frame_format_version::Request,
response: &query_frame_format_version::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_job_response(
&mut self,
_request: &query_job::Request,
response: &query_job::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_job_parameters_response(
&mut self,
_request: &query_job_parameters::Request,
response: &query_job_parameters::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_job_set_info_response(
&mut self,
_request: &query_job_set_info::Request,
response: &query_job_set_info::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_query_module_state_response(
&mut self,
_request: &query_module_state::Request,
response: &query_module_state::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_read_raw_value_from_parameter_response(
&mut self,
_request: &read_raw_value_from_parameter::Request,
response: &read_raw_value_from_parameter::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_read_value_from_module_channel_response(
&mut self,
_request: &read_value_from_module_channel::Request,
response: &read_value_from_module_channel::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_read_value_from_parameter_response(
&mut self,
_request: &read_value_from_parameter::Request,
response: &read_value_from_parameter::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_start_job_response(
&mut self,
_request: &start_job::Request,
response: &start_job::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_start_module_response(
&mut self,
_request: &start_module::Request,
response: &start_module::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_stop_job_response(
&mut self,
_request: &stop_job::Request,
response: &stop_job::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_stop_module_response(
&mut self,
_request: &stop_module::Request,
response: &stop_module::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_uninitialize_module_response(
&mut self,
_request: &uninitialize_module::Request,
response: &uninitialize_module::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_upload_job_response(
&mut self,
_request: &upload_job::Request,
response: &upload_job::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_upload_job_parameters_response(
&mut self,
_request: &upload_job_parameters::Request,
response: &upload_job_parameters::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_write_value_to_module_channel_response(
&mut self,
_request: &write_value_to_module_channel::Request,
response: &write_value_to_module_channel::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
fn process_write_value_to_parameter_response(
&mut self,
_request: &write_value_to_parameter::Request,
response: &write_value_to_parameter::Response,
) -> ::std::result::Result<(), Self::Error> {
response.as_result()?;
Ok(())
}
}
pub trait ProcessNotifications {
type Error;
fn process_notifications(
&mut self,
notifications: &[Notification],
) -> ::std::result::Result<(), Self::Error> {
for notification in notifications {
self.process_notification(notification)?;
}
Ok(())
}
fn process_notification(
&mut self,
notification: &Notification,
) -> ::std::result::Result<(), Self::Error> {
use crate::Notification::*;
match *notification {
JobPositionAt(ref n) => {
self.process_job_position_at_notification(n)
}
JobStopped(ref n) => self.process_job_stopped_notification(n),
MeasurementData(ref n) => {
self.process_measurement_data_notification(n)
}
}
}
fn process_job_position_at_notification(
&mut self,
_notification: &job_position_at::Notification,
) -> ::std::result::Result<(), Self::Error> {
Ok(())
}
fn process_job_stopped_notification(
&mut self,
_notification: &job_stopped::Notification,
) -> ::std::result::Result<(), Self::Error> {
Ok(())
}
fn process_measurement_data_notification(
&mut self,
_notification: &measurement_data::Notification,
) -> ::std::result::Result<(), Self::Error> {
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn into_result_success() {
let error = base::ErrorCode::Success;
let message =
Response::ClearJobSet(clear_job_set::Response { error });
let cloned = message.clone();
match message.as_result() {
Ok(unwrapped) => assert_eq!(cloned, unwrapped),
Err(e) => panic!("expected ok, got err: {:?}", e),
}
}
#[test]
fn into_result_failed() {
let error = base::ErrorCode::TypeValueMismatch;
let message =
Response::ClearJobSet(clear_job_set::Response { error });
match message.as_result() {
Ok(unwrapped) => {
panic!("expected err, got ok({:?})", unwrapped)
}
Err(Error::Xio { error_code, .. }) => {
assert_eq!(error_code, error);
}
Err(e) => {
panic!("expected XIO err, got err: {:?}", e);
}
}
}
}