openethereum/src/bytes.rs

301 lines
6.5 KiB
Rust
Raw Normal View History

2015-11-28 03:58:37 +01:00
//! Unified interfaces for bytes operations on basic types
2015-11-25 02:53:35 +01:00
//!
//! # Examples
2015-11-28 03:58:37 +01:00
//! ```rust
//! extern crate ethcore_util as util;
//!
//! fn bytes_convertable() {
//! use util::bytes::BytesConvertable;
//!
//! let arr = [0; 5];
//! let slice: &[u8] = arr.bytes();
//! }
//!
//! fn to_bytes() {
//! use util::bytes::ToBytes;
//!
//! let a: Vec<u8> = "hello_world".to_bytes();
//! let b: Vec<u8> = 400u32.to_bytes();
//! let c: Vec<u8> = 0xffffffffffffffffu64.to_bytes();
//! }
//!
//! fn from_bytes() {
//! use util::bytes::FromBytes;
//!
//! let a = String::from_bytes(&[b'd', b'o', b'g']);
2015-11-29 19:35:22 +01:00
//! let b = u16::from_bytes(&[0xfa]);
2015-11-28 03:58:37 +01:00
//! let c = u64::from_bytes(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
//! }
2015-11-25 02:53:35 +01:00
//!
2015-11-28 03:58:37 +01:00
//! fn main() {
//! bytes_convertable();
//! to_bytes();
//! from_bytes();
//! }
//! ```
2015-11-25 02:53:35 +01:00
use std::fmt;
use std::cmp::Ordering;
2015-11-25 02:53:35 +01:00
use std::error::Error as StdError;
2015-11-26 15:00:17 +01:00
use uint::{U128, U256};
use hash::FixedHash;
2015-11-25 02:53:35 +01:00
2015-12-01 18:25:18 +01:00
pub struct PrettySlice<'a> (&'a [u8]);
impl<'a> fmt::Debug for PrettySlice<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for i in 0..self.0.len() {
2015-12-01 19:09:48 +01:00
match i > 0 {
true => { try!(write!(f, "·{:02x}", self.0[i])); },
false => { try!(write!(f, "{:02x}", self.0[i])); },
}
2015-12-01 18:25:18 +01:00
}
Ok(())
}
}
pub trait ToPretty {
fn pretty(&self) -> PrettySlice;
}
impl<'a> ToPretty for &'a [u8] {
fn pretty(&self) -> PrettySlice {
PrettySlice(self)
}
}
impl<'a> ToPretty for &'a Bytes {
fn pretty(&self) -> PrettySlice {
PrettySlice(self.bytes())
}
}
impl ToPretty for Bytes {
fn pretty(&self) -> PrettySlice {
PrettySlice(self.bytes())
}
}
2015-11-28 03:58:37 +01:00
/// Vector of bytes
2015-11-28 00:14:40 +01:00
pub type Bytes = Vec<u8>;
2015-11-28 03:58:37 +01:00
/// Slice of bytes to underlying memory
2015-11-27 17:54:33 +01:00
pub trait BytesConvertable {
fn bytes(&self) -> &[u8];
}
impl<'a> BytesConvertable for &'a [u8] {
fn bytes(&self) -> &[u8] { self }
}
impl BytesConvertable for Vec<u8> {
fn bytes(&self) -> &[u8] { self }
}
macro_rules! impl_bytes_convertable_for_array {
($zero: expr) => ();
($len: expr, $($idx: expr),*) => {
impl BytesConvertable for [u8; $len] {
fn bytes(&self) -> &[u8] { self }
}
impl_bytes_convertable_for_array! { $($idx),* }
}
}
2015-11-27 18:18:49 +01:00
// -1 at the end is not expanded
impl_bytes_convertable_for_array! {
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1
}
2015-11-27 17:54:33 +01:00
#[test]
fn bytes_convertable() {
assert_eq!(vec![0x12u8, 0x34].bytes(), &[0x12u8, 0x34]);
assert_eq!([0u8; 0].bytes(), &[]);
2015-11-27 17:54:33 +01:00
}
2015-11-28 03:58:37 +01:00
/// Converts given type to its shortest representation in bytes
///
2015-11-25 02:53:35 +01:00
/// TODO: optimise some conversations
pub trait ToBytes {
2015-11-27 17:54:33 +01:00
fn to_bytes(&self) -> Vec<u8>;
fn to_bytes_len(&self) -> usize { self.to_bytes().len() }
fn first_byte(&self) -> Option<u8> { self.to_bytes().first().map(|&x| { x })}
2015-11-25 02:53:35 +01:00
}
impl <'a> ToBytes for &'a str {
2015-11-27 17:54:33 +01:00
fn to_bytes(&self) -> Vec<u8> {
From::from(*self)
}
fn to_bytes_len(&self) -> usize { self.len() }
2015-11-25 02:53:35 +01:00
}
impl ToBytes for String {
2015-11-27 17:54:33 +01:00
fn to_bytes(&self) -> Vec<u8> {
let s: &str = self.as_ref();
From::from(s)
}
fn to_bytes_len(&self) -> usize { self.len() }
2015-11-25 02:53:35 +01:00
}
impl ToBytes for u64 {
2015-11-27 17:54:33 +01:00
fn to_bytes(&self) -> Vec<u8> {
let mut res= vec![];
let count = self.to_bytes_len();
res.reserve(count);
for i in 0..count {
let j = count - 1 - i;
res.push((*self >> (j * 8)) as u8);
}
res
}
2015-11-25 02:53:35 +01:00
2015-11-27 17:54:33 +01:00
fn to_bytes_len(&self) -> usize { 8 - self.leading_zeros() as usize / 8 }
2015-11-25 02:53:35 +01:00
}
macro_rules! impl_map_to_bytes {
2015-11-27 17:54:33 +01:00
($from: ident, $to: ty) => {
impl ToBytes for $from {
fn to_bytes(&self) -> Vec<u8> { (*self as $to).to_bytes() }
fn to_bytes_len(&self) -> usize { (*self as $to).to_bytes_len() }
}
}
2015-11-25 02:53:35 +01:00
}
impl_map_to_bytes!(usize, u64);
impl_map_to_bytes!(u16, u64);
impl_map_to_bytes!(u32, u64);
2015-11-26 15:00:17 +01:00
macro_rules! impl_uint_to_bytes {
2015-11-27 17:54:33 +01:00
($name: ident) => {
impl ToBytes for $name {
fn to_bytes(&self) -> Vec<u8> {
let mut res= vec![];
let count = self.to_bytes_len();
res.reserve(count);
for i in 0..count {
let j = count - 1 - i;
res.push(self.byte(j));
}
res
}
fn to_bytes_len(&self) -> usize { (self.bits() + 7) / 8 }
}
}
2015-11-26 15:00:17 +01:00
}
impl_uint_to_bytes!(U256);
impl_uint_to_bytes!(U128);
impl <T>ToBytes for T where T: FixedHash {
fn to_bytes(&self) -> Vec<u8> {
let mut res: Vec<u8> = vec![];
res.reserve(T::size());
unsafe {
use std::ptr;
ptr::copy(self.bytes().as_ptr(), res.as_mut_ptr(), T::size());
res.set_len(T::size());
}
res
}
}
2015-11-28 03:58:37 +01:00
/// Error returned when FromBytes conversation goes wrong
2015-11-25 02:53:35 +01:00
#[derive(Debug, PartialEq, Eq)]
pub enum FromBytesError {
DataIsTooShort,
DataIsTooLong
2015-11-25 02:53:35 +01:00
}
impl StdError for FromBytesError {
2015-11-27 17:54:33 +01:00
fn description(&self) -> &str { "from_bytes error" }
2015-11-25 02:53:35 +01:00
}
impl fmt::Display for FromBytesError {
2015-11-27 17:54:33 +01:00
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
2015-11-25 02:53:35 +01:00
}
2015-11-28 03:58:37 +01:00
/// Alias for the result of FromBytes trait
2015-11-25 02:53:35 +01:00
pub type FromBytesResult<T> = Result<T, FromBytesError>;
2015-11-28 03:58:37 +01:00
/// Converts to given type from its bytes representation
///
2015-11-26 15:00:17 +01:00
/// TODO: check size of bytes before conversation and return appropriate error
2015-11-25 02:53:35 +01:00
pub trait FromBytes: Sized {
2015-11-27 17:54:33 +01:00
fn from_bytes(bytes: &[u8]) -> FromBytesResult<Self>;
2015-11-25 02:53:35 +01:00
}
impl FromBytes for String {
2015-11-27 17:54:33 +01:00
fn from_bytes(bytes: &[u8]) -> FromBytesResult<String> {
Ok(::std::str::from_utf8(bytes).unwrap().to_string())
}
2015-11-25 02:53:35 +01:00
}
impl FromBytes for u64 {
2015-11-27 17:54:33 +01:00
fn from_bytes(bytes: &[u8]) -> FromBytesResult<u64> {
match bytes.len() {
0 => Ok(0),
l => {
let mut res = 0u64;
for i in 0..l {
let shift = (l - 1 - i) * 8;
res = res + ((bytes[i] as u64) << shift);
}
Ok(res)
}
}
}
2015-11-25 02:53:35 +01:00
}
macro_rules! impl_map_from_bytes {
2015-11-27 17:54:33 +01:00
($from: ident, $to: ident) => {
impl FromBytes for $from {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<$from> {
$to::from_bytes(bytes).map(| x | { x as $from })
}
}
}
2015-11-25 02:53:35 +01:00
}
impl_map_from_bytes!(usize, u64);
impl_map_from_bytes!(u16, u64);
impl_map_from_bytes!(u32, u64);
2015-11-26 15:00:17 +01:00
macro_rules! impl_uint_from_bytes {
2015-11-27 17:54:33 +01:00
($name: ident) => {
impl FromBytes for $name {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<$name> {
Ok($name::from(bytes))
}
}
}
2015-11-26 15:00:17 +01:00
}
impl_uint_from_bytes!(U256);
impl_uint_from_bytes!(U128);
impl <T>FromBytes for T where T: FixedHash {
fn from_bytes(bytes: &[u8]) -> FromBytesResult<T> {
match bytes.len().cmp(&T::size()) {
Ordering::Less => return Err(FromBytesError::DataIsTooShort),
Ordering::Greater => return Err(FromBytesError::DataIsTooLong),
Ordering::Equal => ()
};
unsafe {
use std::{mem, ptr};
let mut res: T = mem::uninitialized();
ptr::copy(bytes.as_ptr(), res.mut_bytes().as_mut_ptr(), T::size());
Ok(res)
}
}
}
2015-11-29 19:35:22 +01:00