Enum TreeItemMode 

pub enum TreeItemMode {
    Blob,
    BlobExecutable,
    Tree,
    Commit,
    Link,
}

In Git, the mode field in a tree object’s entry specifies the type of the object represented by that entry. The mode is a three-digit octal number that encodes both the permissions and the type of the object. The first digit specifies the object type, and the remaining two digits specify the file mode or permissions.

Variants

Blob

BlobExecutable

Tree

Commit

Link

Implementations

impl TreeItemMode

pub fn tree_item_type_from_bytes(mode: &[u8]) -> Result<TreeItemMode, GitError>

Convert a 32-bit mode to a TreeItemType

|0100000000000000| (040000)| Directory| |1000000110100100| (100644)| Regular non-executable file| |1000000110110100| (100664)| Regular non-executable group-writeable file| |1000000111101101| (100755)| Regular executable file| |1010000000000000| (120000)| Symbolic link| |1110000000000000| (160000)| Gitlink|

GitLink

Gitlink, also known as a submodule, is a feature in Git that allows you to include a Git repository as a subdirectory within another Git repository. This is useful when you want to incorporate code from another project into your own project, without having to manually copy the code into your repository.

When you add a submodule to your Git repository, Git stores a reference to the other repository at a specific commit. This means that your repository will always point to a specific version of the other repository, even if changes are made to the submodule’s code in the future.

To work with a submodule in Git, you use commands like git submodule add, git submodule update, and git submodule init. These commands allow you to add a submodule to your repository, update it to the latest version, and initialize it for use.

Submodules can be a powerful tool for managing dependencies between different projects and components. However, they can also add complexity to your workflow, so it’s important to understand how they work and when to use them.

pub fn to_bytes(self) -> &'static [u8]

32-bit mode, split into (high to low bits):

• 4-bit object type: valid values in binary are 1000 (regular file), 1010 (symbolic link) and 1110 (gitlink)
• 3-bit unused
• 9-bit unix permission: Only 0755 and 0644 are valid for regular files. Symbolic links and gitlink have value 0 in this field.

Trait Implementations

impl Archive for TreeItemMode

type Archived = ArchivedTreeItemMode

The archived representation of this type.

type Resolver = TreeItemModeResolver

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 as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

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

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.

impl Clone for TreeItemMode

fn clone(&self) -> TreeItemMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TreeItemMode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TreeItemMode

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<TreeItemMode, __D> for Archived<TreeItemMode>

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

Deserializes using the given deserializer

impl Display for TreeItemMode

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

Formats the value using the given formatter.

impl Hash for TreeItemMode

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 TreeItemMode

fn eq(&self, other: &TreeItemMode) -> 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 TreeItemMode

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 TreeItemMode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TreeItemMode

impl Eq for TreeItemMode

impl StructuralPartialEq for TreeItemMode