refactored shared messages

src/accounts.rs

@@ -15,7 +15,7 @@ use log::error;
 
 use crate::client::{Subscribable, Subscription};
 use crate::contracts::Contract;
-use crate::messages::{IncomingMessages, ResponseMessage};
+use crate::messages::{IncomingMessages, OutgoingMessages, ResponseMessage};
 use crate::transport::BusSubscription;
 use crate::{server_versions, Client, Error};
 
@@ -91,7 +91,7 @@ pub(crate) fn positions(client: &Client) -> Result<impl Iterator<Item = Position
 
     let message = encoders::request_positions()?;
 
-    let messages = client.request_positions(message)?;
+    let messages = client.send_shared_request(OutgoingMessages::RequestPositions, message)?;
 
     Ok(PositionIterator { client, messages })
 }
@@ -101,7 +101,7 @@ pub(crate) fn cancel_positions(client: &Client) -> Result<(), Error> {
 
     let message = encoders::cancel_positions()?;
 
-    client.request_positions(message)?;
+    client.send_shared_request(OutgoingMessages::CancelPositions, message)?;
 
     Ok(())
 }
@@ -112,7 +112,7 @@ pub(crate) fn family_codes(client: &Client) -> Result<Vec<FamilyCode>, Error> {
 
     let message = encoders::request_family_codes()?;
 
-    let mut messages = client.request_family_codes(message)?;
+    let mut messages = client.send_shared_request(OutgoingMessages::RequestFamilyCodes, message)?;
 
     if let Some(mut message) = messages.next() {
         decoders::decode_family_codes(&mut message)

src/client.rs

@@ -968,28 +968,8 @@ impl Client {
     }
 
     /// Sends request for the next valid order id.
-    pub(crate) fn send_shared_message(&self, message_id: OutgoingMessages, message: RequestMessage) -> Result<BusSubscription, Error> {
-        self.message_bus.lock()?.send_shared_message(message_id, &message)
-    }
-
-    /// Sends request for open orders.
-    pub(crate) fn request_order_data(&self, message: RequestMessage) -> Result<BusSubscription, Error> {
-        self.message_bus.lock()?.request_open_orders(&message)
-    }
-
-    /// Sends request for market rule.
-    pub(crate) fn request_market_rule(&self, message: RequestMessage) -> Result<BusSubscription, Error> {
-        self.message_bus.lock()?.request_market_rule(&message)
-    }
-
-    /// Sends request for positions.
-    pub(crate) fn request_positions(&self, message: RequestMessage) -> Result<BusSubscription, Error> {
-        self.message_bus.lock()?.request_positions(&message)
-    }
-
-    /// Sends request for family codes.
-    pub(crate) fn request_family_codes(&self, message: RequestMessage) -> Result<BusSubscription, Error> {
-        self.message_bus.lock()?.request_family_codes(&message)
+    pub(crate) fn send_shared_request(&self, message_id: OutgoingMessages, message: RequestMessage) -> Result<BusSubscription, Error> {
+        self.message_bus.lock()?.send_shared_request(message_id, &message)
     }
 
     pub(crate) fn check_server_version(&self, version: i32, message: &str) -> Result<(), Error> {
@@ -1003,7 +983,7 @@ impl Client {
 
 impl Drop for Client {
     fn drop(&mut self) {
-        info!("dropping basic client")
+        debug!("dropping basic client")
     }
 }
 
@@ -1036,7 +1016,7 @@ impl<'a, T: Subscribable<T>> Subscription<'a, T> {
                     }
                 }
             }
-            return None;
+            None
         } else {
             None
         }

src/contracts.rs

@@ -6,6 +6,7 @@ use log::{error, info};
 
 use crate::encode_option_field;
 use crate::messages::IncomingMessages;
+use crate::messages::OutgoingMessages;
 use crate::messages::RequestMessage;
 use crate::Client;
 use crate::{server_versions, Error, ToField};
@@ -517,7 +518,7 @@ pub(crate) fn market_rule(client: &Client, market_rule_id: i32) -> Result<Market
 
     let request = encoders::request_market_rule(market_rule_id)?;
 
-    let mut responses = client.request_market_rule(request)?;
+    let mut responses = client.send_shared_request(OutgoingMessages::RequestMarketRule, request)?;
 
     match responses.next() {
         Some(mut message) => Ok(decoders::market_rule(&mut message)?),

src/orders.rs

@@ -1371,7 +1371,7 @@ pub(crate) fn global_cancel(client: &Client) -> Result<(), Error> {
 pub(crate) fn next_valid_order_id(client: &Client) -> Result<i32, Error> {
     let message = encoders::encode_next_valid_order_id()?;
 
-    let mut messages = client.send_shared_message(OutgoingMessages::RequestIds, message)?;
+    let mut messages = client.send_shared_request(OutgoingMessages::RequestIds, message)?;
 
     if let Some(message) = messages.next() {
         let order_id_index = 2;
@@ -1391,7 +1391,7 @@ pub(crate) fn completed_orders(client: &Client, api_only: bool) -> Result<OrderD
 
     let message = encoders::encode_completed_orders(api_only)?;
 
-    let messages = client.request_order_data(message)?;
+    let messages = client.send_shared_request(OutgoingMessages::RequestCompletedOrders, message)?;
 
     Ok(OrderDataIterator {
         server_version: client.server_version(),
@@ -1461,7 +1461,7 @@ impl Iterator for OrderDataIterator {
 pub(crate) fn open_orders(client: &Client) -> Result<OrderDataIterator, Error> {
     let message = encoders::encode_open_orders()?;
 
-    let messages = client.request_order_data(message)?;
+    let messages = client.send_shared_request(OutgoingMessages::RequestOpenOrders, message)?;
 
     Ok(OrderDataIterator {
         server_version: client.server_version(),
@@ -1474,7 +1474,7 @@ pub(crate) fn open_orders(client: &Client) -> Result<OrderDataIterator, Error> {
 pub(crate) fn all_open_orders(client: &Client) -> Result<OrderDataIterator, Error> {
     let message = encoders::encode_all_open_orders()?;
 
-    let messages = client.request_order_data(message)?;
+    let messages = client.send_shared_request(OutgoingMessages::RequestAllOpenOrders, message)?;
 
     Ok(OrderDataIterator {
         server_version: client.server_version(),
@@ -1487,7 +1487,7 @@ pub(crate) fn auto_open_orders(client: &Client, auto_bind: bool) -> Result<Order
     let message = encoders::encode_auto_open_orders(auto_bind)?;
 
     // TODO this should probably not timeout.
-    let messages = client.request_order_data(message)?;
+    let messages = client.send_shared_request(OutgoingMessages::RequestAutoOpenOrders, message)?;
 
     Ok(OrderDataIterator {
         server_version: client.server_version(),

src/stubs.rs

@@ -40,23 +40,7 @@ impl MessageBus for MessageBusStub {
         mock_request(self, request_id, message)
     }
 
-    fn send_shared_message(&mut self, _message_id: OutgoingMessages, message: &RequestMessage) -> Result<BusSubscription, Error> {
-        mock_global_request(self, message)
-    }
-
-    fn request_open_orders(&mut self, message: &RequestMessage) -> Result<BusSubscription, Error> {
-        mock_global_request(self, message)
-    }
-
-    fn request_market_rule(&mut self, message: &RequestMessage) -> Result<BusSubscription, Error> {
-        mock_global_request(self, message)
-    }
-
-    fn request_positions(&mut self, message: &RequestMessage) -> Result<BusSubscription, Error> {
-        mock_global_request(self, message)
-    }
-
-    fn request_family_codes(&mut self, message: &RequestMessage) -> Result<BusSubscription, Error> {
+    fn send_shared_request(&mut self, _message_id: OutgoingMessages, message: &RequestMessage) -> Result<BusSubscription, Error> {
         mock_global_request(self, message)
     }