fn process_raw_data()

in src/data/processes.rs [241:282]

• 39 lines of code
• 3 McCabe index (conditional complexity)

    fn process_raw_data(&mut self, buffer: Data) -> Result<ProcessedData> {
        let mut processes = Processes::new();
        let raw_value = match buffer {
            Data::ProcessesRaw(ref value) => value,
            _ => panic!("Invalid Data type in raw file"),
        };
        *TICKS_PER_SECOND.lock().unwrap() = raw_value.ticks_per_second;
        let reader = BufReader::new(raw_value.data.as_bytes());
        processes.time = raw_value.time;
        for line in reader.lines() {
            let line = line?;

            let open_parenthesis = line.find('(');
            let open_pos = match open_parenthesis {
                Some(v) => v,
                None => continue,
            };
            let close_parenthesis = line.find(')');
            let close_pos = match close_parenthesis {
                Some(v) => v,
                None => continue,
            };
            let pid = line[..open_pos - 1].parse::<u64>()?;
            let name = line[open_pos + 1..close_pos].to_string();
            let values: Vec<&str> = line[close_pos + 2..].split_whitespace().collect();

            if values.len() < PROC_PID_STAT_KERNELSPACE_TIME_POS + 1 {
                continue;
            }
            let user_time = values[PROC_PID_STAT_USERSPACE_TIME_POS].parse::<u64>()?;
            let kernel_time = values[PROC_PID_STAT_KERNELSPACE_TIME_POS].parse::<u64>()?;
            let cpu_time = user_time + kernel_time;

            processes.entries.push(SampleEntry {
                name,
                pid,
                cpu_time,
            });
        }
        let processed_data = ProcessedData::Processes(processes);
        Ok(processed_data)
    }