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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::error::Error::BranchNotFound;
use crate::{BranchName, Marshaler, ReaderTree, Slice, UnmarshalerInto};

pub enum ReadFromTreeResult<T> {
    OneValue(T),
    Slice(Slice<T>),
}

impl<T> ReadFromTreeResult<T> {
    pub fn unwrap(self) -> T {
        match self {
            ReadFromTreeResult::OneValue(v) => v,
            ReadFromTreeResult::Slice(_) => {
                panic!("should not be here ")
            }
        }
    }

    pub fn unwrap_slice(self) -> Slice<T> {
        match self {
            ReadFromTreeResult::OneValue(_v) => panic!("should not be here "),
            ReadFromTreeResult::Slice(b) => b,
        }
    }
}

pub trait ReadFromTree<'a> {
    fn from_branch_tree(
        tree: &'a crate::ReaderTree,
        branch_name: BranchName,
    ) -> crate::Result<impl Iterator<Item = ReadFromTreeResult<Self>>>
    where
        Self: Sized;

    fn from_branch_tree_sliced(
        tree: &'a crate::ReaderTree,
        branch_name: BranchName,
    ) -> crate::Result<impl Iterator<Item = ReadFromTreeResult<Self>>>
    where
        Self: Sized;

    fn from_tree(tree: &'a crate::ReaderTree) -> crate::Result<impl Iterator<Item = Self>>
    where
        Self: Sized,
    {
        Ok(
            Self::from_branch_tree(tree, BranchName::new())?.map(|t| match t {
                ReadFromTreeResult::OneValue(v) => v,
                ReadFromTreeResult::Slice(_) => {
                    panic!("should not be here ")
                }
            }),
        )
    }
}

pub trait WriteToTree {
    fn to_tree(
        it: impl Iterator<Item = Self> + 'static,
        tree: &mut crate::WriterTree,
    ) -> crate::Result<()>
    where
        Self: Sized,
    {
        Self::to_branch_tree(it, tree, None)
    }

    fn to_branch_tree(
        it: impl Iterator<Item = Self> + 'static,
        tree: &mut crate::WriterTree,
        branch_name: Option<&str>,
    ) -> crate::Result<()>
    where
        Self: Sized;
}

impl<'a, T> ReadFromTree<'a> for T
where
    T: UnmarshalerInto<Item = T> + 'a,
{
    fn from_branch_tree(
        tree: &'a crate::ReaderTree,
        branch_name: BranchName,
    ) -> crate::Result<impl Iterator<Item = ReadFromTreeResult<Self>>> {
        let final_branch_name = branch_name.final_name();

        Ok(tree
            .branch(&final_branch_name)
            .ok_or(BranchNotFound {
                name: final_branch_name,
            })?
            .as_iter::<T>()?
            .map(|t| ReadFromTreeResult::OneValue(t)))
    }

    /// this implementation exists to satisfy the compiler whcih need a concrete return type.
    fn from_branch_tree_sliced(
        tree: &'a ReaderTree,
        branch_name: BranchName,
    ) -> crate::Result<impl Iterator<Item = ReadFromTreeResult<Self>>>
    where
        Self: Sized,
    {
        let final_branch_name = branch_name.final_name();
        Ok(tree
            .branch(&final_branch_name)
            .ok_or(BranchNotFound {
                name: final_branch_name,
            })?
            .as_iter::<T>()?
            .map(|t| ReadFromTreeResult::OneValue(t)))
    }
}

// impl<'a, T> ReadFromTree<'a> for Sliced<T>
// where
//     T: ReadFromTree<'a>,
// {
//     fn from_branch_tree(
//         tree: &'a ReaderTree,
//         branch_name: BranchName,
//     ) -> crate::Result<impl Iterator<Item = ReadFromTreeResult<Self>>>
//     where
//         Self: Sized,
//     {
//         let final_branch_name = branch_name.final_name();
//
//         <Slice<T>>::from_tree(tree, branch_name);
//
//         todo!()
//     }
// }

impl<T> WriteToTree for T
where
    T: Marshaler + 'static,
{
    fn to_branch_tree(
        it: impl Iterator<Item = T> + 'static,
        tree: &mut crate::WriterTree,
        branch_name: Option<&str>,
    ) -> crate::Result<()> {
        tree.new_branch(branch_name.unwrap(), it);
        Ok(())
    }
}