oxyroot 0.1.25

Another attempt to make library reading and writing of `.root` binary files which are commonly used in particle physics
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
83
84
85
86
87
88
89
90
91
92
93

use crate::rbytes::rbuffer::RBuffer;
use crate::rbytes::wbuffer::WBuffer;
use crate::rbytes::{Marshaler, Unmarshaler};
use crate::riofs::consts::kStartBigFile;
use crate::root::traits;
use log::trace;

#[derive(Default)]
pub struct FreeSegments {
    pub(crate) first: i64,
    // first free word of segment
    pub(crate) last: i64, // last free word of segment
}

impl FreeSegments {
    pub(crate) fn new(first: i64, last: i64) -> Self {
        FreeSegments { first, last }
    }
    pub(crate) fn size_of(&self) -> i32 {
        if self.last > kStartBigFile {
            return 18;
        }
        10
    }
}

impl Unmarshaler for FreeSegments {
    fn unmarshal(&mut self, r: &mut RBuffer) -> crate::rbytes::Result<()> {
        let vers = r.read_i16()?;

        let is_big_file = vers > 1000;
        let first = if is_big_file {
            r.read_i64()?
        } else {
            r.read_i32()? as i64
        };
        let last = if is_big_file {
            r.read_i64()?
        } else {
            r.read_i32()? as i64
        };

        self.first = first;
        self.last = last;
        Ok(())
    }
}

impl Marshaler for FreeSegments {
    fn marshal(&self, w: &mut WBuffer) -> crate::rbytes::Result<i64> {
        let beg = w.pos();
        trace!(";FreeSegments.marshal.beg:{:?}", beg);
        let mut vers = 1_i16;
        if self.last > kStartBigFile {
            vers += 1000;
        }
        w.write_i16(vers)?;
        if vers > 1000 {
            w.write_i64(self.first)?;
            w.write_i64(self.last)?;
        } else {
            w.write_i32(self.first as i32)?;
            w.write_i32(self.last as i32)?;
        }

        let end = w.pos();

        trace!(";FreeSegments.marshal.buf.end:{:?}", w.p());
        Ok(end - beg)
    }
}

impl traits::Object for FreeSegments {
    fn class(&self) -> &'_ str {
        "FreeSegments"
    }
}

#[derive(Default)]
pub struct FreeList(Vec<FreeSegments>);

impl FreeList {
    pub(crate) fn vec(&mut self) -> &mut Vec<FreeSegments> {
        &mut self.0
    }
    pub fn append(&mut self, seg: FreeSegments) {
        self.0.push(seg)
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }
}