Method update_string_table_msg

src/parsing/stringtables.rs:218–300

(&mut self, data: CSVCMsg_UpdateStringTable)

    }

    pub fn update_string_table_msg(&mut self, data: CSVCMsg_UpdateStringTable) -> Option<bool> {
        let st = self.stringtables.get_mut(data.table_id() as usize).unwrap();
        let mut buf = MyBitreader::new(data.string_data());
        let entry_bits = (st.max_entries as f32).log2() as i32;
        let mut index = 0;
        let mut last_inx: i32 = -1;
        let mut idx = 0;
        let mut btc = 0;
        let mut history: Vec<String> = Vec::new();
        let mut entry = String::new();
        buf.read_boolie()?;

        if !(st.name == "userinfo" || st.name == "instancebaseline") {
            return Some(true);
        }

        for _i in 0..data.num_changed_entries() {
            index = last_inx + 1;
            if !(buf.read_boolie()?) {
                index = buf
                    .read_nbits(entry_bits.try_into().unwrap())?
                    .try_into()
                    .unwrap();
            }
            last_inx = index;
            if buf.read_boolie()? {
                if buf.read_boolie()? {
                    let idx = buf.read_nbits(5)? as i32;
                    let bytes_to_copy = buf.read_nbits(5)?;
                    let s = &history[idx as usize];
                    let s_slice = &s[..bytes_to_copy as usize + 1];
                    entry = s_slice.to_owned() + &buf.read_string(4096)?;
                } else {
                    entry = buf.read_string(4096)?;
                }
                st.data[index as usize].entry = entry.to_string()
            }
            if history.len() >= 32 {
                history.remove(0);
            }
            history.push(entry.clone());
            if buf.read_boolie()? {
                let user_data = if st.udfs {
                    vec![buf
                        .read_nbits(st.uds.try_into().unwrap())?
                        .try_into()
                        .unwrap()]
                } else {
                    let size = buf.read_nbits(14)?;
                    buf.read_bits_st(size)?
                };
                if st.name == "instancebaseline" {
                    let k = entry.parse::<u32>().unwrap_or(999999);
                    match self.serverclass_map.get(&(k as u16)) {
                        Some(sv_cls) => {
                            parse_baselines(&user_data, sv_cls, &mut self.baselines);
                        }
                        None => {