implemented from and into for payloadtype and events

src/ipc.rs

@@ -1,27 +1,67 @@
-#![allow(dead_code)]
+pub enum PayloadType {
+    RunCommand,
+    GetWorkspaces,
+    Subscribe,
+    GetOutputs,
+    GetTree,
+    GetMarks,
+    GetBarConfig,
+    GetVersion,
+    GetBindingModes,
+    GetConfig,
+    SendTick,
+    Sync,
+    GetBindingState,
+    GetInputs,
+    GetSeats,
+}
 
-pub const IPC_RUN_COMMAND:          u32 = 0;
-pub const IPC_GET_WORKSPACES:       u32 = 1;
-pub const IPC_SUBSCRIBE:            u32 = 2;
-pub const IPC_GET_OUTPUTS:          u32 = 3;
-pub const IPC_GET_TREE:             u32 = 4;
-pub const IPC_GET_MARKS:            u32 = 5;
-pub const IPC_GET_BAR_CONFIG:       u32 = 6;
-pub const IPC_GET_VERSION:          u32 = 7;
-pub const IPC_GET_BINDING_MODES:    u32 = 8;
-pub const IPC_GET_CONFIG:           u32 = 9;
-pub const IPC_SEND_TICK:            u32 = 10;
-pub const IPC_SYNC:                 u32 = 11;
-pub const IPC_GET_BINDING_STATE:    u32 = 12;
-pub const IPC_GET_INPUTS:           u32 = 100;
-pub const IPC_GET_SEATS:            u32 = 101;
+impl From<PayloadType> for u32 {
+    fn from(payload_type: PayloadType) -> Self {
+        match payload_type {
+            PayloadType::RunCommand => 0,
+            PayloadType::GetWorkspaces => 1,
+            PayloadType::Subscribe => 2,
+            PayloadType::GetOutputs => 3,
+            PayloadType::GetTree => 4,
+            PayloadType::GetMarks => 5,
+            PayloadType::GetBarConfig => 6,
+            PayloadType::GetVersion => 7,
+            PayloadType::GetBindingModes => 8,
+            PayloadType::GetConfig => 9,
+            PayloadType::SendTick => 10,
+            PayloadType::Sync => 11,
+            PayloadType::GetBindingState => 12,
+            PayloadType::GetInputs => 100,
+            PayloadType::GetSeats => 101,
+        }
+    }
+}
 
-pub const EVENT_WORKSPACE:          &str = "workspace";
-pub const EVENT_MODE:               &str = "mode"; 
-pub const EVENT_WINDOW:             &str = "window";
-pub const EVENT_BARCONFIG_UPDATE:   &str = "barconfig_update";
-pub const EVENT_BINDING:            &str = "binding";
-pub const EVENT_SHUTDOWN:           &str = "shutdown";
-pub const EVENT_TICK:               &str = "tick";
-pub const EVENT_BAR_STATE_UPDATE:   &str = "bar_state_update";
-pub const EVENT_INPUT:              &str = "input";
+pub enum Event {
+    Workspace,
+    Mode,
+    Window,
+    BarconfigUpdate,
+    Binding,
+    Shutdown,
+    Tick,
+    BarStateUpdate,
+    Input,
+}
+
+impl From<Event> for &str {
+    fn from (event: Event) -> Self {
+        match event {
+            Event::Workspace => "workspace",
+            Event::Mode => "mode",
+            Event::Window => "window",
+            Event::BarconfigUpdate => "barconfig_update",
+            Event::Binding => "binding",
+            Event::Shutdown => "shutdown",
+            Event::Tick => "tick",
+            Event::BarStateUpdate => "bar_state_update",
+            Event::Input => "input",
+        }
+    }
+}

src/lib.rs

@@ -8,7 +8,7 @@ use std::io::prelude::*;
 use serde::de::DeserializeOwned;
 use i3msg::I3msg;
 use types::*;
-use ipc::*;
+use ipc::PayloadType;
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
@@ -24,82 +24,82 @@ impl Sway {
 
     /// Runs the payload as sway commands
     pub fn run_command(&mut self, payload: &str) -> Result<Vec<Success>> {
-        self.run(payload, IPC_RUN_COMMAND)
+        self.run(payload, PayloadType::RunCommand)
     }
 
     /// Get the list of current workspaces
     pub fn get_workspaces(&mut self) -> Result<Vec<Workspace>> {
-        self.run("get_workspaces", IPC_GET_WORKSPACES)
+        self.run("get_workspaces", PayloadType::GetWorkspaces)
     }
 
     /// Subscribe the IPC connection to the event listed in the payload
     pub fn subscribe(&mut self, events: Vec<&str>) -> Result<Success> {
         let events = self.parse_events(events)?;
-        self.run(&events, IPC_SUBSCRIBE)
+        self.run(&events, PayloadType::Subscribe)
     }
 
     /// Get the list of current outputs
     pub fn get_outputs(&mut self) -> Result<Vec<Output>> {
-        self.run("get_outputs", IPC_GET_OUTPUTS)
+        self.run("get_outputs", PayloadType::GetOutputs)
     }
 
     /// Get the node layout tree
     pub fn get_tree(&mut self) -> Result<Tree> {
-        self.run("get_tree", IPC_GET_TREE)
+        self.run("get_tree", PayloadType::GetTree)
     }
 
     /// Get the names of all the marks currently set
     pub fn get_marks(&mut self) -> Result<Vec<String>> {
-        self.run("get_marks", IPC_GET_MARKS)
+        self.run("get_marks", PayloadType::GetMarks)
     }
 
     /// Get the specified bar config or a list of bar config names
     pub fn get_bar_config(&mut self, payload: &str) -> Result<Bar> {
-        self.run(payload, IPC_GET_BAR_CONFIG)
+        self.run(payload, PayloadType::GetBarConfig)
     }
 
     /// Get the version of sway that owns the IPC socket
     pub fn get_version(&mut self) -> Result<Version> {
-        self.run("get_version", IPC_GET_VERSION)
+        self.run("get_version", PayloadType::GetVersion)
     }
 
     /// Get the list of binding mode names
     pub fn get_binding_modes(&mut self) -> Result<Vec<String>> {
-        self.run("get_binding_modes", IPC_GET_BINDING_MODES)
+        self.run("get_binding_modes", PayloadType::GetBindingModes)
     }
 
     /// Returns the config that was last loaded
     pub fn get_config(&mut self) -> Result<Config> {
-        self.run("get_config", IPC_GET_CONFIG)
+        self.run("get_config", PayloadType::GetConfig)
     }
 
     /// Sends a tick event with specified payload
     pub fn send_tick(&mut self, payload: &str) -> Result<Success> {
-        self.run(payload, IPC_SEND_TICK)
+        self.run(payload, PayloadType::SendTick)
     }
 
     /// Replies failure object for i3 compatibility
     pub fn sync(&mut self) -> Result<Success> {
-        self.run("sync", IPC_SYNC)
+        self.run("sync", PayloadType::Sync)
     }
 
     /// Request the current binding state, e.g. the currently active binding mode name
     pub fn get_binding_state(&mut self) -> Result<BindingState> {
-        self.run("get_binding_state", IPC_GET_BINDING_STATE)
+        self.run("get_binding_state", PayloadType::GetBindingState)
     }
 
     /// Get the list of input devices
     pub fn get_inputs(&mut self) -> Result<Vec<Input>> {
-        self.run("get_inputs", IPC_GET_INPUTS)
+        self.run("get_inputs", PayloadType::GetInputs)
     }
 
     /// Get the list of seats
     pub fn get_seats(&mut self) -> Result<Vec<Seat>> {
-        self.run("get_seats", IPC_GET_SEATS)
+        self.run("get_seats", PayloadType::GetSeats)
     }
 
-    fn run<T: DeserializeOwned>(&mut self, payload: &str, payload_type: u32) -> Result<T> {
-        let buffer = I3msg::new(payload, payload_type).construct_packet()?;
+    fn run<T: DeserializeOwned>(&mut self, payload: &str, payload_type: PayloadType) -> Result<T> {
+        let buffer = I3msg::new(payload, payload_type.into()).construct_packet()?;
         self.stream.write_all(&buffer.as_slice())?;
 
         let mut buffer = [0; 25000];