Struct radicle_git_ext::tree::Tree

pub struct Tree<'a>(/* private fields */);

A simplified representation of a git tree, intended mainly to be created from literals.

Example

use radicle_git_ext::tree::{Tree, blob};

let my_tree = vec![
    ("README", blob(b"awe")),
    ("src", vec![("main.rs", blob(b"fn main() {}"))].into_iter().collect()),
]
.into_iter()
.collect::<Tree>();

assert_eq!(
    format!("{:?}", my_tree),
    "Tree(\
        {\
            \"README\": Blob(\
                [\
                    97, \
                    119, \
                    101\
                ]\
            ), \
            \"src\": Tree(\
                Tree(\
                    {\
                        \"main.rs\": Blob(\
                            [\
                                102, \
                                110, \
                                32, \
                                109, \
                                97, \
                                105, \
                                110, \
                                40, \
                                41, \
                                32, \
                                123, \
                                125\
                            ]\
                        )\
                    }\
                )\
            )\
        }\
    )"
)

Implementations

impl Tree<'_>

pub fn write(&self, repo: &Repository) -> Result<Oid, Error>

Trait Implementations

impl<'a> Clone for Tree<'a>

fn clone(&self) -> Tree<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Tree<'a>

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

Formats the value using the given formatter.

impl<'a> From<BTreeMap<Cow<'a, str>, Node<'a>>> for Tree<'a>

fn from(map: BTreeMap<Cow<'a, str>, Node<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Tree<'a>> for Node<'a>

fn from(tree: Tree<'a>) -> Self

Converts to this type from the input type.

impl<'a, K, N> FromIterator<(K, N)> for Tree<'a>

where K: Into<Cow<'a, str>>, N: Into<Node<'a>>,

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = (K, N)>,

Creates a value from an iterator.