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

use std::convert::TryInto;

use git_hash::oid;
use git_object::Data;
use git_pack::find::Entry;

use crate::{
    pack,
    store_impls::{compound, linked},
};

impl git_pack::Find for linked::Store {
    type Error = compound::find::Error;

    /// Return true if the given object `id` is contained in the store.
    fn contains(&self, id: impl AsRef<oid>) -> bool {
        let id = id.as_ref();
        for db in self.dbs.iter() {
            if db.internal_find_packed(id).is_some() || db.loose.contains(id) {
                return true;
            }
        }
        false
    }

    fn try_find_cached<'a>(
        &self,
        id: impl AsRef<oid>,
        buffer: &'a mut Vec<u8>,
        pack_cache: &mut impl git_pack::cache::DecodeEntry,
    ) -> Result<Option<(git_object::Data<'a>, Option<pack::data::entry::Location>)>, Self::Error> {
        let id = id.as_ref();
        for db in self.dbs.iter() {
            match db.internal_find_packed(id) {
                Some(compound::find::PackLocation {
                    bundle_index: pack_id,
                    entry_index,
                }) => {
                    return db
                        .internal_get_packed_object_by_index(pack_id, entry_index, buffer, pack_cache)
                        .map(|(obj, location)| Some((obj, Some(location))))
                        .map_err(Into::into);
                }
                None => {
                    if db.loose.contains(id) {
                        return db
                            .loose
                            .try_find(id, buffer)
                            .map(|o| o.map(|o| (o, None)))
                            .map_err(Into::into);
                    }
                }
            }
        }
        Ok(None)
    }

    fn location_by_oid(&self, id: impl AsRef<oid>, buf: &mut Vec<u8>) -> Option<pack::data::entry::Location> {
        let id = id.as_ref();
        for db in self.dbs.iter() {
            if let Some(compound::find::PackLocation {
                bundle_index,
                entry_index,
            }) = db.internal_find_packed(id)
            {
                let bundle = &db.bundles[bundle_index];
                let pack_offset = bundle.index.pack_offset_at_index(entry_index);
                let entry = bundle.pack.entry(pack_offset);

                buf.resize(entry.decompressed_size.try_into().expect("representable size"), 0);
                return bundle
                    .pack
                    .decompress_entry(&entry, buf)
                    .ok()
                    .map(|entry_size_past_header| pack::data::entry::Location {
                        pack_id: bundle.pack.id,
                        pack_offset,
                        entry_size: entry.header_size() + entry_size_past_header,
                    });
            }
        }
        None
    }

    fn pack_offsets_and_oid(&self, pack_id: u32) -> Option<Vec<(u64, git_hash::ObjectId)>> {
        self.dbs.iter().find_map(|db| {
            db.bundles
                .iter()
                .find_map(|b| (b.pack.id == pack_id).then(|| b.index.iter().map(|e| (e.pack_offset, e.oid)).collect()))
        })
    }

    fn entry_by_location(&self, location: &pack::data::entry::Location) -> Option<Entry> {
        self.dbs
            .iter()
            .find_map(|db| db.bundles.iter().find(|p| p.pack.id == location.pack_id))
            .map(|b| (b, location))
            .and_then(|(bundle, l)| {
                bundle.pack.entry_slice(l.entry_range(l.pack_offset)).map(|data| Entry {
                    data: data.to_owned(),
                    version: bundle.pack.version(),
                })
            })
    }
}

impl crate::Find for linked::Store {
    type Error = compound::find::Error;

    fn contains(&self, id: impl AsRef<oid>) -> bool {
        pack::Find::contains(self, id)
    }

    fn try_find<'a>(&self, id: impl AsRef<oid>, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, Self::Error> {
        pack::Find::try_find(self, id, buffer).map(|t| t.map(|t| t.0))
    }
}