You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 lines
4.4 KiB
184 lines
4.4 KiB
use super::*;
|
|
use std::{
|
|
collections::{HashMap, HashSet},
|
|
io::{
|
|
self,
|
|
Write,
|
|
Read,
|
|
},
|
|
path::{
|
|
Path,
|
|
PathBuf
|
|
},
|
|
};
|
|
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub struct DupeMap
|
|
{
|
|
iteration: HashSet<hash::Sha256Hash>, // What we calculate
|
|
table: HashMap<PathBuf, hash::Sha256Hash>, // What we save and load
|
|
}
|
|
|
|
/// Do we care about windows? nah
|
|
#[inline]
|
|
fn path_bytes(path: &Path) -> &[u8]
|
|
{
|
|
use std::os::unix::ffi::OsStrExt;
|
|
path.as_os_str().as_bytes()
|
|
}
|
|
|
|
#[inline]
|
|
fn bytes_path(bytes: &[u8]) -> &Path
|
|
{
|
|
use std::os::unix::ffi::OsStrExt;
|
|
std::ffi::OsStr::from_bytes(bytes).as_ref()
|
|
}
|
|
|
|
const ENTRY_HEADER: &[u8] = &[0x00, 0xde, 0xad];
|
|
|
|
impl DupeMap
|
|
{
|
|
/// Create a new empty dupe map
|
|
pub fn new() -> Self
|
|
{
|
|
Self{iteration: HashSet::new(), table: HashMap::new()}
|
|
}
|
|
|
|
/// Iterator over all hashes
|
|
pub fn iter(&self) -> std::collections::hash_set::Iter<hash::Sha256Hash>
|
|
{
|
|
self.iteration.iter()
|
|
}
|
|
|
|
/// Cache this path's hash
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// True if caching was okay, false if key already added.
|
|
pub fn cache<T: AsRef<Path>>(&mut self, id: T, hash: hash::Sha256Hash) -> bool
|
|
{
|
|
if self.table.contains_key(id.as_ref()) {
|
|
false
|
|
} else {
|
|
self.table.insert(id.as_ref().to_owned(), hash);
|
|
true
|
|
}
|
|
}
|
|
|
|
/// Look for path `id` in cache.
|
|
pub fn get_cache<T: AsRef<Path>>(&self, id: T) -> Option<&hash::Sha256Hash>
|
|
{
|
|
self.table.get(id.as_ref())
|
|
}
|
|
|
|
/// Try to add to store. True if adding was oke, false if already exists.
|
|
pub fn try_add(&mut self, hash: hash::Sha256Hash) -> bool
|
|
{
|
|
if self.iteration.contains(&hash) {
|
|
false
|
|
} else {
|
|
self.iteration.insert(hash);
|
|
true
|
|
}
|
|
}
|
|
|
|
/// Save this list to a file
|
|
pub fn save<W: Write>(&self, to: &mut W) -> io::Result<usize>
|
|
{
|
|
let mut done=0;
|
|
for (path, hash) in self.table.iter()
|
|
{
|
|
let path = path_bytes(path.as_ref());
|
|
let hash: &[u8] = hash.as_ref();
|
|
|
|
to.write(ENTRY_HEADER)?;
|
|
to.write(bytes::reinterpret(&path.len()))?;
|
|
to.write(path)?;
|
|
to.write(hash)?;
|
|
done+=1;
|
|
}
|
|
Ok(done)
|
|
}
|
|
/// Save this list to a file async
|
|
#[cfg(feature="threads")]
|
|
pub async fn save_async<W>(&self, to: &mut W) -> io::Result<usize>
|
|
where W: tokio::io::AsyncWrite + std::marker::Send + std::marker::Sync + std::marker::Unpin
|
|
{
|
|
use tokio::prelude::*;
|
|
|
|
let mut done=0;
|
|
for (path, hash) in self.table.iter()
|
|
{
|
|
let path = path_bytes(path.as_ref());
|
|
let hash: &[u8] = hash.as_ref();
|
|
|
|
to.write(ENTRY_HEADER).await?;
|
|
to.write(bytes::reinterpret(&path.len())).await?;
|
|
to.write(path).await?;
|
|
to.write(hash).await?;
|
|
done+=1;
|
|
}
|
|
Ok(done)
|
|
}
|
|
|
|
/// Load from file.
|
|
pub fn load<R: Read>(&mut self, from: &mut R) -> io::Result<usize>
|
|
{
|
|
let mut done=0;
|
|
let mut read;
|
|
let mut header_buffer = [0u8; ENTRY_HEADER.len() + std::mem::size_of::<usize>()];
|
|
let mut hash_buffer = [0u8; hash::SHA256_SIZE];
|
|
|
|
while {read = from.read(&mut header_buffer[..])?; read == header_buffer.len() && &header_buffer[..ENTRY_HEADER.len()] == ENTRY_HEADER}
|
|
{
|
|
let sz = *bytes::reinterpret_back(&header_buffer[ENTRY_HEADER.len()..]);
|
|
if sz > 0 {
|
|
let mut path = vec![0u8; sz];
|
|
if from.read(&mut path[..])? == sz {
|
|
let path = bytes_path(&path[..]);
|
|
if from.read(&mut hash_buffer[..])? == hash::SHA256_SIZE
|
|
{
|
|
if self.cache(path, hash::Sha256Hash::new(hash_buffer)) {
|
|
done +=1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(done)
|
|
}
|
|
|
|
/// Load from file.
|
|
#[cfg(feature="threads")]
|
|
pub async fn load_async<R>(&mut self, from: &mut R) -> io::Result<usize>
|
|
where R: tokio::io::AsyncRead + std::marker::Send + std::marker::Sync + std::marker::Unpin
|
|
{
|
|
use tokio::prelude::*;
|
|
|
|
let mut done=0;
|
|
let mut read;
|
|
let mut header_buffer = [0u8; ENTRY_HEADER.len() + std::mem::size_of::<usize>()];
|
|
let mut hash_buffer = [0u8; hash::SHA256_SIZE];
|
|
|
|
while {read = from.read(&mut header_buffer[..]).await?; read == header_buffer.len() && &header_buffer[..ENTRY_HEADER.len()] == ENTRY_HEADER}
|
|
{
|
|
let sz = *bytes::reinterpret_back(&header_buffer[ENTRY_HEADER.len()..]);
|
|
if sz > 0 {
|
|
let mut path = vec![0u8; sz];
|
|
if from.read(&mut path[..]).await? == sz {
|
|
let path = bytes_path(&path[..]);
|
|
if from.read(&mut hash_buffer[..]).await? == hash::SHA256_SIZE
|
|
{
|
|
if self.cache(path, hash::Sha256Hash::new(hash_buffer)) {
|
|
done +=1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(done)
|
|
}
|
|
}
|