get rid of specific_ keyword

p2p/src/io/handshake.rs

@@ -3,7 +3,7 @@ use futures::{Future, Poll, Async};
 use message::Message;
 use message::types::{Version, Verack};
 use message::common::Magic;
-use io::{write_message, WriteMessage, ReadSpecificMessage, read_specific_message};
+use io::{write_message, WriteMessage, ReadMessage, read_message};
 use Error;
 
 pub fn handshake<A>(a: A, magic: Magic, version: Version) -> Handshake<A> where A: io::Write + io::Read {
@@ -19,7 +19,7 @@ pub fn accept_handshake<A>(a: A, magic: Magic, version: Version) -> AcceptHandsh
 		version: version.version(),
 		state: AcceptHandshakeState::ReceiveVersion {
 			local_version: Some(version),
-			future: read_specific_message(a, magic, 0),
+			future: read_message(a, magic, 0),
 		},
 		magic: magic,
 	}
@@ -45,10 +45,10 @@ fn verack_message(magic: Magic) -> Message<Verack> {
 
 enum HandshakeState<A> {
 	SendVersion(WriteMessage<Version, A>),
-	ReceiveVersion(ReadSpecificMessage<Version, A>),
+	ReceiveVersion(ReadMessage<Version, A>),
 	ReceiveVerack {
 		version: Option<Version>,
-		future: ReadSpecificMessage<Verack, A>,
+		future: ReadMessage<Verack, A>,
 	},
 	Finished,
 }
@@ -56,7 +56,7 @@ enum HandshakeState<A> {
 enum AcceptHandshakeState<A> {
 	ReceiveVersion {
 		local_version: Option<Version>,
-		future: ReadSpecificMessage<Version, A>
+		future: ReadMessage<Version, A>
 	},
 	SendVersion {
 		version: Option<Version>,
@@ -89,7 +89,7 @@ impl<A> Future for Handshake<A> where A: io::Read + io::Write {
 		let (next, result) = match self.state {
 			HandshakeState::SendVersion(ref mut future) => {
 				let (stream, _) = try_ready!(future.poll());
-				(HandshakeState::ReceiveVersion(read_specific_message(stream, self.magic, 0)), Async::NotReady)
+				(HandshakeState::ReceiveVersion(read_message(stream, self.magic, 0)), Async::NotReady)
 			},
 			HandshakeState::ReceiveVersion(ref mut future) => {
 				let (stream, version) = try_ready!(future.poll());
@@ -100,7 +100,7 @@ impl<A> Future for Handshake<A> where A: io::Read + io::Write {
 
 				let next = HandshakeState::ReceiveVerack {
 					version: Some(version),
-					future: read_specific_message(stream, self.magic, 0),
+					future: read_message(stream, self.magic, 0),
 				};
 
 				(next, Async::NotReady)

p2p/src/io/mod.rs

@@ -1,7 +1,7 @@
 mod handshake;
 mod read_header;
-mod read_specific_message;
-mod read_specific_payload;
+mod read_message;
+mod read_payload;
 mod readrc;
 mod write_message;
 
@@ -9,7 +9,7 @@ pub use self::handshake::{
 	handshake, accept_handshake, Handshake, AcceptHandshake, HandshakeResult
 };
 pub use self::read_header::{read_header, ReadHeader};
-pub use self::read_specific_payload::{read_specific_payload, ReadSpecificPayload};
-pub use self::read_specific_message::{read_specific_message, ReadSpecificMessage};
+pub use self::read_payload::{read_payload, ReadPayload};
+pub use self::read_message::{read_message, ReadMessage};
 pub use self::readrc::ReadRc;
 pub use self::write_message::{write_message, WriteMessage};

p2p/src/io/read_message.rs

@@ -4,11 +4,11 @@ use futures::{Poll, Future, Async};
 use message::{MessageResult, Error};
 use message::common::Magic;
 use message::serialization::PayloadType;
-use io::{read_header, ReadHeader, read_specific_payload, ReadSpecificPayload};
+use io::{read_header, ReadHeader, read_payload, ReadPayload};
 
-pub fn read_specific_message<M, A>(a: A, magic: Magic, version: u32) -> ReadSpecificMessage<M, A>
+pub fn read_message<M, A>(a: A, magic: Magic, version: u32) -> ReadMessage<M, A>
 	where A: io::Read, M: PayloadType {
-	ReadSpecificMessage {
+	ReadMessage {
 		state: ReadMessageState::ReadHeader {
 			version: version,
 			future: read_header(a, magic),
@@ -23,17 +23,17 @@ enum ReadMessageState<M, A> {
 		future: ReadHeader<A>,
 	},
 	ReadPayload {
-		future: ReadSpecificPayload<M, A>,
+		future: ReadPayload<M, A>,
 	},
 	Finished,
 }
 
-pub struct ReadSpecificMessage<M, A> {
+pub struct ReadMessage<M, A> {
 	state: ReadMessageState<M, A>,
 	message_type: PhantomData<M>,
 }
 
-impl<M, A> Future for ReadSpecificMessage<M, A> where A: io::Read, M: PayloadType {
+impl<M, A> Future for ReadMessage<M, A> where A: io::Read, M: PayloadType {
 	type Item = (A, MessageResult<M>);
 	type Error = io::Error;
 
@@ -50,7 +50,7 @@ impl<M, A> Future for ReadSpecificMessage<M, A> where A: io::Read, M: PayloadTyp
 				if header.command != M::command().into() {
 					return Ok((read, Err(Error::InvalidCommand)).into());
 				}
-				let future = read_specific_payload(
+				let future = read_payload(
 					read, version, header.len as usize, header.checksum,
 				);
 				let next = ReadMessageState::ReadPayload {
@@ -62,7 +62,7 @@ impl<M, A> Future for ReadSpecificMessage<M, A> where A: io::Read, M: PayloadTyp
 				let (read, payload) = try_ready!(future.poll());
 				(ReadMessageState::Finished, Async::Ready((read, payload)))
 			},
-			ReadMessageState::Finished => panic!("poll ReadSpecificMessage after it's done"),
+			ReadMessageState::Finished => panic!("poll ReadMessage after it's done"),
 		};
 
 		self.state = next;

p2p/src/io/read_payload.rs

@@ -7,9 +7,9 @@ use hash::H32;
 use message::MessageResult;
 use message::serialization::{PayloadType, deserialize_payload};
 
-pub fn read_specific_payload<M, A>(a: A, version: u32, len: usize, checksum: H32) -> ReadSpecificPayload<M, A>
+pub fn read_payload<M, A>(a: A, version: u32, len: usize, checksum: H32) -> ReadPayload<M, A>
 	where A: io::Read, M: PayloadType {
-	ReadSpecificPayload {
+	ReadPayload {
 		reader: read_exact(a, Bytes::new_with_len(len)),
 		version: version,
 		checksum: checksum,
@@ -17,7 +17,7 @@ pub fn read_specific_payload<M, A>(a: A, version: u32, len: usize, checksum: H32
 	}
 }
 
-pub struct ReadSpecificPayload<M, A> {
+pub struct ReadPayload<M, A> {
 	reader: ReadExact<A, Bytes>,
 	version: u32,
 	checksum: H32,
@@ -25,7 +25,7 @@ pub struct ReadSpecificPayload<M, A> {
 }
 
 /// TODO: check checksum
-impl<M, A> Future for ReadSpecificPayload<M, A> where A: io::Read, M: PayloadType {
+impl<M, A> Future for ReadPayload<M, A> where A: io::Read, M: PayloadType {
 	type Item = (A, MessageResult<M>);
 	type Error = io::Error;