quilt-rs 0.7.0

Rust library for accessing Quilt data packages.
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

pub use crate::quilt::lineage::mocks as lineage;

pub mod status {
    use multihash::Multihash;

    use crate::quilt::flow::status::PackageFileFingerprint;

    pub fn package_file_fingerprint() -> PackageFileFingerprint {
        PackageFileFingerprint {
            size: 0,
            hash: Multihash::wrap(0xb510, b"pedestrian").unwrap(),
        }
    }
}

pub mod manifest {
    use std::collections::BTreeMap;

    use multihash::Multihash;

    use crate::quilt::manifest_handle::ReadableManifest;
    use crate::quilt::storage::Storage;
    use crate::Error;
    use crate::Row4;
    use crate::Table;

    pub fn row4_with_name(name: String) -> Row4 {
        Row4 {
            name,
            place: "file:///z/x/y".to_string(),
            hash: Multihash::wrap(0xb510, b"pedestrian").unwrap(),
            ..Row4::default()
        }
    }

    pub fn default() -> impl ReadableManifest {
        struct InMemoryManifest {}
        impl ReadableManifest for InMemoryManifest {
            async fn read(&self, _storage: &impl Storage) -> Result<Table, Error> {
                Ok(Table::default())
            }
        }
        InMemoryManifest {}
    }

    pub fn with_record_keys(keys: Vec<String>) -> impl ReadableManifest {
        struct InMemoryManifest {
            keys: Vec<String>,
        }
        impl ReadableManifest for InMemoryManifest {
            async fn read(&self, _storage: &impl Storage) -> Result<Table, Error> {
                let mut records = BTreeMap::new();
                for key in &self.keys {
                    records.insert(key.to_string(), row4_with_name(key.to_string()));
                }
                Ok(Table {
                    records,
                    ..Table::default()
                })
            }
        }
        InMemoryManifest { keys }
    }

    pub fn with_rows(rows: Vec<Row4>) -> impl ReadableManifest {
        struct InMemoryManifest {
            rows: Vec<Row4>,
        }
        impl ReadableManifest for InMemoryManifest {
            async fn read(&self, _storage: &impl Storage) -> Result<Table, Error> {
                let mut records = BTreeMap::new();
                for row in &self.rows {
                    records.insert(row.name.to_string(), row.clone());
                }
                Ok(Table {
                    records,
                    ..Table::default()
                })
            }
        }
        InMemoryManifest { rows }
    }
}