Struct wdg_base16::B16

pub struct B16<T>(_);

Trait Implementations

impl B16Encode<Vec<u64>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<u64>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<u64>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<u64>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<i64>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<i64>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<i64>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<i64>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<u32>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<u32>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<u32>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<u32>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<i32>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<i32>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<i32>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<i32>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<u16>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<u16>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<u16>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<u16>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<i16>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<i16>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<i16>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<i16>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<u8>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<u8>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<u8>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<u8>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<Vec<i8>, String, B16EncodeError> for B16<String>

fn encode(input: Vec<i8>) -> Result<String, B16EncodeError>

impl B16Encode<Vec<i8>, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: Vec<i8>) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<u8, String, B16EncodeError> for B16<String>

fn encode(input: u8) -> Result<String, B16EncodeError>

impl B16Encode<u8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: u8) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a u8, String, B16EncodeError> for B16<String>

fn encode(input: &'a u8) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a u8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a u8) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<i8, String, B16EncodeError> for B16<String>

fn encode(input: i8) -> Result<String, B16EncodeError>

impl B16Encode<i8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: i8) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a i8, String, B16EncodeError> for B16<String>

fn encode(input: &'a i8) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a i8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a i8) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<u16, String, B16EncodeError> for B16<String>

fn encode(input: u16) -> Result<String, B16EncodeError>

impl B16Encode<u16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: u16) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a u16, String, B16EncodeError> for B16<String>

fn encode(input: &'a u16) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a u16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a u16) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<i16, String, B16EncodeError> for B16<String>

fn encode(input: i16) -> Result<String, B16EncodeError>

impl B16Encode<i16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: i16) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a i16, String, B16EncodeError> for B16<String>

fn encode(input: &'a i16) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a i16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a i16) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<u32, String, B16EncodeError> for B16<String>

fn encode(input: u32) -> Result<String, B16EncodeError>

impl B16Encode<u32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: u32) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a u32, String, B16EncodeError> for B16<String>

fn encode(input: &'a u32) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a u32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a u32) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<i32, String, B16EncodeError> for B16<String>

fn encode(input: i32) -> Result<String, B16EncodeError>

impl B16Encode<i32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: i32) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a i32, String, B16EncodeError> for B16<String>

fn encode(input: &'a i32) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a i32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a i32) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<u64, String, B16EncodeError> for B16<String>

fn encode(input: u64) -> Result<String, B16EncodeError>

impl B16Encode<u64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: u64) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a u64, String, B16EncodeError> for B16<String>

fn encode(input: &'a u64) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a u64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a u64) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<i64, String, B16EncodeError> for B16<String>

fn encode(input: i64) -> Result<String, B16EncodeError>

impl B16Encode<i64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: i64) -> Result<Vec<u8>, B16EncodeError>

impl<'a> B16Encode<&'a i64, String, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a i64) -> Result<String, B16EncodeError>

impl<'a> B16Encode<&'a i64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: &'a i64) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<String, String, B16EncodeError> for B16<String>

fn encode(input: String) -> Result<String, B16EncodeError>

impl B16Encode<String, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: String) -> Result<Vec<u8>, B16EncodeError>

impl B16Encode<File, String, B16EncodeError> for B16<String>

fn encode(input: File) -> Result<String, B16EncodeError>

impl B16Encode<File, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn encode(input: File) -> Result<Vec<u8>, B16EncodeError>

impl B16FutureEncode<u8, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = u8>, 

impl B16FutureEncode<u8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = u8>, 

impl B16FutureEncode<i8, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = i8>, 

impl B16FutureEncode<i8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = i8>, 

impl B16FutureEncode<u16, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = u16>, 

impl B16FutureEncode<u16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = u16>, 

impl B16FutureEncode<i16, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = i16>, 

impl B16FutureEncode<i16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = i16>, 

impl B16FutureEncode<u32, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = u32>, 

impl B16FutureEncode<u32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = u32>, 

impl B16FutureEncode<i32, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = i32>, 

impl B16FutureEncode<i32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = i32>, 

impl B16FutureEncode<u64, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = u64>, 

impl B16FutureEncode<u64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = u64>, 

impl B16FutureEncode<i64, String, B16EncodeError> for B16<String>

fn future_encode<F>(
    f: F
) -> Then<F, Result<String, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<String, B16EncodeError>> where
    F: Future<Item = i64>, 

impl B16FutureEncode<i64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn future_encode<F>(
    f: F
) -> Then<F, Result<Vec<u8>, B16EncodeError>, fn(_: Result<F::Item, F::Error>) -> Result<Vec<u8>, B16EncodeError>> where
    F: Future<Item = i64>, 

impl B16PoolEncode<u8, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: u8) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<u8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: u8) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<i8, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: i8) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<i8, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: i8) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<u16, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: u16) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<u16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: u16) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<i16, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: i16) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<i16, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: i16) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<u32, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: u32) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<u32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: u32) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<i32, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: i32) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<i32, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: i32) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<u64, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: u64) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<u64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: u64) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16PoolEncode<i64, String, B16EncodeError> for B16<String>

fn pool_encode(pool: &CpuPool, input: i64) -> CpuFuture<String, B16EncodeError>

impl B16PoolEncode<i64, Vec<u8>, B16EncodeError> for B16<Vec<u8>>

fn pool_encode(pool: &CpuPool, input: i64) -> CpuFuture<Vec<u8>, B16EncodeError>

impl B16Decode<String, String, B16DecodeError> for B16<String>

fn decode(data: String) -> Result<String, B16DecodeError>

impl B16Decode<String, Vec<u8>, B16DecodeError> for B16<Vec<u8>>

fn decode(data: String) -> Result<Vec<u8>, B16DecodeError>

impl B16Decode<String, u8, B16DecodeError> for B16<u8>

fn decode(data: String) -> Result<u8, B16DecodeError>

impl B16Decode<Vec<u8>, u8, B16DecodeError> for B16<u8>

fn decode(data: Vec<u8>) -> Result<u8, B16DecodeError>

impl B16Decode<String, i8, B16DecodeError> for B16<i8>

fn decode(data: String) -> Result<i8, B16DecodeError>

impl B16Decode<Vec<u8>, i8, B16DecodeError> for B16<i8>

fn decode(data: Vec<u8>) -> Result<i8, B16DecodeError>

impl B16Decode<String, u16, B16DecodeError> for B16<u16>

fn decode(data: String) -> Result<u16, B16DecodeError>

impl B16Decode<Vec<u8>, u16, B16DecodeError> for B16<u16>

fn decode(data: Vec<u8>) -> Result<u16, B16DecodeError>

impl B16Decode<String, i16, B16DecodeError> for B16<i16>

fn decode(data: String) -> Result<i16, B16DecodeError>

impl B16Decode<Vec<u8>, i16, B16DecodeError> for B16<i16>

fn decode(data: Vec<u8>) -> Result<i16, B16DecodeError>

impl B16Decode<String, u32, B16DecodeError> for B16<u32>

fn decode(data: String) -> Result<u32, B16DecodeError>

impl B16Decode<Vec<u8>, u32, B16DecodeError> for B16<u32>

fn decode(data: Vec<u8>) -> Result<u32, B16DecodeError>

impl B16Decode<String, i32, B16DecodeError> for B16<i32>

fn decode(data: String) -> Result<i32, B16DecodeError>

impl B16Decode<Vec<u8>, i32, B16DecodeError> for B16<i32>

fn decode(data: Vec<u8>) -> Result<i32, B16DecodeError>

impl B16Decode<String, u64, B16DecodeError> for B16<u64>

fn decode(data: String) -> Result<u64, B16DecodeError>

impl B16Decode<Vec<u8>, u64, B16DecodeError> for B16<u64>

fn decode(data: Vec<u8>) -> Result<u64, B16DecodeError>

impl B16Decode<String, i64, B16DecodeError> for B16<i64>

fn decode(data: String) -> Result<i64, B16DecodeError>

impl B16Decode<Vec<u8>, i64, B16DecodeError> for B16<i64>

fn decode(data: Vec<u8>) -> Result<i64, B16DecodeError>

impl B16FutureDecode<String, u8, B16DecodeError> for B16<u8>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u8, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u8, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, u8, B16DecodeError> for B16<u8>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u8, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u8, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, i8, B16DecodeError> for B16<i8>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i8, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i8, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, i8, B16DecodeError> for B16<i8>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i8, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i8, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, u16, B16DecodeError> for B16<u16>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u16, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u16, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, u16, B16DecodeError> for B16<u16>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u16, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u16, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, i16, B16DecodeError> for B16<i16>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i16, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i16, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, i16, B16DecodeError> for B16<i16>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i16, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i16, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, u32, B16DecodeError> for B16<u32>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u32, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u32, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, u32, B16DecodeError> for B16<u32>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u32, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u32, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, i32, B16DecodeError> for B16<i32>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i32, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i32, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, i32, B16DecodeError> for B16<i32>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i32, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i32, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, u64, B16DecodeError> for B16<u64>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u64, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u64, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, u64, B16DecodeError> for B16<u64>

fn future_decode<F>(
    f: F
) -> Then<F, Result<u64, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<u64, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16FutureDecode<String, i64, B16DecodeError> for B16<i64>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i64, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i64, B16DecodeError>> where
    F: Future<Item = String>, 

impl B16FutureDecode<Vec<u8>, i64, B16DecodeError> for B16<i64>

fn future_decode<F>(
    f: F
) -> Then<F, Result<i64, B16DecodeError>, fn(_: Result<F::Item, F::Error>) -> Result<i64, B16DecodeError>> where
    F: Future<Item = Vec<u8>>, 

impl B16PoolDecode<String, u8, B16DecodeError> for B16<u8>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<u8, B16DecodeError>

impl B16PoolDecode<Vec<u8>, u8, B16DecodeError> for B16<u8>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<u8, B16DecodeError>

impl B16PoolDecode<String, i8, B16DecodeError> for B16<i8>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<i8, B16DecodeError>

impl B16PoolDecode<Vec<u8>, i8, B16DecodeError> for B16<i8>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<i8, B16DecodeError>

impl B16PoolDecode<String, u16, B16DecodeError> for B16<u16>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<u16, B16DecodeError>

impl B16PoolDecode<Vec<u8>, u16, B16DecodeError> for B16<u16>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<u16, B16DecodeError>

impl B16PoolDecode<String, i16, B16DecodeError> for B16<i16>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<i16, B16DecodeError>

impl B16PoolDecode<Vec<u8>, i16, B16DecodeError> for B16<i16>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<i16, B16DecodeError>

impl B16PoolDecode<String, u32, B16DecodeError> for B16<u32>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<u32, B16DecodeError>

impl B16PoolDecode<Vec<u8>, u32, B16DecodeError> for B16<u32>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<u32, B16DecodeError>

impl B16PoolDecode<String, i32, B16DecodeError> for B16<i32>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<i32, B16DecodeError>

impl B16PoolDecode<Vec<u8>, i32, B16DecodeError> for B16<i32>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<i32, B16DecodeError>

impl B16PoolDecode<String, u64, B16DecodeError> for B16<u64>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<u64, B16DecodeError>

impl B16PoolDecode<Vec<u8>, u64, B16DecodeError> for B16<u64>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<u64, B16DecodeError>

impl B16PoolDecode<String, i64, B16DecodeError> for B16<i64>

fn pool_decode(pool: &CpuPool, input: String) -> CpuFuture<i64, B16DecodeError>

impl B16PoolDecode<Vec<u8>, i64, B16DecodeError> for B16<i64>

fn pool_decode(pool: &CpuPool, input: Vec<u8>) -> CpuFuture<i64, B16DecodeError>