use libpijul::pristine::ChannelMutTxnT;

        if let Some((mut change, updates, hash)) = result {

        if let Some((mut change, updates, hash, oldest)) = result {

            let oldest = if let Ok(t) = oldest.duration_since(std::time::SystemTime::UNIX_EPOCH) {
                t.as_secs() as u64
            } else {
                0
            };
            txn.touch_channel(&mut channel.borrow_mut(), Some(oldest));

            let oldest = std::time::SystemTime::now();
            let oldest = if let Ok(t) = oldest.duration_since(std::time::SystemTime::UNIX_EPOCH) {
                t.as_secs() as u64
            } else {
                0
            };
            txn.touch_channel(&mut channel.borrow_mut(), Some(oldest));
            txn.commit()?;

            std::time::SystemTime,

        Ok(Some((change, rec.updatables, Some(hash))))

        Ok(Some((
            change,
            rec.updatables,
            Some(hash),
            rec.oldest_change,
        )))

    T::touch_channel(channel, Some(0));

    txn.touch_channel(channel, Some(0));

#[derive(Default)]

    /// Timestamp of the oldest changed file. If nothing changed,
    /// returns now().
    pub oldest_change: std::time::SystemTime,

            rec: Recorded::default(),

            rec: Recorded {
                contents: Vec::new(),
                actions: Vec::new(),
                updatables: HashMap::new(),
                largest_file: 0,
                has_binary_files: false,
                oldest_change: std::time::SystemTime::now(),
            },

            force_rediff: true,

            force_rediff: false,

                    || modified_since_last_commit::<T, _>(&channel, working_copy, &item.full_path)?)

                    || self.modified_since_last_commit::<T, _>(&channel, working_copy, &item.full_path)?)

                if self.rec.actions.len() > len {
                    if let Ok(last_modified) = working_copy.modified_time(&item.full_path) {
                        self.rec.oldest_change = self.rec.oldest_change.min(last_modified);
                    }
                }

}

fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
    channel: &T::Channel,
    working_copy: &W,
    prefix: &str,
) -> Result<bool, std::time::SystemTimeError> {
    if let Ok(last_modified) = working_copy.modified_time(prefix) {
        debug!(
            "last_modified = {:?}, channel.last = {:?}",
            last_modified
                .duration_since(std::time::UNIX_EPOCH)?
                .as_secs(),
            T::last_modified(channel)
        );
        Ok(last_modified
            .duration_since(std::time::UNIX_EPOCH)?
            .as_secs()
            + 2
            >= T::last_modified(channel))
    } else {
        Ok(true)

    fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
        &mut self,
        channel: &T::Channel,
        working_copy: &W,
        prefix: &str,
    ) -> Result<bool, std::time::SystemTimeError> {
        if let Ok(last_modified) = working_copy.modified_time(prefix) {
            debug!(
                "last_modified = {:?}, channel.last = {:?}",
                last_modified
                    .duration_since(std::time::UNIX_EPOCH)?
                    .as_secs(),
                T::last_modified(channel)
            );
            Ok(last_modified
               .duration_since(std::time::UNIX_EPOCH)?
               .as_secs()
               + 2
               >= T::last_modified(channel))
        } else {
            Ok(true)
        }

    fn touch_channel(channel: &mut Self::Channel, t: Option<u64>) {

    fn touch_channel(&mut self, channel: &mut Self::Channel, t: Option<u64>) {

    fn touch_channel(channel: &mut Self::Channel, t: Option<u64>);

    fn touch_channel(&mut self, channel: &mut Self::Channel, t: Option<u64>);

    T::touch_channel(channel, None);