feat: function signatures #2

+1

Cargo.toml

··· 8 8 crate-type = ["staticlib"] 9 9 10 10 [dependencies] 11 11 + libz-sys = "1.1.23"

+18 -2

nilla.nix

··· 11 11 { config, lib }: 12 12 { 13 13 config = { 14 14 - inputs.nixpkgs.src = pins.nixpkgs; 14 14 + inputs.nixpkgs = { 15 15 + src = pins.nixpkgs; 16 16 + settings.overlays = [ config.inputs.fenix.result.overlays.default ]; 17 17 + }; 18 18 + 19 19 + inputs.fenix.src = pins.fenix; 15 20 16 21 shells.default = { 17 22 systems = [ "x86_64-linux" ]; 18 23 19 24 shell = 20 20 - { mkShell, git }: 25 25 + { mkShell, git, fenix, bacon }: 21 26 mkShell { 22 27 inputsFrom = [ git ]; 28 28 + packages = [ 29 29 + (fenix.complete.withComponents [ 30 30 + "cargo" 31 31 + "clippy" 32 32 + "rust-src" 33 33 + "rustc" 34 34 + "rustfmt" 35 35 + "rust-analyzer" 36 36 + ]) 37 37 + bacon 38 38 + ]; 23 39 }; 24 40 }; 25 41 };

+13

npins/sources.json

··· 1 1 { 2 2 "pins": { 3 3 + "fenix": { 4 4 + "type": "Git", 5 5 + "repository": { 6 6 + "type": "GitHub", 7 7 + "owner": "nix-community", 8 8 + "repo": "fenix" 9 9 + }, 10 10 + "branch": "main", 11 11 + "submodules": false, 12 12 + "revision": "a563f057979806c59da53070297502eb7af22f62", 13 13 + "url": "https://github.com/nix-community/fenix/archive/a563f057979806c59da53070297502eb7af22f62.tar.gz", 14 14 + "hash": "sha256-WfItZn6duisxCxyltbu7Hs7kxzNeylgZGOwCYwHe26g=" 15 15 + }, 3 16 "nilla": { 4 17 "type": "GitRelease", 5 18 "repository": {

+1

src/lib.rs

··· 1 1 + pub mod reftable; 1 2 pub mod varint;

+64

src/reftable/basics.rs

··· 1 1 + #[derive(Debug, Clone)] 2 2 + pub struct ReftableBuf { 3 3 + pub data: Vec<u8>, 4 4 + pub len: usize, 5 5 + } 6 6 + 7 7 + impl ReftableBuf { 8 8 + pub fn new() -> Self { 9 9 + Self { 10 10 + data: Vec::new(), 11 11 + len: 0, 12 12 + } 13 13 + } 14 14 + 15 15 + pub fn with_capacity(capacity: usize) -> Self { 16 16 + Self { 17 17 + data: Vec::with_capacity(capacity), 18 18 + len: 0, 19 19 + } 20 20 + } 21 21 + 22 22 + pub fn clear(&mut self) { 23 23 + self.data.clear(); 24 24 + self.len = 0; 25 25 + } 26 26 + 27 27 + pub fn as_slice(&self) -> &[u8] { 28 28 + &self.data[..self.len] 29 29 + } 30 30 + } 31 31 + 32 32 + impl Default for ReftableBuf { 33 33 + fn default() -> Self { 34 34 + Self::new() 35 35 + } 36 36 + } 37 37 + 38 38 + pub fn binsearch<F>(sz: usize, mut f: F) -> usize 39 39 + where 40 40 + F: FnMut(usize) -> Result<bool, String>, 41 41 + { 42 42 + todo!() 43 43 + } 44 44 + 45 45 + pub fn names_length(names: &[&str]) -> usize { 46 46 + todo!() 47 47 + } 48 48 + 49 49 + pub fn parse_names(buf: &str) -> Result<Vec<String>, String> { 50 50 + todo!() 51 51 + } 52 52 + 53 53 + pub fn common_prefix_size(a: &ReftableBuf, b: &ReftableBuf) -> usize { 54 54 + todo!() 55 55 + } 56 56 + 57 57 + pub enum HashAlgorithm { 58 58 + Sha1 = 89, 59 59 + Sha256 = 247, 60 60 + } 61 61 + 62 62 + pub fn hash_size(id: HashAlgorithm) -> u32 { 63 63 + todo!() 64 64 + }

+59

src/reftable/block.rs

··· 1 1 + use crate::reftable::{basics::ReftableBuf, blocksource::ReftableBlockData}; 2 2 + use libz_sys::z_stream; 3 3 + 4 4 + pub struct BlockWriter { 5 5 + pub zstream: Box<z_stream>, 6 6 + pub compressed: Vec<u8>, 7 7 + 8 8 + pub block: Vec<u8>, 9 9 + pub block_size: u32, 10 10 + 11 11 + pub header_off: u32, 12 12 + 13 13 + pub restart_interval: u16, 14 14 + pub hash_size: u32, 15 15 + 16 16 + pub next: u32, 17 17 + pub restarts: Vec<u32>, 18 18 + pub restart_len: u32, 19 19 + pub restart_cap: u32, 20 20 + 21 21 + pub last_key: ReftableBuf, 22 22 + 23 23 + pub scratch: ReftableBuf, 24 24 + pub entries: i32, 25 25 + } 26 26 + 27 27 + pub struct BlockIter { 28 28 + pub next_off: u32, 29 29 + pub block: Vec<ReftableBlock>, 30 30 + 31 31 + pub last_key: ReftableBuf, 32 32 + pub scratch: ReftableBuf, 33 33 + } 34 34 + 35 35 + pub struct ReftableBlock { 36 36 + pub header_off: u32, 37 37 + 38 38 + pub block_data: ReftableBlockData, 39 39 + pub hash_size: usize, 40 40 + 41 41 + pub zstream: Box<z_stream>, 42 42 + pub uncompressed_data: Vec<u8>, 43 43 + 44 44 + pub restart_count: u16, 45 45 + pub restart_off: u32, 46 46 + 47 47 + pub full_block_size: u32, 48 48 + pub block_type: u8, 49 49 + } 50 50 + 51 51 + pub struct BlockReader { 52 52 + pub zstream: Box<z_stream>, 53 53 + pub uncompressed: Vec<u8>, 54 54 + pub uncompressed_len: usize, 55 55 + 56 56 + pub block: ReftableBlock, 57 57 + 58 58 + pub pos: usize, 59 59 + }

+21

src/reftable/blocksource.rs

··· 1 1 + pub struct ReftableBlockData { 2 2 + data: Vec<u8>, 3 3 + source: ReftableBlockSource, 4 4 + } 5 5 + 6 6 + impl AsRef<[u8]> for ReftableBlockData { 7 7 + fn as_ref(&self) -> &[u8] { 8 8 + &self.data 9 9 + } 10 10 + } 11 11 + 12 12 + pub trait ReftableBlockSourceOps { 13 13 + fn size(&self) -> u64; 14 14 + fn read_block(&self, offset: u64, size: u32) -> Result<Vec<u8>, String>; 15 15 + fn release_block(&self, data: &ReftableBlockData) -> Result<(), String>; 16 16 + fn close(&mut self) -> Result<(), String>; 17 17 + } 18 18 + 19 19 + pub struct ReftableBlockSource { 20 20 + ops: Box<dyn ReftableBlockSourceOps>, 21 21 + }

+34

src/reftable/error.rs

··· 1 1 + #[derive(Debug, Clone, PartialEq, Eq)] 2 2 + pub enum ReftableError { 3 3 + General(String), 4 4 + Io, 5 5 + Format, 6 6 + NotExist, 7 7 + Lock, 8 8 + Api, 9 9 + Zlib, 10 10 + EmptyTable, 11 11 + Refname, 12 12 + EntryTooBig, 13 13 + Outdated, 14 14 + OutOfMemory, 15 15 + } 16 16 + 17 17 + impl std::fmt::Display for ReftableError { 18 18 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 19 19 + match self { 20 20 + ReftableError::General(msg) => write!(f, "general error: {}", msg), 21 21 + ReftableError::Io => write!(f, "I/O error"), 22 22 + ReftableError::Format => write!(f, "corrupt reftable file"), 23 23 + ReftableError::NotExist => write!(f, "file does not exist"), 24 24 + ReftableError::Lock => write!(f, "data is locked"), 25 25 + ReftableError::Api => write!(f, "misuse of the reftable API"), 26 26 + ReftableError::Zlib => write!(f, "zlib failure"), 27 27 + ReftableError::EmptyTable => write!(f, "wrote empty table"), 28 28 + ReftableError::Refname => write!(f, "invalid refname"), 29 29 + ReftableError::EntryTooBig => write!(f, "entry too large"), 30 30 + ReftableError::Outdated => write!(f, "data concurrently modified"), 31 31 + ReftableError::OutOfMemory => write!(f, "out of memory"), 32 32 + } 33 33 + } 34 34 + }

+26

src/reftable/fsck.rs

··· 1 1 + pub enum ReftableFsckError { 2 2 + TableName, 3 3 + MaxValue, 4 4 + } 5 5 + 6 6 + pub struct ReftableFsckInfo { 7 7 + pub msg: String, 8 8 + pub path: String, 9 9 + pub error: ReftableFsckError, 10 10 + } 11 11 + 12 12 + pub fn table_has_valid_name(name: &str) -> bool { 13 13 + todo!() 14 14 + } 15 15 + 16 16 + pub fn table_check_name(table: &ReftableTable) -> Result<(), String> { 17 17 + todo!() 18 18 + } 19 19 + 20 20 + pub fn table_checks(table: &ReftableTable) -> Result<(), String> { 21 21 + todo!() 22 22 + } 23 23 + 24 24 + pub fn reftable_fsck_check(stack: &ReftableStack) -> Result<(), String> { 25 25 + todo!() 26 26 + }

src/reftable/iter.rs

src/reftable/merged.rs

+14

src/reftable/mod.rs

··· 1 1 + pub mod basics; 2 2 + pub mod block; 3 3 + pub mod blocksource; 4 4 + pub mod error; 5 5 + pub mod fsck; 6 6 + pub mod iter; 7 7 + pub mod merged; 8 8 + pub mod pq; 9 9 + pub mod record; 10 10 + pub mod stack; 11 11 + pub mod system; 12 12 + pub mod table; 13 13 + pub mod tree; 14 14 + pub mod write;

src/reftable/pq.rs

+148

src/reftable/record.rs

··· 1 1 + use crate::reftable::basics::ReftableBuf; 2 2 + 3 3 + pub const REFTABLE_HASH_SIZE_MAX: usize = 32; 4 4 + pub const REFTABLE_HASH_SIZE_SHA1: usize = 20; 5 5 + pub const REFTABLE_HASH_SIZE_SHA256: usize = 32; 6 6 + 7 7 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 8 8 + pub enum RefValueType { 9 9 + Deletion = 0x0, 10 10 + Val1 = 0x1, 11 11 + Val2 = 0x2, 12 12 + SymRef = 0x3, 13 13 + } 14 14 + 15 15 + impl std::convert::TryFrom<u8> for RefValueType { 16 16 + type Error = String; 17 17 + 18 18 + fn try_from(value: u8) -> Result<Self, String> { 19 19 + match value { 20 20 + 0x0 => Ok(RefValueType::Deletion), 21 21 + 0x1 => Ok(RefValueType::Val1), 22 22 + 0x2 => Ok(RefValueType::Val2), 23 23 + 0x3 => Ok(RefValueType::SymRef), 24 24 + _ => Err(format!("Unknown ref value type: {value}")), 25 25 + } 26 26 + } 27 27 + } 28 28 + 29 29 + #[derive(Debug, Clone)] 30 30 + pub enum RefValue { 31 31 + Val1([u8; REFTABLE_HASH_SIZE_MAX]), 32 32 + Val2 { 33 33 + value: [u8; REFTABLE_HASH_SIZE_MAX], 34 34 + target_value: [u8; REFTABLE_HASH_SIZE_MAX], 35 35 + }, 36 36 + SymRef(String), 37 37 + } 38 38 + 39 39 + #[derive(Debug, Clone)] 40 40 + pub struct ReftableRefRecord { 41 41 + pub refname: String, 42 42 + pub update_index: u64, 43 43 + pub value: Option<RefValue>, 44 44 + } 45 45 + 46 46 + impl ReftableRefRecord { 47 47 + pub fn equals(&self, other: &ReftableRefRecord, hash_size: u32) -> bool { 48 48 + todo!() 49 49 + } 50 50 + } 51 51 + 52 52 + impl PartialEq for ReftableRefRecord { 53 53 + fn eq(&self, other: &ReftableRefRecord) -> bool { 54 54 + self.equals(other, REFTABLE_HASH_SIZE_MAX as u32) 55 55 + } 56 56 + } 57 57 + 58 58 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 59 59 + pub enum LogValueType { 60 60 + Deletion = 0x0, 61 61 + Update = 0x1, 62 62 + } 63 63 + 64 64 + impl std::convert::TryFrom<u8> for LogValueType { 65 65 + type Error = String; 66 66 + 67 67 + fn try_from(value: u8) -> Result<Self, String> { 68 68 + match value { 69 69 + 0x0 => Ok(LogValueType::Deletion), 70 70 + 0x1 => Ok(LogValueType::Update), 71 71 + _ => Err(format!("Unknown log value type: {value}")), 72 72 + } 73 73 + } 74 74 + } 75 75 + 76 76 + #[derive(Debug, Clone)] 77 77 + pub struct LogUpdate { 78 78 + pub new_hash: [u8; REFTABLE_HASH_SIZE_MAX], 79 79 + pub old_hash: [u8; REFTABLE_HASH_SIZE_MAX], 80 80 + pub name: String, 81 81 + pub email: String, 82 82 + pub time: u64, 83 83 + pub tz_offset: i16, 84 84 + pub message: String, 85 85 + } 86 86 + 87 87 + #[derive(Debug, Clone)] 88 88 + pub struct ReftableLogRecord { 89 89 + pub refname: String, 90 90 + pub update_index: u64, 91 91 + pub value: Option<LogUpdate>, 92 92 + } 93 93 + 94 94 + impl ReftableLogRecord { 95 95 + pub fn equals(&self, other: &ReftableLogRecord, hash_size: u32) -> bool { 96 96 + todo!() 97 97 + } 98 98 + } 99 99 + 100 100 + impl PartialEq for ReftableLogRecord { 101 101 + fn eq(&self, other: &ReftableLogRecord) -> bool { 102 102 + self.equals(other, REFTABLE_HASH_SIZE_MAX as u32) 103 103 + } 104 104 + } 105 105 + 106 106 + #[derive(Debug, Clone)] 107 107 + pub struct ReftableObjRecord { 108 108 + pub hash_prefix: Vec<u8>, 109 109 + pub offsets: Vec<u64>, 110 110 + } 111 111 + 112 112 + impl PartialEq for ReftableObjRecord { 113 113 + fn eq(&self, other: &Self) -> bool { 114 114 + self.hash_prefix == other.hash_prefix && self.offsets == other.offsets 115 115 + } 116 116 + } 117 117 + 118 118 + #[derive(Debug, Clone)] 119 119 + pub struct ReftableIndexRecord { 120 120 + pub offset: u64, 121 121 + pub last_key: ReftableBuf, 122 122 + } 123 123 + 124 124 + impl PartialEq for ReftableIndexRecord { 125 125 + fn eq(&self, other: &Self) -> bool { 126 126 + self.offset == other.offset && self.last_key.as_slice() == other.last_key.as_slice() 127 127 + } 128 128 + } 129 129 + 130 130 + #[derive(Debug, Clone)] 131 131 + pub enum ReftableRecord { 132 132 + Ref(ReftableRefRecord), 133 133 + Log(ReftableLogRecord), 134 134 + Obj(ReftableObjRecord), 135 135 + Index(ReftableIndexRecord), 136 136 + } 137 137 + 138 138 + impl PartialEq for ReftableRecord { 139 139 + fn eq(&self, other: &Self) -> bool { 140 140 + match (self, other) { 141 141 + (ReftableRecord::Ref(a), ReftableRecord::Ref(b)) => a == b, 142 142 + (ReftableRecord::Log(a), ReftableRecord::Log(b)) => a == b, 143 143 + (ReftableRecord::Obj(a), ReftableRecord::Obj(b)) => a == b, 144 144 + (ReftableRecord::Index(a), ReftableRecord::Index(b)) => a == b, 145 145 + _ => false, 146 146 + } 147 147 + } 148 148 + }

src/reftable/stack.rs

src/reftable/system.rs

src/reftable/table.rs

src/reftable/tree.rs

src/reftable/write.rs