Drop Message suffix

Author: sfackler

src/lib.rs

@@ -75,9 +75,9 @@ pub use transaction::Transaction;
 
 use error::{Error, ConnectError, SqlState, DbError};
 use io::{StreamWrapper, NegotiateSsl};
-use message::BackendMessage::*;
-use message::FrontendMessage::*;
-use message::{FrontendMessage, BackendMessage, RowDescriptionEntry};
+use message::Backend::*;
+use message::Frontend::*;
+use message::{Frontend, Backend, RowDescriptionEntry};
 use message::{WriteMessage, ReadMessage};
 use notification::{Notifications, Notification};
 use rows::{Rows, LazyRows};
@@ -521,15 +521,15 @@ impl InnerConnection {
         }
     }
 
-    fn write_messages(&mut self, messages: &[FrontendMessage]) -> std_io::Result<()> {
+    fn write_messages(&mut self, messages: &[Frontend]) -> std_io::Result<()> {
         debug_assert!(!self.desynchronized);
         for message in messages {
             try_desync!(self, self.stream.write_message(message));
         }
         Ok(try_desync!(self, self.stream.flush()))
     }
 
-    fn read_message_with_notification(&mut self) -> std_io::Result<BackendMessage> {
+    fn read_message_with_notification(&mut self) -> std_io::Result<Backend> {
         debug_assert!(!self.desynchronized);
         loop {
             match try_desync!(self, self.stream.read_message()) {
@@ -548,7 +548,7 @@ impl InnerConnection {
 
     fn read_message_with_notification_timeout(&mut self,
                                               timeout: Duration)
-                                              -> std::io::Result<Option<BackendMessage>> {
+                                              -> std::io::Result<Option<Backend>> {
         debug_assert!(!self.desynchronized);
         loop {
             match try_desync!(self, self.stream.read_message_timeout(timeout)) {
@@ -566,7 +566,7 @@ impl InnerConnection {
     }
 
     fn read_message_with_notification_nonblocking(&mut self)
-                                                  -> std::io::Result<Option<BackendMessage>> {
+                                                  -> std::io::Result<Option<Backend>> {
         debug_assert!(!self.desynchronized);
         loop {
             match try_desync!(self, self.stream.read_message_nonblocking()) {
@@ -583,7 +583,7 @@ impl InnerConnection {
         }
     }
 
-    fn read_message(&mut self) -> std_io::Result<BackendMessage> {
+    fn read_message(&mut self) -> std_io::Result<Backend> {
         loop {
             match try!(self.read_message_with_notification()) {
                 NotificationResponse { pid, channel, payload } => {

src/message.rs

@@ -7,14 +7,14 @@ use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use types::Oid;
 use priv_io::StreamOptions;
 
-use self::BackendMessage::*;
-use self::FrontendMessage::*;
+use self::Backend::*;
+use self::Frontend::*;
 
 pub const PROTOCOL_VERSION: u32 = 0x0003_0000;
 pub const CANCEL_CODE: u32 = 80877102;
 pub const SSL_CODE: u32 = 80877103;
 
-pub enum BackendMessage {
+pub enum Backend {
     AuthenticationCleartextPassword,
     AuthenticationGSS,
     AuthenticationKerberosV5,
@@ -89,7 +89,7 @@ pub struct RowDescriptionEntry {
     pub format: i16,
 }
 
-pub enum FrontendMessage<'a> {
+pub enum Frontend<'a> {
     Bind {
         portal: &'a str,
         statement: &'a str,
@@ -157,12 +157,12 @@ impl<W: Write> WriteCStr for W {
 
 #[doc(hidden)]
 pub trait WriteMessage {
-    fn write_message(&mut self, &FrontendMessage) -> io::Result<()>;
+    fn write_message(&mut self, &Frontend) -> io::Result<()>;
 }
 
 impl<W: Write> WriteMessage for W {
     #[allow(cyclomatic_complexity)]
-    fn write_message(&mut self, message: &FrontendMessage) -> io::Result<()> {
+    fn write_message(&mut self, message: &Frontend) -> io::Result<()> {
         let mut buf = vec![];
         let mut ident = None;
 
@@ -283,22 +283,22 @@ impl<R: BufRead> ReadCStr for R {
 
 #[doc(hidden)]
 pub trait ReadMessage {
-    fn read_message(&mut self) -> io::Result<BackendMessage>;
+    fn read_message(&mut self) -> io::Result<Backend>;
 
-    fn read_message_timeout(&mut self, timeout: Duration) -> io::Result<Option<BackendMessage>>;
+    fn read_message_timeout(&mut self, timeout: Duration) -> io::Result<Option<Backend>>;
 
-    fn read_message_nonblocking(&mut self) -> io::Result<Option<BackendMessage>>;
+    fn read_message_nonblocking(&mut self) -> io::Result<Option<Backend>>;
 
-    fn finish_read_message(&mut self, ident: u8) -> io::Result<BackendMessage>;
+    fn finish_read_message(&mut self, ident: u8) -> io::Result<Backend>;
 }
 
 impl<R: BufRead + StreamOptions> ReadMessage for R {
-    fn read_message(&mut self) -> io::Result<BackendMessage> {
+    fn read_message(&mut self) -> io::Result<Backend> {
         let ident = try!(self.read_u8());
         self.finish_read_message(ident)
     }
 
-    fn read_message_timeout(&mut self, timeout: Duration) -> io::Result<Option<BackendMessage>> {
+    fn read_message_timeout(&mut self, timeout: Duration) -> io::Result<Option<Backend>> {
         try!(self.set_read_timeout(Some(timeout)));
         let ident = self.read_u8();
         try!(self.set_read_timeout(None));
@@ -316,7 +316,7 @@ impl<R: BufRead + StreamOptions> ReadMessage for R {
         }
     }
 
-    fn read_message_nonblocking(&mut self) -> io::Result<Option<BackendMessage>> {
+    fn read_message_nonblocking(&mut self) -> io::Result<Option<Backend>> {
         try!(self.set_nonblocking(true));
         let ident = self.read_u8();
         try!(self.set_nonblocking(false));
@@ -335,7 +335,7 @@ impl<R: BufRead + StreamOptions> ReadMessage for R {
     }
 
     #[allow(cyclomatic_complexity)]
-    fn finish_read_message(&mut self, ident: u8) -> io::Result<BackendMessage> {
+    fn finish_read_message(&mut self, ident: u8) -> io::Result<Backend> {
         // subtract size of length value
         let len = try!(self.read_u32::<BigEndian>()) - mem::size_of::<u32>() as u32;
         let mut rdr = self.by_ref().take(len as u64);
@@ -428,7 +428,7 @@ fn read_fields<R: BufRead>(buf: &mut R) -> io::Result<Vec<(u8, String)>> {
     Ok(fields)
 }
 
-fn read_data_row<R: BufRead>(buf: &mut R) -> io::Result<BackendMessage> {
+fn read_data_row<R: BufRead>(buf: &mut R) -> io::Result<Backend> {
     let len = try!(buf.read_u16::<BigEndian>()) as usize;
     let mut values = Vec::with_capacity(len);
 
@@ -447,7 +447,7 @@ fn read_data_row<R: BufRead>(buf: &mut R) -> io::Result<BackendMessage> {
     Ok(DataRow { row: values })
 }
 
-fn read_auth_message<R: Read>(buf: &mut R) -> io::Result<BackendMessage> {
+fn read_auth_message<R: Read>(buf: &mut R) -> io::Result<Backend> {
     Ok(match try!(buf.read_i32::<BigEndian>()) {
         0 => AuthenticationOk,
         2 => AuthenticationKerberosV5,
@@ -467,7 +467,7 @@ fn read_auth_message<R: Read>(buf: &mut R) -> io::Result<BackendMessage> {
     })
 }
 
-fn read_parameter_description<R: Read>(buf: &mut R) -> io::Result<BackendMessage> {
+fn read_parameter_description<R: Read>(buf: &mut R) -> io::Result<Backend> {
     let len = try!(buf.read_u16::<BigEndian>()) as usize;
     let mut types = Vec::with_capacity(len);
 
@@ -478,7 +478,7 @@ fn read_parameter_description<R: Read>(buf: &mut R) -> io::Result<BackendMessage
     Ok(ParameterDescription { types: types })
 }
 
-fn read_row_description<R: BufRead>(buf: &mut R) -> io::Result<BackendMessage> {
+fn read_row_description<R: BufRead>(buf: &mut R) -> io::Result<Backend> {
     let len = try!(buf.read_u16::<BigEndian>()) as usize;
     let mut types = Vec::with_capacity(len);
 

src/notification.rs

@@ -4,7 +4,7 @@ use std::fmt;
 use std::time::Duration;
 
 use {desynchronized, Result, Connection, NotificationsNew};
-use message::BackendMessage::NotificationResponse;
+use message::Backend;
 use error::Error;
 
 /// An asynchronous notification.
@@ -110,7 +110,7 @@ impl<'a> Iterator for Iter<'a> {
         }
 
         match conn.read_message_with_notification_nonblocking() {
-            Ok(Some(NotificationResponse { pid, channel, payload })) => {
+            Ok(Some(Backend::NotificationResponse { pid, channel, payload })) => {
                 Some(Ok(Notification {
                     pid: pid,
                     channel: channel,
@@ -148,7 +148,7 @@ impl<'a> Iterator for BlockingIter<'a> {
         }
 
         match conn.read_message_with_notification() {
-            Ok(NotificationResponse { pid, channel, payload }) => {
+            Ok(Backend::NotificationResponse { pid, channel, payload }) => {
                 Some(Ok(Notification {
                     pid: pid,
                     channel: channel,
@@ -187,7 +187,7 @@ impl<'a> Iterator for TimeoutIter<'a> {
         }
 
         match conn.read_message_with_notification_timeout(self.timeout) {
-            Ok(Some(NotificationResponse { pid, channel, payload })) => {
+            Ok(Some(Backend::NotificationResponse { pid, channel, payload })) => {
                 Some(Ok(Notification {
                     pid: pid,
                     channel: channel,

src/priv_io.rs

@@ -20,7 +20,7 @@ use {SslMode, ConnectParams, ConnectTarget};
 use error::ConnectError;
 use io::{NegotiateSsl, StreamWrapper};
 use message::{self, WriteMessage};
-use message::FrontendMessage::SslRequest;
+use message::Frontend;
 
 const DEFAULT_PORT: u16 = 5432;
 
@@ -170,7 +170,7 @@ pub fn initialize_stream(params: &ConnectParams,
         SslMode::Require(negotiator) => (true, negotiator),
     };
 
-    try!(socket.write_message(&SslRequest { code: message::SSL_CODE }));
+    try!(socket.write_message(&Frontend::SslRequest { code: message::SSL_CODE }));
     try!(socket.flush());
 
     if try!(socket.read_u8()) == b'N' {

src/rows.rs

@@ -12,7 +12,7 @@ use {Result, Transaction, DbErrorNew, SessionInfoNew, RowsNew, LazyRowsNew, Stat
 use types::{FromSql, SessionInfo, WrongType};
 use stmt::{Statement, Column};
 use error::Error;
-use message::FrontendMessage::*;
+use message::Frontend::*;
 
 enum StatementContainer<'a> {
     Borrowed(&'a Statement<'a>),

src/stmt.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 
 use error::{Error, DbError};
 use types::{SessionInfo, Type, ToSql};
-use message::FrontendMessage::*;
-use message::BackendMessage::*;
+use message::Frontend::*;
+use message::Backend::*;
 use message::WriteMessage;
 use rows::{Rows, LazyRows};
 use {bad_response, Connection, Transaction, StatementInternals, Result, RowsNew, InnerConnection,