renamed read_bytes -> read_slice, append_bytes -> append_slice

src/block_header.rs

@@ -28,8 +28,8 @@ impl Serializable for BlockHeader {
 	fn serialize(&self, stream: &mut Stream) {
 		stream
 			.append(&self.version)
-			.append_bytes(&self.previous_header_hash)
-			.append_bytes(&self.merkle_root_hash)
+			.append_slice(&self.previous_header_hash)
+			.append_slice(&self.merkle_root_hash)
 			.append(&self.time)
 			.append(&self.nbits)
 			.append(&self.nonce);
@@ -40,9 +40,9 @@ impl Deserializable for BlockHeader {
 	fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
 		let version = try!(reader.read());
 		let mut previous_header_hash = [0u8; 32];
-		previous_header_hash.copy_from_slice(try!(reader.read_bytes(32)));
-		let mut merkle_root_hash = [0u8; 32]; 
-		merkle_root_hash.copy_from_slice(try!(reader.read_bytes(32)));
+		previous_header_hash.copy_from_slice(try!(reader.read_slice(32)));
+		let mut merkle_root_hash = [0u8; 32];
+		merkle_root_hash.copy_from_slice(try!(reader.read_slice(32)));
 		let time = try!(reader.read());
 		let nbits = try!(reader.read());
 		let nonce = try!(reader.read());

src/bytes.rs

@@ -57,14 +57,14 @@ impl Serializable for Bytes {
 	fn serialize(&self, stream: &mut Stream) {
 		stream
 			.append(&CompactInteger::from(self.0.len()))
-			.append_bytes(&self.0);
+			.append_slice(&self.0);
 	}
 }
 
 impl Deserializable for Bytes {
 	fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
 		let len = try!(reader.read::<CompactInteger>());
-		reader.read_bytes(len.into()).map(|b| Bytes(b.to_vec()))
+		reader.read_slice(len.into()).map(|b| Bytes(b.to_vec()))
 	}
 }
 

src/net/address.rs

@@ -53,8 +53,8 @@ impl Serializable for IpAddress {
 		match self.0 {
 			net::IpAddr::V4(address) => {
 				stream
-					.append_bytes(&[0u8; 12])
-					.append_bytes(&address.octets());
+					.append_slice(&[0u8; 12])
+					.append_slice(&address.octets());
 			},
 			net::IpAddr::V6(address) => {
 				for segment in &address.segments() {
@@ -67,9 +67,9 @@ impl Serializable for IpAddress {
 
 impl Deserializable for IpAddress {
 	fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
-		let mut bytes = try!(reader.read_bytes(12));
+		let mut bytes = try!(reader.read_slice(12));
 		if bytes == &[0u8; 12] {
-			let address = try!(reader.read_bytes(4));
+			let address = try!(reader.read_slice(4));
 			let address = net::Ipv4Addr::new(address[0], address[1], address[2], address[3]);
 			Ok(IpAddress(net::IpAddr::V4(address)))
 		} else {

src/reader.rs

@@ -55,7 +55,7 @@ impl<'a> Reader<'a> {
 		T::deserialize(self)
 	}
 
-	pub fn read_bytes(&mut self, len: usize) -> Result<&'a [u8], Error> {
+	pub fn read_slice(&mut self, len: usize) -> Result<&'a [u8], Error> {
 		if self.read + len > self.buffer.len() {
 			return Err(Error::UnexpectedEnd);
 		}

src/stream.rs

@@ -27,7 +27,7 @@ impl Stream {
 	}
 
 	/// Appends raw bytes to the end of the stream.
-	pub fn append_bytes(&mut self, bytes: &[u8]) -> &mut Self {
+	pub fn append_slice(&mut self, bytes: &[u8]) -> &mut Self {
 		// discard error for now, since we write to simple vector
 		self.buffer.write(bytes).unwrap();
 		self

src/transaction.rs

@@ -38,7 +38,7 @@ pub struct OutPoint {
 impl Serializable for OutPoint {
 	fn serialize(&self, stream: &mut Stream) {
 		stream
-			.append_bytes(&self.hash)
+			.append_slice(&self.hash)
 			.append(&self.index);
 	}
 }
@@ -46,7 +46,7 @@ impl Serializable for OutPoint {
 impl Deserializable for OutPoint {
 	fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
 		let mut hash = [0u8; 32];
-		hash.copy_from_slice(try!(reader.read_bytes(32)));
+		hash.copy_from_slice(try!(reader.read_slice(32)));
 		let index = try!(reader.read());
 		let result = OutPoint {
 			hash: hash,