gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-19 21:04:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename SSZ traits (Encodable -> Encode)

Browse Source
This commit is contained in:
Paul Hauner
2019-05-13 15:12:19 +10:00
parent 94ab2479fe
commit a0148b5aae
39 changed files with 130 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
eth2/utils/ssz/src/decode.rs
View File

@@ -26,7 +26,7 @@ pub enum DecodeError {
///
/// See `examples/` for manual implementations or the crate root for implementations using
/// `#[derive(Decode)]`.
pub trait Decodable: Sized {
pub trait Decode: Sized {
/// Returns `true` if this object has a fixed-length.
///
/// I.e., there are no variable length items in this object or any of it's contained objects.
@@ -80,7 +80,7 @@ impl<'a> SszDecoderBuilder<'a> {
}
/// Declares that some type `T` is the next item in `bytes`.
pub fn register_type<T: Decodable>(&mut self) -> Result<(), DecodeError> {
pub fn register_type<T: Decode>(&mut self) -> Result<(), DecodeError> {
if T::is_ssz_fixed_len() {
let start = self.items_index;
self.items_index += T::ssz_fixed_len();
@@ -173,7 +173,7 @@ impl<'a> SszDecoderBuilder<'a> {
///
/// ```rust
/// use ssz_derive::{Encode, Decode};
/// use ssz::{Decodable, Encodable, SszDecoder, SszDecoderBuilder};
/// use ssz::{Decode, Encode, SszDecoder, SszDecoderBuilder};
///
/// #[derive(PartialEq, Debug, Encode, Decode)]
/// struct Foo {
@@ -215,7 +215,7 @@ impl<'a> SszDecoder<'a> {
/// # Panics
///
/// Panics when attempting to decode more items than actually exist.
pub fn decode_next<T: Decodable>(&mut self) -> Result<T, DecodeError> {
pub fn decode_next<T: Decode>(&mut self) -> Result<T, DecodeError> {
T::from_ssz_bytes(self.items.remove(0))
}
}

20
eth2/utils/ssz/src/decode/impls.rs
View File

@@ -3,7 +3,7 @@ use ethereum_types::H256;
macro_rules! impl_decodable_for_uint {
($type: ident, $bit_size: expr) => {
impl Decodable for $type {
impl Decode for $type {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -14,7 +14,7 @@ macro_rules! impl_decodable_for_uint {
fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
let len = bytes.len();
let expected = <Self as Decodable>::ssz_fixed_len();
let expected = <Self as Decode>::ssz_fixed_len();
if len != expected {
Err(DecodeError::InvalidByteLength { len, expected })
@@ -35,7 +35,7 @@ impl_decodable_for_uint!(u32, 32);
impl_decodable_for_uint!(u64, 64);
impl_decodable_for_uint!(usize, 64);
impl Decodable for bool {
impl Decode for bool {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -46,7 +46,7 @@ impl Decodable for bool {
fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
let len = bytes.len();
let expected = <Self as Decodable>::ssz_fixed_len();
let expected = <Self as Decode>::ssz_fixed_len();
if len != expected {
Err(DecodeError::InvalidByteLength { len, expected })
@@ -64,7 +64,7 @@ impl Decodable for bool {
}
}
impl Decodable for H256 {
impl Decode for H256 {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -75,7 +75,7 @@ impl Decodable for H256 {
fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
let len = bytes.len();
let expected = <Self as Decodable>::ssz_fixed_len();
let expected = <Self as Decode>::ssz_fixed_len();
if len != expected {
Err(DecodeError::InvalidByteLength { len, expected })
@@ -87,7 +87,7 @@ impl Decodable for H256 {
macro_rules! impl_decodable_for_u8_array {
($len: expr) => {
impl Decodable for [u8; $len] {
impl Decode for [u8; $len] {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -98,7 +98,7 @@ macro_rules! impl_decodable_for_u8_array {
fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
let len = bytes.len();
let expected = <Self as Decodable>::ssz_fixed_len();
let expected = <Self as Decode>::ssz_fixed_len();
if len != expected {
Err(DecodeError::InvalidByteLength { len, expected })
@@ -115,7 +115,7 @@ macro_rules! impl_decodable_for_u8_array {
impl_decodable_for_u8_array!(4);
impl<T: Decodable> Decodable for Vec<T> {
impl<T: Decode> Decode for Vec<T> {
fn is_ssz_fixed_len() -> bool {
false
}
@@ -139,7 +139,7 @@ impl<T: Decodable> Decodable for Vec<T> {
/// The `ssz::SszDecoder` can also perform this functionality, however it it significantly faster
/// as it is optimized to read same-typed items whilst `ssz::SszDecoder` supports reading items of
/// differing types.
pub fn decode_list_of_variable_length_items<T: Decodable>(
pub fn decode_list_of_variable_length_items<T: Decode>(
bytes: &[u8],
) -> Result<Vec<T>, DecodeError> {
let mut next_variable_byte = read_offset(bytes)?;

8
eth2/utils/ssz/src/encode.rs
View File

@@ -6,7 +6,7 @@ mod impls;
///
/// See `examples/` for manual implementations or the crate root for implementations using
/// `#[derive(Encode)]`.
pub trait Encodable {
pub trait Encode {
/// Returns `true` if this object has a fixed-length.
///
/// I.e., there are no variable length items in this object or any of it's contained objects.
@@ -50,7 +50,7 @@ pub trait Encodable {
///
/// ```rust
/// use ssz_derive::{Encode, Decode};
/// use ssz::{Decodable, Encodable, SszEncoder};
/// use ssz::{Decode, Encode, SszEncoder};
///
/// #[derive(PartialEq, Debug, Encode, Decode)]
/// struct Foo {
@@ -65,7 +65,7 @@ pub trait Encodable {
/// };
///
/// let mut buf: Vec<u8> = vec![];
/// let offset = <u64 as Encodable>::ssz_fixed_len() + <Vec<u16> as Encodable>::ssz_fixed_len();
/// let offset = <u64 as Encode>::ssz_fixed_len() + <Vec<u16> as Encode>::ssz_fixed_len();
///
/// let mut encoder = SszEncoder::container(&mut buf, offset);
///
@@ -104,7 +104,7 @@ impl<'a> SszEncoder<'a> {
}
/// Append some `item` to the SSZ bytes.
pub fn append<T: Encodable>(&mut self, item: &T) {
pub fn append<T: Encode>(&mut self, item: &T) {
if T::is_ssz_fixed_len() {
item.ssz_append(&mut self.buf);
} else {

10
eth2/utils/ssz/src/encode/impls.rs
View File

@@ -3,7 +3,7 @@ use ethereum_types::H256;
macro_rules! impl_encodable_for_uint {
($type: ident, $bit_size: expr) => {
impl Encodable for $type {
impl Encode for $type {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -25,7 +25,7 @@ impl_encodable_for_uint!(u32, 32);
impl_encodable_for_uint!(u64, 64);
impl_encodable_for_uint!(usize, 64);
impl<T: Encodable> Encodable for Vec<T> {
impl<T: Encode> Encode for Vec<T> {
fn is_ssz_fixed_len() -> bool {
false
}
@@ -49,7 +49,7 @@ impl<T: Encodable> Encodable for Vec<T> {
}
}
impl Encodable for bool {
impl Encode for bool {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -63,7 +63,7 @@ impl Encodable for bool {
}
}
impl Encodable for H256 {
impl Encode for H256 {
fn is_ssz_fixed_len() -> bool {
true
}
@@ -79,7 +79,7 @@ impl Encodable for H256 {
macro_rules! impl_encodable_for_u8_array {
($len: expr) => {
impl Encodable for [u8; $len] {
impl Encode for [u8; $len] {
fn is_ssz_fixed_len() -> bool {
true
}

11
eth2/utils/ssz/src/lib.rs
View File

@@ -9,7 +9,7 @@
//!
//! ```rust
//! use ssz_derive::{Encode, Decode};
//! use ssz::{Decodable, Encodable};
//! use ssz::{Decode, Encode};
//!
//! #[derive(PartialEq, Debug, Encode, Decode)]
//! struct Foo {
@@ -32,17 +32,16 @@
//!
//! ```
//!
//! See `examples/` for manual implementations of the `Encodable` and `Decodable` traits.
//! See `examples/` for manual implementations of the `Encode` and `Decode` traits.
mod decode;
mod encode;
mod macros;
pub use decode::{
impls::decode_list_of_variable_length_items, Decodable, DecodeError, SszDecoder,
SszDecoderBuilder,
impls::decode_list_of_variable_length_items, Decode, DecodeError, SszDecoder, SszDecoderBuilder,
};
pub use encode::{Encodable, SszEncoder};
pub use encode::{Encode, SszEncoder};
/// The number of bytes used to represent an offset.
pub const BYTES_PER_LENGTH_OFFSET: usize = 4;
@@ -54,7 +53,7 @@ pub const MAX_LENGTH_VALUE: usize = (1 << (BYTES_PER_LENGTH_OFFSET * 8)) - 1;
/// Equivalent to `val.as_ssz_bytes()`.
pub fn ssz_encode<T>(val: &T) -> Vec<u8>
where
T: Encodable,
T: Encode,
{
val.as_ssz_bytes()
}

26
eth2/utils/ssz/src/macros.rs
View File

@@ -1,18 +1,18 @@
/// Implements `Encodable` for `$impl_type` using an implementation of `From<$impl_type> for
/// Implements `Encode` for `$impl_type` using an implementation of `From<$impl_type> for
/// $from_type`.
///
/// In effect, this allows for easy implementation of `Encodable` for some type that implements a
/// `From` conversion into another type that already has `Encodable` implemented.
/// In effect, this allows for easy implementation of `Encode` for some type that implements a
/// `From` conversion into another type that already has `Encode` implemented.
#[macro_export]
macro_rules! impl_encode_via_from {
($impl_type: ty, $from_type: ty) => {
impl ssz::Encodable for $impl_type {
impl ssz::Encode for $impl_type {
fn is_ssz_fixed_len() -> bool {
<$from_type as ssz::Encodable>::is_ssz_fixed_len()
<$from_type as ssz::Encode>::is_ssz_fixed_len()
}
fn ssz_fixed_len() -> usize {
<$from_type as ssz::Encodable>::ssz_fixed_len()
<$from_type as ssz::Encode>::ssz_fixed_len()
}
fn ssz_append(&self, buf: &mut Vec<u8>) {
@@ -24,21 +24,21 @@ macro_rules! impl_encode_via_from {
};
}
/// Implements `Decodable` for `$impl_type` using an implementation of `From<$impl_type> for
/// Implements `Decode` for `$impl_type` using an implementation of `From<$impl_type> for
/// $from_type`.
///
/// In effect, this allows for easy implementation of `Decodable` for some type that implements a
/// `From` conversion into another type that already has `Decodable` implemented.
/// In effect, this allows for easy implementation of `Decode` for some type that implements a
/// `From` conversion into another type that already has `Decode` implemented.
#[macro_export]
macro_rules! impl_decode_via_from {
($impl_type: ty, $from_type: tt) => {
impl ssz::Decodable for $impl_type {
impl ssz::Decode for $impl_type {
fn is_ssz_fixed_len() -> bool {
<$from_type as ssz::Decodable>::is_ssz_fixed_len()
<$from_type as ssz::Decode>::is_ssz_fixed_len()
}
fn ssz_fixed_len() -> usize {
<$from_type as ssz::Decodable>::ssz_fixed_len()
<$from_type as ssz::Decode>::ssz_fixed_len()
}
fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
@@ -51,7 +51,7 @@ macro_rules! impl_decode_via_from {
#[cfg(test)]
mod tests {
use crate as ssz;
use ssz::{Decodable, Encodable};
use ssz::{Decode, Encode};
#[derive(PartialEq, Debug, Clone, Copy)]
struct Wrapper(u64);