Struct oxyroot::rtree::Tree

pub struct Tree<B> { /* private fields */ }

Implementations

impl Tree<Branch>

pub fn branch(&self, name: &str) -> Option<&Branch>

Get a branch from this tree

pub fn branches(&self) -> impl Iterator<Item = &Branch>

Get iterator over top-level branches

pub fn entries(&self) -> i64

Number of entries in the TTree, as reported by fEntries.

pub fn branches_r(&self) -> Vec<&Branch>

Get all (recursively) branches in this tree

pub fn user_info(&self) -> Option<&ReaderList>

pub fn show(&self)

Display branches in this tree

Provide name, C++ type and a possible Rust interpretation.

Example:

name                           | typename                       | interpretation
-------------------------------+-------------------------------+-------------------------------
string                         | string                         | String
vector_vector_int32            | vector<vector<int32_t>>        | Vec<Vec<i32>>
vector_int32                   | vector<int32_t>                | Vec<i32>
vector_string                  | vector<string>                 | Vec<String>
three                          | char*                          | String

In this example, last branch can be read with:

let three = tree
        .branch("three")
        .unwrap()
        .as_iter::<String>()
        .collect::<Vec<_>>();

impl Tree<WBranch<Box<dyn Marshaler>>>

pub fn new<S>(name: S) -> Self

where S: AsRef<str>,

pub fn add_callback<F>(&mut self, f: Box<F>)

where F: FnMut(StateCallBack) + 'static,

pub fn add_streamer(&mut self, si: StreamerInfo)

pub fn new_branch<T, S>( &mut self, name: S, provider: impl Iterator<Item = T> + 'static )

where T: Marshaler + 'static, S: AsRef<str>,

pub fn write(&mut self, file: &mut RootFile) -> Result<(), Error>

impl<B> Tree<B>

pub fn tot_bytes(&self) -> i64

pub fn title(&self) -> &str

Trait Implementations

impl<B> Default for Tree<B>

fn default() -> Self

Returns the “default value” for a type.