mapcat/src/job.rs

use super::*;
use std::fs::{
    File, Metadata, OpenOptions,   
};
use std::convert::TryFrom;
use std::path::Path;
use std::io::{
    self,
    Read,
};
use std::{fmt,error};

#[derive(Debug)]
pub struct Prelude
{
    file: File,
    stat: Metadata,

    file_num: usize,
    offset: usize,
}

impl Prelude{
    pub fn len(&self) -> usize
    {
	usize::try_from(self.stat.len()).expect("Failed to fit file size into pointer size")
    }

    /// Convert this job prelude into a job, assigning it this state
    pub fn start(self, state: state::State) -> Job
    {
	Job {
	    fd: self.file,
	    stat: self.stat,
	    offset: self.offset,
	    file_num: self.file_num,
	    state,
	}
    }
}

#[derive(Debug)]
pub struct Job
{
    fd: File,
    stat: Metadata,

    file_num: usize,
    /// We grab the slice of memory we write to from here
    state: state::State,
    /// From this offset
    offset: usize,
}

//TODO: job's work :^)

impl Job
{
    pub fn state(&self) -> &state::State
    {
	&self.state
    }

    pub fn info(&self) -> (&File, &Metadata)
    {
	(&self.fd, &self.stat)
    }
    
    pub fn len(&self) -> usize
    {
	usize::try_from(self.stat.len()).expect("Failed to fit file size into pointer size")
    }
    
    pub fn start(&self) -> usize
    {
	self.offset
    }
    pub fn end(&self) -> usize
    {
	self.len() + self.offset
    }

    /// Get the output slice for this job.
    pub fn output_slice<'a, 'b>(&'a mut self) -> &'b mut [u8]
	where 'a: 'b
    {
	unsafe {
	    self.state.slice(self.start() .. self.end())
	}
    }

    /// Complete this job
    pub fn complete(self, size: usize) -> Result<(), CompletionError>
    {
	self.state.send_complete(self.file_num, size).map_err(|_| CompletionError)
    }
}

impl Read for Job
{
    #[inline] fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>
    {
	self.fd.read(buf)
    }
}

/// Create a job description for this file.
///
/// `sz` is the offset of the *end* of the last job. (or 0 for the first).
/// `sz` is then updated with this file's size for this method to be used again on the next file.
pub fn create_from_file(file_num: usize, file: impl AsRef<Path>, sz: &mut usize) -> io::Result<Prelude>
{
    let file = OpenOptions::new()
	.read(true)
	.open(file.as_ref())?;
    
    let stat = file.metadata()?;
    let offset = *sz;
    
    let prelude = Prelude {
	file, stat, offset, file_num
    };
    *sz += prelude.len();

    Ok(prelude)
}

/// Error returned when main thread's completion receiver was dropped. This should be fatal.
#[derive(Debug)]
pub struct CompletionError;

impl error::Error for CompletionError{}
impl fmt::Display for CompletionError
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
    {
	write!(f, "unable to send completion signal because main thread's completion receiver was dropped.")
    }
}