molframe-pdb 0.6.4

Legacy PDB reading and writing for molframe
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Walking a file line by line, tracking where each began.
//!
//! The position is a by-product of the walk rather than something reconstructed
//! afterwards, so attaching an exact location to a finding costs nothing.

use super::numbers::AtomNumbers;
use crate::fixed;
use molframe_core::diagnostic::{Code, Diagnostic};
use molframe_core::span::Position;

/// A line of the file, with where it began.
#[derive(Clone, Copy)]
pub(super) struct Line<'a> {
    pub(super) text: &'a str,
    pub(super) at: Position,
    /// The row's numbers when a window decoded them ahead of the walk.
    pub(super) numbers: Option<&'a AtomNumbers>,
}

impl Line<'_> {
    pub(super) fn occupancy(&self) -> Option<f64> {
        match self.numbers {
            Some(numbers) => numbers.occupancy,
            None => fixed::real(self.text, 55, 60),
        }
    }

    pub(super) fn b_factor(&self) -> Option<f64> {
        match self.numbers {
            Some(numbers) => numbers.b_factor,
            None => fixed::real(self.text, 61, 66),
        }
    }
}

/// Walks the lines of a file, tracking where each began.
pub(super) struct Lines<'a> {
    remaining: &'a str,
    at: Position,
}

impl<'a> Lines<'a> {
    pub(super) fn new(text: &'a str) -> Self {
        Self {
            remaining: text,
            at: Position::START,
        }
    }
}

impl<'a> Iterator for Lines<'a> {
    type Item = Result<Line<'a>, Diagnostic>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.remaining.is_empty() {
            return None;
        }
        let at = self.at;
        let (line, rest) = match self.remaining.find('\n') {
            Some(end) => (self.remaining.get(..end)?, self.remaining.get(end + 1..)?),
            None => (self.remaining, ""),
        };
        self.remaining = rest;
        let advance = u64::try_from(line.len())
            .ok()
            .and_then(|length| length.checked_add(1));
        let Some((byte_offset, line_number)) = advance
            .and_then(|advance| at.byte_offset.checked_add(advance))
            .zip(at.line.checked_add(1))
        else {
            self.remaining = "";
            return Some(Err(Diagnostic::new(Code::E1202)
                .with_message("PDB source position exceeds the supported range")));
        };
        self.at = Position::new(byte_offset, line_number, 1);
        Some(Ok(Line {
            text: line.trim_end_matches('\r'),
            at,
            numbers: None,
        }))
    }
}