Struct TreeItem 

pub struct TreeItem {
    pub mode: TreeItemMode,
    pub id: ObjectHash,
    pub name: String,
}

A tree object contains a list of entries, one for each file or directory in the tree. Each entry in the file represents an entry in the tree, and each entry has the following format:

<mode> <name>\0<binary object ID>

• <mode> is the mode of the object, represented as a six-digit octal number. The first digit represents the object type (tree, blob, etc.), and the remaining digits represent the file mode or permissions.
• <name> is the name of the object.
• \0 is a null byte separator.
• <binary object ID> is the ID of the object that represents the contents of the file or directory, represented as a binary SHA-1 hash.

Example

100644 hello-world\0<blob object ID>
040000 data\0<tree object ID>

Fields

mode: TreeItemMode

id: ObjectHash

name: String

Implementations

impl TreeItem

pub fn new(mode: TreeItemMode, id: ObjectHash, name: String) -> Self

Creates a new TreeItem with the given mode, object ID, and name.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, GitError>

Create a new TreeItem from a byte vector, split into a mode, id and name, the TreeItem format is:

<mode> <name>\0<binary object ID>

pub fn to_data(&self) -> Vec<u8>

Convert a TreeItem to a byte vector

use std::str::FromStr;
use git_internal::internal::object::tree::{TreeItem, TreeItemMode};
use git_internal::hash::ObjectHash;

let tree_item = TreeItem::new(
    TreeItemMode::Blob,
    ObjectHash::from_str("8ab686eafeb1f44702738c8b0f24f2567c36da6d").unwrap(),
    "hello-world".to_string(),
);

pub fn is_tree(&self) -> bool

Returns true if this item represents a subdirectory (tree).

pub fn is_blob(&self) -> bool

Returns true if this item represents a regular file (blob).

Trait Implementations

impl Archive for TreeItem

where TreeItemMode: Archive, ObjectHash: Archive, String: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedTreeItem

The archived representation of this type.

type Resolver = TreeItemResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for TreeItem

fn clone(&self) -> TreeItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TreeItem

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TreeItem

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<TreeItem, __D> for Archived<TreeItem>

where TreeItemMode: Archive, <TreeItemMode as Archive>::Archived: Deserialize<TreeItemMode, __D>, ObjectHash: Archive, <ObjectHash as Archive>::Archived: Deserialize<ObjectHash, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TreeItem, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for TreeItem

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

Formats the value using the given formatter.

impl Hash for TreeItem

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TreeItem

fn eq(&self, other: &TreeItem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<__S: Fallible + ?Sized> Serialize<__S> for TreeItem

where TreeItemMode: Serialize<__S>, ObjectHash: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for TreeItem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TreeItem

impl StructuralPartialEq for TreeItem