competitive::tools

Trait SerdeByteStr

pub trait SerdeByteStr {
    // Required methods
    fn serialize(&self, buf: &mut Vec<u8>);
    fn deserialize<I>(iter: &mut I) -> Self
       where I: Iterator<Item = u8>;

    // Provided methods
    fn serialize_bytestr(&self) -> String { ... }
    fn deserialize_from_bytes(bytes: &[u8]) -> Self
       where Self: Sized { ... }
}

Required Methods§

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

Provided Methods§

fn serialize_bytestr(&self) -> String

fn deserialize_from_bytes(bytes: &[u8]) -> Self
where Self: Sized,

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

impl SerdeByteStr for bool

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for char

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for f32

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for f64

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for i8

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for i16

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for i32

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for i64

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for i128

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for isize

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for u8

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for u16

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for u32

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for u64

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for u128

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for ()

fn serialize(&self, _buf: &mut Vec<u8>)

fn deserialize<I>(_iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for usize

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl SerdeByteStr for String

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<A> SerdeByteStr for (A,)
where A: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B> SerdeByteStr for (A, B)
where A: SerdeByteStr, B: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C> SerdeByteStr for (A, B, C)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D> SerdeByteStr for (A, B, C, D)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E> SerdeByteStr for (A, B, C, D, E)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F> SerdeByteStr for (A, B, C, D, E, F)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F, G> SerdeByteStr for (A, B, C, D, E, F, G)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr, G: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F, G, H> SerdeByteStr for (A, B, C, D, E, F, G, H)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr, G: SerdeByteStr, H: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F, G, H, I> SerdeByteStr for (A, B, C, D, E, F, G, H, I)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr, G: SerdeByteStr, H: SerdeByteStr, I: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F, G, H, I, J> SerdeByteStr for (A, B, C, D, E, F, G, H, I, J)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr, G: SerdeByteStr, H: SerdeByteStr, I: SerdeByteStr, J: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<A, B, C, D, E, F, G, H, I, J, K> SerdeByteStr for (A, B, C, D, E, F, G, H, I, J, K)
where A: SerdeByteStr, B: SerdeByteStr, C: SerdeByteStr, D: SerdeByteStr, E: SerdeByteStr, F: SerdeByteStr, G: SerdeByteStr, H: SerdeByteStr, I: SerdeByteStr, J: SerdeByteStr, K: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<Iter>(iter: &mut Iter) -> Self
where Iter: Iterator<Item = u8>,

impl<K, V> SerdeByteStr for BTreeMap<K, V>
where K: SerdeByteStr + Ord, V: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<K, V> SerdeByteStr for HashMap<K, V>
where K: SerdeByteStr + Eq + Hash, V: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for Option<T>
where T: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for BinaryHeap<T>
where T: SerdeByteStr + Ord,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for BTreeSet<T>
where T: SerdeByteStr + Ord,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for VecDeque<T>
where T: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for Vec<T>
where T: SerdeByteStr,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

impl<T> SerdeByteStr for HashSet<T>
where T: SerdeByteStr + Eq + Hash,

fn serialize(&self, buf: &mut Vec<u8>)

fn deserialize<I>(iter: &mut I) -> Self
where I: Iterator<Item = u8>,

Implementors§