bitcointx 0.0.11

// Implementation of ByteBuffer
// With the API we need

pub struct ByteBuffer {
    buffer: Vec<u8>,
    cursor: usize,
}

impl ByteBuffer {
    pub fn from_vec(data: Vec<u8>) -> ByteBuffer {
        return ByteBuffer {
            buffer: data.clone(),
            cursor: 0,
        };
    }
    pub fn read_bytes(&mut self, n: usize) -> Vec<u8> {
        let slice = self.buffer[self.cursor..(self.cursor + n)].to_vec();
        self.cursor += n;

        return slice;
    }

    fn read_uint(&mut self, n: usize) -> u64 {
        let mut value: u64 = 0;

        for i in 0..n {
            value += (self.buffer[self.cursor] as u64) << (8 * i);
            self.cursor += 1;
        }

        return value;
    }
    pub fn read_u8(&mut self) -> u8 {
        return self.read_uint(1) as u8;
    }
    pub fn read_u16(&mut self) -> u16 {
        return self.read_uint(2) as u16;
    }
    pub fn read_u32(&mut self) -> u32 {
        return self.read_uint(4) as u32;
    }
    pub fn read_u64(&mut self) -> u64 {
        return self.read_uint(8) as u64;
    }
    pub fn read_var_int(&mut self) -> u64 {
        let size_byte = self.read_u8();

        return match size_byte {
            0xFF => self.read_u64(),
            0xFE => self.read_u32() as u64,
            0xFD => self.read_u16() as u64,
            _ => size_byte as u64,
        };
    }
}