fn binary()

in src/replay.rs [389:431]
36 lines of code
3 McCabe index (conditional complexity)

    fn binary(&mut self) {
        // open files
        let zlog = File::open(&self.trace).expect("failed to open input zlog");
        let zbuf = BufReader::new(zlog);
        let mut log = Decoder::with_buffer(zbuf).expect("failed to init zstd decoder");

        let mut tmp = [0_u8; 20];
        while log.read_exact(&mut tmp).is_ok() {
            let ts: u64 = u32::from_le_bytes([tmp[0], tmp[1], tmp[2], tmp[3]]) as u64;
            let keyid: u64 = u64::from_le_bytes([
                tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11],
            ]);
            let klen_vlen: u32 = u32::from_le_bytes([tmp[12], tmp[13], tmp[14], tmp[15]]);
            let op_ttl: u32 = u32::from_le_bytes([tmp[16], tmp[17], tmp[18], tmp[19]]);
            let op: u8 = (op_ttl >> 24) as u8;
            let ttl: u32 = op_ttl & 0x00FF_FFFF;
            let klen = klen_vlen >> 22;
            let vlen: usize = (klen_vlen & 0x003F_FFFF) as usize;

            let key = format!("{:01$}", keyid, klen as usize);

            let mut request = match op {
                1 => Request::Get { key },
                2 => Request::Gets { key },
                3 => Request::Set { key, vlen, ttl },
                4 => Request::Add { key, vlen, ttl },
                6 => Request::Replace { key, vlen, ttl },
                9 => Request::Delete { key },
                _ => {
                    self.stats.skip += 1;
                    continue;
                }
            };

            self.controller.delay(ts);

            while let Err(r) = self.work.push(request) {
                request = r;
            }

            self.stats.sent += 1;
        }
    }