chore: Split message attrs into client/server versions

Instead of requiring the only message attributes class to conform to
what both the client AND server need, split attributes into server
(which will handle configuration) and client (which is what we'll fly
over the protocol).

buttplug/src/client/device.rs

···
       ButtplugCurrentSpecServerMessage,
       ButtplugDeviceMessageType,
       ButtplugMessage,
-      DeviceMessageAttributes,
+      ClientDeviceMessageAttributes,
       DeviceMessageInfo,
       Endpoint,
       LinearCmd,
···
   /// Map of messages the device can take, along with the attributes of those
   /// messages.
   #[getset(get = "pub")]
-  message_attributes: DeviceMessageAttributes,
+  message_attributes: ClientDeviceMessageAttributes,
   /// Sends commands from the [ButtplugClientDevice] instance to the
   /// [ButtplugClient][super::ButtplugClient]'s event loop, which will then send
   /// the message on to the [ButtplugServer][crate::server::ButtplugServer]
···
   pub(super) fn new(
     name: &str,
     index: u32,
-    message_attributes: &DeviceMessageAttributes,
+    message_attributes: &ClientDeviceMessageAttributes,
     message_sender: broadcast::Sender<ButtplugClientRequest>,
   ) -> Self {
     info!(

buttplug/src/core/messages/device_added.rs

···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributes,
+  device_messages: ClientDeviceMessageAttributes,
 }
 
 impl DeviceAdded {
   pub fn new(
     device_index: u32,
     device_name: &str,
-    device_messages: &DeviceMessageAttributes,
+    device_messages: &ClientDeviceMessageAttributes,
   ) -> Self {
     Self {
       id: 0,
···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributesV2,
+  device_messages: ClientDeviceMessageAttributesV2,
 }
 
 impl From<DeviceAdded> for DeviceAddedV2 {
···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributesV1,
+  device_messages: ClientDeviceMessageAttributesV1,
 }
 
 impl From<DeviceAdded> for DeviceAddedV1 {

buttplug/src/core/messages/device_message_info.rs

···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributes,
+  device_messages: ClientDeviceMessageAttributes,
 }
 
 impl DeviceMessageInfo {
   pub fn new(
     device_index: u32,
     device_name: &str,
-    device_messages: DeviceMessageAttributes,
+    device_messages: ClientDeviceMessageAttributes,
   ) -> Self {
     Self {
       device_index,
···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributesV2,
+  device_messages: ClientDeviceMessageAttributesV2,
 }
 
 impl From<DeviceAdded> for DeviceMessageInfoV2 {
···
   device_name: String,
   #[cfg_attr(feature = "serialize-json", serde(rename = "DeviceMessages"))]
   #[getset(get = "pub")]
-  device_messages: DeviceMessageAttributesV1,
+  device_messages: ClientDeviceMessageAttributesV1,
 }
 
 impl From<DeviceAdded> for DeviceMessageInfoV1 {

buttplug/src/core/messages/message_attributes.rs buttplug/src/core/messages/client_device_message_attributes.rs

···
   // Gyro,
 }
 
-// Unlike other message components, MessageAttributes is always turned on for
-// serialization, because it's used by device configuration files also.
+// This will look almost exactly like ServerDeviceMessageAttributes. However, it will only contain
+// information we want the client to know, i.e. step counts versus specific step ranges. This is
+// what will be sent to the client as part of DeviceAdded/DeviceList messages. It should not be used
+// for outside configuration/serialization, rather it should be a subset of that information.
+//
+// For many messages, client and server configurations may be exactly the same. If they are not,
+// then we denote this by prefixing the type with Client/Server. Server attributes will usually be
+// hosted in the server/device/configuration module.
 #[derive(
-  Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Getters, MutGetters, Setters,
+  Clone, Debug, Default, PartialEq, Eq, Getters, MutGetters, Setters,
 )]
-pub struct DeviceMessageAttributes {
+#[cfg_attr(feature = "serialize-json", derive(Serialize, Deserialize))]
+pub struct ClientDeviceMessageAttributes {
   // Generic commands
   #[getset(get = "pub", get_mut = "pub")]
   #[serde(rename = "ScalarCmd")]
   #[serde(skip_serializing_if = "Option::is_none")]
-  scalar_cmd: Option<Vec<GenericDeviceMessageAttributes>>,
+  scalar_cmd: Option<Vec<ClientGenericDeviceMessageAttributes>>,
   #[getset(get = "pub", get_mut = "pub")]
   #[serde(rename = "RotateCmd")]
   #[serde(skip_serializing_if = "Option::is_none")]
-  rotate_cmd: Option<Vec<GenericDeviceMessageAttributes>>,
+  rotate_cmd: Option<Vec<ClientGenericDeviceMessageAttributes>>,
   #[getset(get = "pub", get_mut = "pub")]
   #[serde(rename = "LinearCmd")]
   #[serde(skip_serializing_if = "Option::is_none")]
-  linear_cmd: Option<Vec<GenericDeviceMessageAttributes>>,
+  linear_cmd: Option<Vec<ClientGenericDeviceMessageAttributes>>,
 
   // Sensor Messages
   #[getset(get = "pub")]
···
   vorze_a10_cyclone_cmd: Option<NullDeviceMessageAttributes>,
 }
 
-impl DeviceMessageAttributes {
+impl ClientDeviceMessageAttributes {
   pub fn raw_unsubscribe_cmd(&self) -> &Option<RawDeviceMessageAttributes> {
     self.raw_subscribe_cmd()
   }
···
       ButtplugDeviceMessageType::LovenseCmd => false,
     }
   }
-
-  pub fn merge(&self, child: &DeviceMessageAttributes) -> DeviceMessageAttributes {
-    Self {
-      rotate_cmd: child
-        .rotate_cmd()
-        .clone()
-        .or_else(|| self.rotate_cmd().clone()),
-      linear_cmd: child
-        .linear_cmd()
-        .clone()
-        .or_else(|| self.linear_cmd().clone()),
-      scalar_cmd: child
-        .scalar_cmd()
-        .clone()
-        .or_else(|| self.scalar_cmd().clone()),
-      sensor_read_cmd: child
-        .sensor_read_cmd()
-        .clone()
-        .or_else(|| self.sensor_read_cmd().clone()),
-      sensor_subscribe_cmd: child
-        .sensor_subscribe_cmd()
-        .clone()
-        .or_else(|| self.sensor_subscribe_cmd().clone()),
-      stop_device_cmd: NullDeviceMessageAttributes::default(),
-      raw_read_cmd: child
-        .raw_read_cmd()
-        .clone()
-        .or_else(|| self.raw_read_cmd().clone()),
-      raw_write_cmd: child
-        .raw_write_cmd()
-        .clone()
-        .or_else(|| self.raw_write_cmd().clone()),
-      raw_subscribe_cmd: child
-        .raw_subscribe_cmd()
-        .clone()
-        .or_else(|| self.raw_subscribe_cmd().clone()),
-      fleshlight_launch_fw12_cmd: child
-        .fleshlight_launch_fw12_cmd()
-        .clone()
-        .or_else(|| self.fleshlight_launch_fw12_cmd().clone()),
-      vorze_a10_cyclone_cmd: child
-        .vorze_a10_cyclone_cmd()
-        .clone()
-        .or_else(|| self.vorze_a10_cyclone_cmd().clone()),
-    }
-  }
+}
 
-  pub fn add_raw_messages(&mut self, endpoints: &[Endpoint]) {
-    let raw_attrs = RawDeviceMessageAttributes {
-      endpoints: endpoints.clone().to_vec(),
-    };
-    self.raw_read_cmd = Some(raw_attrs.clone());
-    self.raw_write_cmd = Some(raw_attrs.clone());
-    self.raw_subscribe_cmd = Some(raw_attrs.clone());
-  }
-}
 
 #[derive(Default)]
-pub struct DeviceMessageAttributesBuilder {
-  attrs: DeviceMessageAttributes,
+pub struct ClientDeviceMessageAttributesBuilder {
+  attrs: ClientDeviceMessageAttributes,
 }
 
-impl DeviceMessageAttributesBuilder {
-  pub fn scalar_cmd(&mut self, attrs: &Vec<GenericDeviceMessageAttributes>) -> &Self {
+impl ClientDeviceMessageAttributesBuilder {
+  pub fn scalar_cmd(&mut self, attrs: &Vec<ClientGenericDeviceMessageAttributes>) -> &Self {
     self.attrs.scalar_cmd = Some(attrs.clone());
     self
   }
 
-  pub fn rotate_cmd(&mut self, attrs: &Vec<GenericDeviceMessageAttributes>) -> &Self {
+  pub fn rotate_cmd(&mut self, attrs: &Vec<ClientGenericDeviceMessageAttributes>) -> &Self {
     self.attrs.rotate_cmd = Some(attrs.clone());
     self
   }
 
-  pub fn linear_cmd(&mut self, attrs: &Vec<GenericDeviceMessageAttributes>) -> &Self {
+  pub fn linear_cmd(&mut self, attrs: &Vec<ClientGenericDeviceMessageAttributes>) -> &Self {
     self.attrs.linear_cmd = Some(attrs.clone());
     self
   }
···
     self
   }
 
-  pub fn finish(&self) -> DeviceMessageAttributes {
+  pub fn finish(&self) -> ClientDeviceMessageAttributes {
     self.attrs.clone()
   }
 }
 
+
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct NullDeviceMessageAttributes {}
 
···
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Getters, Setters)]
-pub struct GenericDeviceMessageAttributes {
+pub struct ClientGenericDeviceMessageAttributes {
   #[getset(get = "pub")]
   #[serde(rename = "FeatureDescriptor")]
   #[serde(default = "unspecified_feature")]
···
   #[getset(get = "pub")]
   #[serde(rename = "ActuatorType")]
   actuator_type: ActuatorType,
-  #[serde(rename = "StepRange")]
-  #[serde(skip_serializing)]
-  #[getset(get = "pub", set = "pub")]
-  step_range: RangeInclusive<u32>,
+  #[serde(rename = "StepCount")]
+  #[getset(get = "pub")]
+  step_count: u32
 }
 
-impl GenericDeviceMessageAttributes {
+impl ClientGenericDeviceMessageAttributes {
   pub fn new(
     feature_descriptor: &str,
-    step_range: &RangeInclusive<u32>,
+    step_count: u32,
     actuator_type: ActuatorType,
   ) -> Self {
     Self {
       feature_descriptor: feature_descriptor.to_owned(),
       actuator_type,
-      step_range: step_range.clone(),
+      step_count
     }
-  }
-
-  pub fn step_count(&self) -> u32 {
-    self.step_range.end() - self.step_range.start()
   }
 
   pub fn is_valid(
     &self,
     message_type: &ButtplugDeviceMessageType,
   ) -> Result<(), ButtplugDeviceError> {
-    if self.step_range.is_empty() {
-      Err(ButtplugDeviceError::DeviceConfigurationError(format!(
-        "Step range out of order for {}, must be start <= x <= end.",
-        message_type
-      )))
-    } else {
-      Ok(())
-    }
+    Ok(())
   }
 }
 
···
  */
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Getters, Setters)]
-pub struct DeviceMessageAttributesV2 {
+pub struct ClientDeviceMessageAttributesV2 {
   // Generic commands
   #[getset(get = "pub")]
   #[serde(rename = "VibrateCmd")]
···
   vorze_a10_cyclone_cmd: Option<NullDeviceMessageAttributes>,
 }
 
-impl From<DeviceMessageAttributes> for DeviceMessageAttributesV2 {
-  fn from(other: DeviceMessageAttributes) -> Self {
+impl From<ClientDeviceMessageAttributes> for ClientDeviceMessageAttributesV2 {
+  fn from(other: ClientDeviceMessageAttributes) -> Self {
     Self {
       vibrate_cmd: other
         .scalar_cmd()
···
 }
 
 impl GenericDeviceMessageAttributesV2 {
-  pub fn vibrate_cmd_from_scalar_cmd(attributes_vec: Vec<GenericDeviceMessageAttributes>) -> Self {
+  pub fn vibrate_cmd_from_scalar_cmd(attributes_vec: Vec<ClientGenericDeviceMessageAttributes>) -> Self {
     let mut feature_count = 0u32;
     let mut step_count = vec![];
     for attr in attributes_vec {
       if *attr.actuator_type() == ActuatorType::Vibrate {
         feature_count += 1;
-        step_count.push(attr.step_count());
+        step_count.push(*attr.step_count());
       }
     }
     Self {
       feature_count,
-      step_count,
+      step_count
     }
   }
 }
 
-impl From<Vec<GenericDeviceMessageAttributes>> for GenericDeviceMessageAttributesV2 {
-  fn from(attributes_vec: Vec<GenericDeviceMessageAttributes>) -> Self {
+impl From<Vec<ClientGenericDeviceMessageAttributes>> for GenericDeviceMessageAttributesV2 {
+  fn from(attributes_vec: Vec<ClientGenericDeviceMessageAttributes>) -> Self {
     Self {
       feature_count: attributes_vec.len() as u32,
-      step_count: attributes_vec.iter().map(|x| x.step_count()).collect(),
+      step_count: attributes_vec.iter().map(|x| *x.step_count()).collect(),
     }
   }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Getters, Setters)]
-pub struct DeviceMessageAttributesV1 {
+pub struct ClientDeviceMessageAttributesV1 {
   // Generic commands
   #[getset(get = "pub")]
   #[serde(rename = "VibrateCmd")]
···
   vorze_a10_cyclone_cmd: Option<NullDeviceMessageAttributes>,
 }
 
-impl From<DeviceMessageAttributesV2> for DeviceMessageAttributesV1 {
-  fn from(other: DeviceMessageAttributesV2) -> Self {
+impl From<ClientDeviceMessageAttributesV2> for ClientDeviceMessageAttributesV1 {
+  fn from(other: ClientDeviceMessageAttributesV2) -> Self {
     Self {
       vibrate_cmd: other
         .vibrate_cmd()
···
     }
   }
 }
-
-#[cfg(test)]
-mod test {
-  use super::*;
-
-  #[test]
-  pub fn test_step_count_calculation() {
-    let mut vibrate_attributes = GenericDeviceMessageAttributes::new(
-      "test",
-      &RangeInclusive::new(0, 10),
-      ActuatorType::Vibrate,
-    );
-    assert_eq!(vibrate_attributes.step_count(), 10);
-    vibrate_attributes.set_step_range(RangeInclusive::new(3u32, 7));
-    assert_eq!(vibrate_attributes.step_count(), 4);
-  }
-}

buttplug/src/core/messages/mod.rs

···
 mod log;
 mod log_level;
 mod lovense_cmd;
-mod message_attributes;
+mod client_device_message_attributes;
 mod ok;
 mod ping;
 mod raw_read_cmd;
···
 pub use linear_cmd::{LinearCmd, VectorSubcommand};
 pub use log_level::LogLevel;
 pub use lovense_cmd::LovenseCmd;
-pub use message_attributes::{
+pub use client_device_message_attributes::{
   ActuatorType,
-  DeviceMessageAttributes,
-  DeviceMessageAttributesBuilder,
-  DeviceMessageAttributesV1,
-  DeviceMessageAttributesV2,
-  GenericDeviceMessageAttributes,
+  ClientDeviceMessageAttributes,
+  ClientDeviceMessageAttributesBuilder,
+  ClientDeviceMessageAttributesV1,
+  ClientDeviceMessageAttributesV2,
+  ClientGenericDeviceMessageAttributes,
+  NullDeviceMessageAttributes,
+  RawDeviceMessageAttributes,
   SensorDeviceMessageAttributes,
   SensorType,
 };
···
   TryFromButtplugClientMessage,
 )]
 #[cfg_attr(feature = "serialize-json", derive(Serialize, Deserialize))]
-pub(crate) enum ButtplugSpecV1ClientMessage {
+pub enum ButtplugSpecV1ClientMessage {
   // Handshake messages
   RequestServerInfo(RequestServerInfo),
   Ping(Ping),
···
   Debug, Clone, PartialEq, Eq, ButtplugMessage, ButtplugMessageValidator, ButtplugServerMessageType,
 )]
 #[cfg_attr(feature = "serialize-json", derive(Serialize, Deserialize))]
-pub(crate) enum ButtplugSpecV1ServerMessage {
+pub enum ButtplugSpecV1ServerMessage {
   // Status messages
   Ok(Ok),
   Error(ErrorV0),
···
   TryFromButtplugClientMessage,
 )]
 #[cfg_attr(feature = "serialize-json", derive(Serialize, Deserialize))]
-pub(crate) enum ButtplugSpecV0ClientMessage {
+pub enum ButtplugSpecV0ClientMessage {
   RequestLog(RequestLog),
   Ping(Ping),
   // Handshake messages
···
   Debug, Clone, PartialEq, Eq, ButtplugMessage, ButtplugMessageValidator, ButtplugServerMessageType,
 )]
 #[cfg_attr(feature = "serialize-json", derive(Serialize, Deserialize))]
-pub(crate) enum ButtplugSpecV0ServerMessage {
+pub enum ButtplugSpecV0ServerMessage {
   // Status messages
   Ok(Ok),
   Error(ErrorV0),

buttplug/src/server/device/configuration/mod.rs

···
 //!
 
 pub mod specifier;
+mod server_device_message_attributes;
 pub use specifier::*;
+
+pub use server_device_message_attributes::{ServerDeviceMessageAttributes, ServerGenericDeviceMessageAttributes, ServerDeviceMessageAttributesBuilder};
 
 use super::protocol::{get_default_protocol_map, ProtocolIdentifierFactory, ProtocolSpecializer};
 use crate::{
   core::{
     errors::ButtplugDeviceError,
-    messages::{ButtplugDeviceMessageType, DeviceMessageAttributes, Endpoint},
+    messages::{ButtplugDeviceMessageType, Endpoint},
   },
   server::device::ServerDeviceIdentifier,
 };
···
   /// User configured name of the device this instance represents, assuming one exists.
   display_name: Option<String>,
   /// Message attributes for this device instance.
-  pub(super) message_attributes: DeviceMessageAttributes,
+  pub(super) message_attributes: ServerDeviceMessageAttributes,
 }
 
 impl ProtocolDeviceAttributes {
···
     identifier: ProtocolAttributesType,
     name: Option<String>,
     display_name: Option<String>,
-    message_attributes: DeviceMessageAttributes,
+    message_attributes: ServerDeviceMessageAttributes,
     parent: Option<Arc<ProtocolDeviceAttributes>>,
   ) -> Self {
     Self {
···
   }
 
   /// Retreive a map of all message attributes for this instance.
-  pub fn message_attributes(&self) -> DeviceMessageAttributes {
+  pub fn message_attributes(&self) -> ServerDeviceMessageAttributes {
     if let Some(parent) = &self.parent {
       parent.message_attributes().merge(&self.message_attributes)
     } else {
···
 
 #[cfg(test)]
 mod test {
-  use super::*;
-  use crate::core::messages::{DeviceMessageAttributesBuilder, GenericDeviceMessageAttributes};
+  use super::{*, server_device_message_attributes::{ServerDeviceMessageAttributesBuilder, ServerGenericDeviceMessageAttributes}};
   use std::{
     collections::{HashMap, HashSet},
     ops::RangeInclusive,
···
         ProtocolAttributesType::Identifier("P".to_owned()),
         Some("Lovense Edge".to_owned()),
         None,
-        DeviceMessageAttributesBuilder::default()
+        ServerDeviceMessageAttributesBuilder::default()
           .scalar_cmd(&vec![
-            GenericDeviceMessageAttributes::new(
+            ServerGenericDeviceMessageAttributes::new(
               "Edge Vibrator 1",
               &RangeInclusive::new(0, 20),
               crate::core::messages::ActuatorType::Vibrate,
             ),
-            GenericDeviceMessageAttributes::new(
+            ServerGenericDeviceMessageAttributes::new(
               "Edge Vibrator 2",
               &RangeInclusive::new(0, 20),
               crate::core::messages::ActuatorType::Vibrate,

buttplug/src/server/device/configuration/server_device_message_attributes.rs

···
+use std::ops::RangeInclusive;
+
+use serde::{Serialize, Deserialize};
+use getset::{Getters, MutGetters, Setters};
+
+use crate::core::{messages::{SensorDeviceMessageAttributes, NullDeviceMessageAttributes, RawDeviceMessageAttributes, ButtplugDeviceMessageType, SensorType, Endpoint, ActuatorType, ClientGenericDeviceMessageAttributes, ClientDeviceMessageAttributes, ClientDeviceMessageAttributesBuilder}, errors::ButtplugDeviceError};
+
+// Unlike other message components, MessageAttributes is always turned on for
+// serialization, because it's used by device configuration files also.
+#[derive(
+  Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Getters, MutGetters, Setters,
+)]
+pub struct ServerDeviceMessageAttributes {
+  // Generic commands
+  #[getset(get = "pub", get_mut = "pub")]
+  #[serde(rename = "ScalarCmd")]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  scalar_cmd: Option<Vec<ServerGenericDeviceMessageAttributes>>,
+  #[getset(get = "pub", get_mut = "pub")]
+  #[serde(rename = "RotateCmd")]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  rotate_cmd: Option<Vec<ServerGenericDeviceMessageAttributes>>,
+  #[getset(get = "pub", get_mut = "pub")]
+  #[serde(rename = "LinearCmd")]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  linear_cmd: Option<Vec<ServerGenericDeviceMessageAttributes>>,
+
+  // Sensor Messages
+  #[getset(get = "pub")]
+  #[serde(rename = "SensorReadCmd")]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  sensor_read_cmd: Option<Vec<SensorDeviceMessageAttributes>>,
+  #[getset(get = "pub")]
+  #[serde(rename = "SensorSubscribeCmd")]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  sensor_subscribe_cmd: Option<Vec<SensorDeviceMessageAttributes>>,
+
+  // StopDeviceCmd always exists
+  #[getset(get = "pub")]
+  #[serde(rename = "StopDeviceCmd")]
+  #[serde(skip_deserializing)]
+  stop_device_cmd: NullDeviceMessageAttributes,
+
+  // Raw commands are only added post-serialization
+  #[getset(get = "pub")]
+  #[serde(rename = "RawReadCmd")]
+  #[serde(skip_deserializing)]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  raw_read_cmd: Option<RawDeviceMessageAttributes>,
+  // Raw commands are only added post-serialization
+  #[getset(get = "pub")]
+  #[serde(rename = "RawWriteCmd")]
+  #[serde(skip_deserializing)]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  raw_write_cmd: Option<RawDeviceMessageAttributes>,
+  // Raw commands are only added post-serialization
+  #[getset(get = "pub")]
+  #[serde(rename = "RawSubscribeCmd")]
+  #[serde(skip_deserializing)]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  raw_subscribe_cmd: Option<RawDeviceMessageAttributes>,
+
+  // Needed to load from config for fallback, but unused here.
+  #[getset(get = "pub")]
+  #[serde(rename = "FleshlightLaunchFW12Cmd")]
+  #[serde(skip_serializing)]
+  fleshlight_launch_fw12_cmd: Option<NullDeviceMessageAttributes>,
+  #[getset(get = "pub")]
+  #[serde(rename = "VorzeA10CycloneCmd")]
+  #[serde(skip_serializing)]
+  vorze_a10_cyclone_cmd: Option<NullDeviceMessageAttributes>,
+}
+
+impl ServerDeviceMessageAttributes {
+  pub fn raw_unsubscribe_cmd(&self) -> &Option<RawDeviceMessageAttributes> {
+    self.raw_subscribe_cmd()
+  }
+
+  pub fn message_allowed(&self, message_type: &ButtplugDeviceMessageType) -> bool {
+    match message_type {
+      ButtplugDeviceMessageType::ScalarCmd => self.scalar_cmd.is_some(),
+      // VibrateCmd and SingleMotorVibrateCmd will derive from Scalars, so errors will be thrown in
+      // the scalar parser if the actuator isn't correct.
+      ButtplugDeviceMessageType::VibrateCmd => self.scalar_cmd.is_some(),
+      ButtplugDeviceMessageType::SingleMotorVibrateCmd => self.scalar_cmd.is_some(),
+      ButtplugDeviceMessageType::SensorReadCmd => self.sensor_read_cmd.is_some(),
+      ButtplugDeviceMessageType::SensorSubscribeCmd => self.sensor_subscribe_cmd.is_some(),
+      ButtplugDeviceMessageType::SensorUnsubscribeCmd => self.sensor_subscribe_cmd.is_some(),
+      ButtplugDeviceMessageType::LinearCmd => self.linear_cmd.is_some(),
+      ButtplugDeviceMessageType::RotateCmd => self.rotate_cmd.is_some(),
+      ButtplugDeviceMessageType::BatteryLevelCmd => {
+        if let Some(sensor_info) = &self.sensor_read_cmd {
+          sensor_info
+            .iter()
+            .any(|x| *x.sensor_type() == SensorType::Battery)
+        } else {
+          false
+        }
+      }
+      ButtplugDeviceMessageType::FleshlightLaunchFW12Cmd => {
+        self.fleshlight_launch_fw12_cmd.is_some()
+      }
+      ButtplugDeviceMessageType::RSSILevelCmd => {
+        if let Some(sensor_info) = &self.sensor_read_cmd {
+          sensor_info
+            .iter()
+            .any(|x| *x.sensor_type() == SensorType::RSSI)
+        } else {
+          false
+        }
+      }
+      ButtplugDeviceMessageType::RawReadCmd => self.raw_read_cmd.is_some(),
+      ButtplugDeviceMessageType::RawSubscribeCmd => self.raw_subscribe_cmd.is_some(),
+      ButtplugDeviceMessageType::RawUnsubscribeCmd => self.raw_subscribe_cmd.is_some(),
+      ButtplugDeviceMessageType::RawWriteCmd => self.raw_write_cmd.is_some(),
+      ButtplugDeviceMessageType::VorzeA10CycloneCmd => self.vorze_a10_cyclone_cmd.is_some(),
+      ButtplugDeviceMessageType::StopDeviceCmd => true,
+      ButtplugDeviceMessageType::KiirooCmd => false,
+      ButtplugDeviceMessageType::LovenseCmd => false,
+    }
+  }
+
+  pub fn merge(&self, child: &ServerDeviceMessageAttributes) -> ServerDeviceMessageAttributes {
+    Self {
+      rotate_cmd: child
+        .rotate_cmd()
+        .clone()
+        .or_else(|| self.rotate_cmd().clone()),
+      linear_cmd: child
+        .linear_cmd()
+        .clone()
+        .or_else(|| self.linear_cmd().clone()),
+      scalar_cmd: child
+        .scalar_cmd()
+        .clone()
+        .or_else(|| self.scalar_cmd().clone()),
+      sensor_read_cmd: child
+        .sensor_read_cmd()
+        .clone()
+        .or_else(|| self.sensor_read_cmd().clone()),
+      sensor_subscribe_cmd: child
+        .sensor_subscribe_cmd()
+        .clone()
+        .or_else(|| self.sensor_subscribe_cmd().clone()),
+      stop_device_cmd: NullDeviceMessageAttributes::default(),
+      raw_read_cmd: child
+        .raw_read_cmd()
+        .clone()
+        .or_else(|| self.raw_read_cmd().clone()),
+      raw_write_cmd: child
+        .raw_write_cmd()
+        .clone()
+        .or_else(|| self.raw_write_cmd().clone()),
+      raw_subscribe_cmd: child
+        .raw_subscribe_cmd()
+        .clone()
+        .or_else(|| self.raw_subscribe_cmd().clone()),
+      fleshlight_launch_fw12_cmd: child
+        .fleshlight_launch_fw12_cmd()
+        .clone()
+        .or_else(|| self.fleshlight_launch_fw12_cmd().clone()),
+      vorze_a10_cyclone_cmd: child
+        .vorze_a10_cyclone_cmd()
+        .clone()
+        .or_else(|| self.vorze_a10_cyclone_cmd().clone()),
+    }
+  }
+
+  pub fn add_raw_messages(&mut self, endpoints: &[Endpoint]) {
+    let raw_attrs = RawDeviceMessageAttributes::new(&endpoints.to_vec());
+    self.raw_read_cmd = Some(raw_attrs.clone());
+    self.raw_write_cmd = Some(raw_attrs.clone());
+    self.raw_subscribe_cmd = Some(raw_attrs.clone());
+  }
+}
+
+impl Into<ClientDeviceMessageAttributes> for ServerDeviceMessageAttributes {
+  fn into(self) -> ClientDeviceMessageAttributes {
+    let mut builder = ClientDeviceMessageAttributesBuilder::default();
+    if let Some(scalar_cmd) = self.scalar_cmd {
+      builder.scalar_cmd(&scalar_cmd.iter().cloned().map(|x| x.into()).collect());
+    }
+    if let Some(rotate_cmd) = self.rotate_cmd {
+      builder.rotate_cmd(&rotate_cmd.iter().cloned().map(|x| x.into()).collect());
+    }
+    if let Some(linear_cmd) = self.linear_cmd {
+      builder.linear_cmd(&linear_cmd.iter().cloned().map(|x| x.into()).collect());
+    }
+    if let Some(sensor_read_cmd) = self.sensor_read_cmd {
+      builder.sensor_read_cmd(&sensor_read_cmd);
+    }
+    if let Some(sensor_subscribe_cmd) = self.sensor_subscribe_cmd {
+      builder.sensor_subscribe_cmd(&sensor_subscribe_cmd);
+    }
+    if let Some(raw_read_cmd) = self.raw_read_cmd {
+      builder.raw_read_cmd(raw_read_cmd.endpoints());
+    }
+    if let Some(raw_write_cmd) = self.raw_write_cmd {
+      builder.raw_write_cmd(raw_write_cmd.endpoints());
+    }
+    if let Some(raw_subscribe_cmd) = self.raw_subscribe_cmd {
+      builder.raw_subscribe_cmd(raw_subscribe_cmd.endpoints());
+    }
+    builder.finish()
+  }
+}
+
+#[derive(Default)]
+pub struct ServerDeviceMessageAttributesBuilder {
+  attrs: ServerDeviceMessageAttributes,
+}
+
+impl ServerDeviceMessageAttributesBuilder {
+  pub fn scalar_cmd(&mut self, attrs: &Vec<ServerGenericDeviceMessageAttributes>) -> &Self {
+    self.attrs.scalar_cmd = Some(attrs.clone());
+    self
+  }
+
+  pub fn rotate_cmd(&mut self, attrs: &Vec<ServerGenericDeviceMessageAttributes>) -> &Self {
+    self.attrs.rotate_cmd = Some(attrs.clone());
+    self
+  }
+
+  pub fn linear_cmd(&mut self, attrs: &Vec<ServerGenericDeviceMessageAttributes>) -> &Self {
+    self.attrs.linear_cmd = Some(attrs.clone());
+    self
+  }
+
+  pub fn sensor_read_cmd(&mut self, attrs: &Vec<SensorDeviceMessageAttributes>) -> &Self {
+    self.attrs.sensor_read_cmd = Some(attrs.clone());
+    self
+  }
+
+  pub fn sensor_subscribe_cmd(&mut self, attrs: &Vec<SensorDeviceMessageAttributes>) -> &Self {
+    self.attrs.sensor_subscribe_cmd = Some(attrs.clone());
+    self
+  }
+
+  pub fn raw_read_cmd(&mut self, endpoints: &Vec<Endpoint>) -> &Self {
+    self.attrs.raw_read_cmd = Some(RawDeviceMessageAttributes::new(endpoints));
+    self
+  }
+
+  pub fn raw_write_cmd(&mut self, endpoints: &Vec<Endpoint>) -> &Self {
+    self.attrs.raw_write_cmd = Some(RawDeviceMessageAttributes::new(endpoints));
+    self
+  }
+
+  pub fn raw_subscribe_cmd(&mut self, endpoints: &Vec<Endpoint>) -> &Self {
+    self.attrs.raw_subscribe_cmd = Some(RawDeviceMessageAttributes::new(endpoints));
+    self
+  }
+
+  pub fn finish(&self) -> ServerDeviceMessageAttributes {
+    self.attrs.clone()
+  }
+}
+
+fn unspecified_feature() -> String {
+  "No description available for feature".to_string()
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Getters, Setters)]
+pub struct ServerGenericDeviceMessageAttributes {
+  #[getset(get = "pub")]
+  #[serde(rename = "FeatureDescriptor")]
+  #[serde(default = "unspecified_feature")]
+  feature_descriptor: String,
+  #[getset(get = "pub")]
+  #[serde(rename = "ActuatorType")]
+  actuator_type: ActuatorType,
+  #[serde(rename = "StepRange")]
+  #[serde(skip_serializing)]
+  #[getset(get = "pub", set = "pub")]
+  step_range: RangeInclusive<u32>,
+}
+
+impl Into<ClientGenericDeviceMessageAttributes> for ServerGenericDeviceMessageAttributes {
+  fn into(self) -> ClientGenericDeviceMessageAttributes {
+    ClientGenericDeviceMessageAttributes::new(
+      &self.feature_descriptor,
+      self.step_count(),
+      self.actuator_type,
+    )
+  }
+}
+
+impl ServerGenericDeviceMessageAttributes {
+  pub fn new(
+    feature_descriptor: &str,
+    step_range: &RangeInclusive<u32>,
+    actuator_type: ActuatorType,
+  ) -> Self {
+    Self {
+      feature_descriptor: feature_descriptor.to_owned(),
+      actuator_type,
+      step_range: step_range.clone(),
+    }
+  }
+
+  pub fn step_count(&self) -> u32 {
+    self.step_range.end() - self.step_range.start()
+  }
+
+  pub fn is_valid(
+    &self,
+    message_type: &ButtplugDeviceMessageType,
+  ) -> Result<(), ButtplugDeviceError> {
+    if self.step_range.is_empty() {
+      Err(ButtplugDeviceError::DeviceConfigurationError(format!(
+        "Step range out of order for {}, must be start <= x <= end.",
+        message_type
+      )))
+    } else {
+      Ok(())
+    }
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+
+  #[test]
+  pub fn test_step_count_calculation() {
+    let mut vibrate_attributes = ServerGenericDeviceMessageAttributes::new(
+      "test",
+      &RangeInclusive::new(0, 10),
+      ActuatorType::Vibrate,
+    );
+    assert_eq!(vibrate_attributes.step_count(), 10);
+    vibrate_attributes.set_step_range(RangeInclusive::new(3u32, 7));
+    assert_eq!(vibrate_attributes.step_count(), 4);
+  }
+}

buttplug/src/server/device/protocol/generic_command_manager.rs

···
     messages::{
       ActuatorType,
       ButtplugDeviceCommandMessageUnion,
-      GenericDeviceMessageAttributes,
+      ClientGenericDeviceMessageAttributes,
       LinearCmd,
       RotateCmd,
       RotationSubcommand,
···
       ScalarSubcommand,
     },
   },
-  server::device::configuration::ProtocolDeviceAttributes,
+  server::device::configuration::{ProtocolDeviceAttributes, ServerGenericDeviceMessageAttributes},
 };
 use getset::Getters;
 use std::{
···
 }
 
 impl ScalarGenericCommand {
-  pub fn new(attributes: &GenericDeviceMessageAttributes) -> Self {
+  pub fn new(attributes: &ServerGenericDeviceMessageAttributes) -> Self {
     Self {
       actuator: attributes.actuator_type().clone(),
       step_range: attributes.step_range().clone(),
···
   use crate::{
     core::messages::{
       ActuatorType,
-      DeviceMessageAttributesBuilder,
-      GenericDeviceMessageAttributes,
       RotateCmd,
       RotationSubcommand,
       ScalarCmd,
       ScalarSubcommand,
     },
-    server::device::configuration::ProtocolAttributesType,
+    server::device::configuration::{ProtocolAttributesType, ServerGenericDeviceMessageAttributes, ServerDeviceMessageAttributesBuilder},
   };
   use std::ops::RangeInclusive;
 
   #[test]
   pub fn test_command_generator_vibration() {
-    let scalar_attrs = GenericDeviceMessageAttributes::new(
+    let scalar_attrs = ServerGenericDeviceMessageAttributes::new(
       "Test",
       &RangeInclusive::new(0, 20),
       ActuatorType::Vibrate,
     );
-    let scalar_attributes = DeviceMessageAttributesBuilder::default()
+    let scalar_attributes = ServerDeviceMessageAttributesBuilder::default()
       .scalar_cmd(&vec![scalar_attrs.clone(), scalar_attrs.clone()])
       .finish();
     let device_attributes = ProtocolDeviceAttributes::new(
···
 
   #[test]
   pub fn test_command_generator_vibration_step_range() {
-    let mut vibrate_attrs_1 = GenericDeviceMessageAttributes::new(
+    let mut vibrate_attrs_1 = ServerGenericDeviceMessageAttributes::new(
       "Test",
       &RangeInclusive::new(0, 20),
       ActuatorType::Vibrate,
     );
     vibrate_attrs_1.set_step_range(RangeInclusive::new(10, 15));
-    let mut vibrate_attrs_2 = GenericDeviceMessageAttributes::new(
+    let mut vibrate_attrs_2 = ServerGenericDeviceMessageAttributes::new(
       "Test",
       &RangeInclusive::new(0, 20),
       ActuatorType::Vibrate,
     );
     vibrate_attrs_2.set_step_range(RangeInclusive::new(10, 20));
 
-    let vibrate_attributes = DeviceMessageAttributesBuilder::default()
+    let vibrate_attributes = ServerDeviceMessageAttributesBuilder::default()
       .scalar_cmd(&vec![vibrate_attrs_1, vibrate_attrs_2])
       .finish();
     let device_attributes = ProtocolDeviceAttributes::new(
···
 
   #[test]
   pub fn test_command_generator_rotation() {
-    let rotate_attrs = GenericDeviceMessageAttributes::new(
+    let rotate_attrs = ServerGenericDeviceMessageAttributes::new(
       "Test",
       &RangeInclusive::new(0, 20),
       ActuatorType::Rotate,
     );
 
-    let rotate_attributes = DeviceMessageAttributesBuilder::default()
+    let rotate_attributes = ServerDeviceMessageAttributesBuilder::default()
       .rotate_cmd(&vec![rotate_attrs.clone(), rotate_attrs])
       .finish();
     let device_attributes = ProtocolDeviceAttributes::new(

buttplug/src/server/device/server_device.rs

···
       ButtplugDeviceMessageType,
       ButtplugMessage,
       ButtplugServerDeviceMessage,
-      DeviceMessageAttributes,
+      ClientDeviceMessageAttributes,
       Endpoint,
       RawReading,
       RawSubscribeCmd,
···
 use tokio_stream::StreamExt;
 
 use super::{
-  configuration::ProtocolDeviceAttributes,
+  configuration::{ProtocolDeviceAttributes, ServerDeviceMessageAttributes},
   protocol::generic_command_manager::GenericCommandManager,
 };
 
···
   }
 
   /// Retreive the message attributes for the device.
-  pub fn message_attributes(&self) -> DeviceMessageAttributes {
+  pub fn message_attributes(&self) -> ServerDeviceMessageAttributes {
     self.attributes.message_attributes()
   }
 

buttplug/src/server/device/server_device_manager.rs

···
           .iter()
           .map(|device| {
             let dev = device.value();
-            DeviceMessageInfo::new(*device.key(), &dev.name(), dev.message_attributes())
+            DeviceMessageInfo::new(*device.key(), &dev.name(), dev.message_attributes().clone().into())
           })
           .collect();
         let mut device_list = DeviceList::new(devices);

buttplug/src/server/device/server_device_manager_event_loop.rs

···
 
         info!("Assigning index {} to {}", device_index, device.name());
         let device_added_message =
-          DeviceAdded::new(device_index, &device.name(), &device.message_attributes());
+          DeviceAdded::new(device_index, &device.name(), &device.message_attributes().clone().into());
         self.device_map.insert(device_index, device);
         // After that, we can send out to the server's event listeners to let
         // them know a device has been added.

buttplug/src/util/device_configuration.rs

···
 
 use super::json::JSONValidator;
 use crate::{
-  core::{errors::ButtplugDeviceError, messages::DeviceMessageAttributes},
+  core::errors::ButtplugDeviceError,
   server::device::{
     configuration::{
       BluetoothLESpecifier,
···
       SerialSpecifier,
       USBSpecifier,
       WebsocketSpecifier,
-      XInputSpecifier,
+      XInputSpecifier, ServerDeviceMessageAttributes,
     },
     ServerDeviceIdentifier,
   },
···
   deny: Option<bool>,
   #[serde(skip_serializing_if = "Option::is_none")]
   #[serde(default)]
-  messages: Option<DeviceMessageAttributes>,
+  messages: Option<ServerDeviceMessageAttributes>,
   #[serde(skip_serializing_if = "Option::is_none")]
   #[serde(default)]
   index: Option<u32>,
···
   #[serde(skip_serializing_if = "Option::is_none")]
   name: Option<String>,
   #[serde(skip_serializing_if = "Option::is_none")]
-  messages: Option<DeviceMessageAttributes>,
+  messages: Option<ServerDeviceMessageAttributes>,
 }
 
 #[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]