gix-ref 0.67.1

A crate to handle git references
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::{
    FullName, FullNameRef, Namespace, PartialName, PartialNameRef, Reference,
    bstr::{BStr, BString, ByteSlice},
    file, packed,
};

macro_rules! impl_partial_eq {
    ($left_type:ty, $right_type:ty, $left:ident => $left_bytes:expr, $right:ident => $right_bytes:expr) => {
        impl PartialEq<$right_type> for $left_type {
            fn eq(&self, other: &$right_type) -> bool {
                let $left = self;
                let $right = other;
                $left_bytes == $right_bytes
            }
        }
    };
}

macro_rules! impl_partial_eq_pair {
    ($left_type:ty, $right_type:ty, $left:ident => $left_bytes:expr, $right:ident => $right_bytes:expr) => {
        impl_partial_eq!($left_type, $right_type, $left => $left_bytes, $right => $right_bytes);
        impl_partial_eq!($right_type, $left_type, $right => $right_bytes, $left => $left_bytes);
    };
}

macro_rules! impl_partial_eq_bytes {
    ($type:ty, $value:ident => $bytes:expr) => {
        impl_partial_eq_pair!($type, str, $value => $bytes.as_bytes(), other => other.as_bytes());
        impl_partial_eq_pair!($type, &str, $value => $bytes.as_bytes(), other => other.as_bytes());
        impl_partial_eq_pair!($type, String, $value => $bytes.as_bytes(), other => other.as_bytes());
        impl_partial_eq_pair!($type, BStr, $value => $bytes.as_bytes(), other => other.as_bytes());
        impl_partial_eq_pair!($type, &BStr, $value => $bytes.as_bytes(), other => other.as_bytes());
        impl_partial_eq_pair!($type, BString, $value => $bytes.as_bytes(), other => other.as_bytes());
    };
}

macro_rules! impl_partial_eq_reference {
    ($type:ty, $value:ident => $name:expr) => {
        impl_partial_eq!($type, str, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!($type, &str, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!($type, String, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!($type, BStr, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!($type, &BStr, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!($type, BString, $value => $name.as_bytes(), other => other.as_bytes());
        impl_partial_eq!(
            $type,
            FullName,
            $value => $name.as_bytes(),
            other => other.as_bstr().as_bytes()
        );
        impl_partial_eq!(
            $type,
            FullNameRef,
            $value => $name.as_bytes(),
            other => other.as_bstr().as_bytes()
        );
        impl_partial_eq!(
            $type,
            &FullNameRef,
            $value => $name.as_bytes(),
            other => other.as_bstr().as_bytes()
        );
    };
}

impl_partial_eq_bytes!(FullName, value => value.as_bstr());
impl_partial_eq_bytes!(FullNameRef, value => value.as_bstr());
impl_partial_eq_bytes!(PartialName, value => value.as_ref().as_bstr());
impl_partial_eq_bytes!(PartialNameRef, value => value.as_bstr());
impl_partial_eq_bytes!(Namespace, value => value.as_bstr());

impl_partial_eq_pair!(
    &FullNameRef,
    String,
    name => name.as_bstr().as_bytes(),
    text => text.as_bytes()
);
impl_partial_eq_pair!(
    &FullNameRef,
    BString,
    name => name.as_bstr().as_bytes(),
    text => text.as_bytes()
);
impl_partial_eq_pair!(
    &PartialNameRef,
    String,
    name => name.as_bstr().as_bytes(),
    text => text.as_bytes()
);
impl_partial_eq_pair!(
    &PartialNameRef,
    BString,
    name => name.as_bstr().as_bytes(),
    text => text.as_bytes()
);

impl_partial_eq_pair!(
    FullName,
    FullNameRef,
    owned => owned.as_bstr().as_bytes(),
    borrowed => borrowed.as_bstr().as_bytes()
);
impl_partial_eq_pair!(
    FullName,
    &FullNameRef,
    owned => owned.as_bstr().as_bytes(),
    borrowed => borrowed.as_bstr().as_bytes()
);
impl_partial_eq_pair!(
    PartialName,
    PartialNameRef,
    owned => owned.as_ref().as_bstr().as_bytes(),
    borrowed => borrowed.as_bstr().as_bytes()
);
impl_partial_eq_pair!(
    PartialName,
    &PartialNameRef,
    owned => owned.as_ref().as_bstr().as_bytes(),
    borrowed => borrowed.as_bstr().as_bytes()
);

// Keep these comparisons one-way: same-type reference equality is structural, so reverse
// implementations would let references with different targets form a non-transitive chain through their name.
impl_partial_eq_reference!(Reference, value => value.name.as_bstr());
impl_partial_eq_reference!(file::loose::Reference, value => value.name.as_bstr());
impl_partial_eq_reference!(packed::Reference<'_>, value => value.name.as_bstr());