Struct oxyroot::Slice

pub struct Slice<T> { /* private fields */ }

Represent a array of T* in C++

To read branch with int (aka i32 rust) in it

use oxyroot::RootFile;

let s = "examples/from_uproot/data/small-evnt-tree-fullsplit.root";///
let mut f = RootFile::open(s).unwrap();
let tree = f.get_tree("tree").unwrap();

tree.branch("SliceI16")
        .unwrap()
        .as_iter::<oxyroot::Slice<i16>>().expect("wrong type")
        .map(|a| a.into_vec())
        .enumerate()
        .for_each(|(i, val)| {
            assert_eq!(val.len(), i % 10);

            val.into_iter()
                .map(|v| {
                    assert_eq!(v, i as i16);
                })
                .for_each(drop) // Consume iterator
        });

Implementations

impl<T> Slice<T>

pub fn into_vec(self) -> Vec<T>

pub fn inner(&self) -> &Vec<T>

Trait Implementations

impl<T: Debug> Debug for Slice<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Slice<T>

fn default() -> Slice<T>

Returns the “default value” for a type.

impl<T> From<Slice<T>> for Vec<T>

fn from(slice: Slice<T>) -> Self

Converts to this type from the input type.

impl<T> Unmarshaler for Slice<T>

where T: UnmarshalerInto<Item = T> + Debug,

fn unmarshal(&mut self, r: &mut RBuffer<'_>) -> Result<(), Error>

fn class_name() -> Option<Vec<String>>

where Self: Sized,

Returns the kind of the type as C++ typename. Used to check if the type is supported.