file_info.cpp

Go to the documentation of this file.

#ifndef FILE_INFO_IMPLEMENTATION_FILE
#define FILE_INFO_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : file_info                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "file_info.h"

#include <basis/byte_array.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <opsystem/huge_file.h>

#define DEBUG_FILE_INFO
  // uncomment for noisy version.

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)

file_info::file_info(const filename &to_copy, double file_size, int checksum)
: filename(to_copy),
  _file_size(file_size),
  _checksum(checksum),
  _secondary(new istring),
  _attachment(new byte_array)
{}

file_info::file_info(const file_info &to_copy)
: filename(to_copy),
  _file_size(to_copy._file_size),
  _checksum(to_copy._checksum),
  _secondary(new istring(*to_copy._secondary)),
  _attachment(new byte_array(*to_copy._attachment))
{
}

file_info::~file_info()
{
  WHACK(_secondary);
  WHACK(_attachment);
}

const byte_array &file_info::attachment() const { return *_attachment; }

void file_info::attachment(const byte_array &new_attachment)
{ *_attachment = new_attachment; }

const istring &file_info::secondary() const { return *_secondary; }

void file_info::secondary(const istring &new_sec) const
{ *_secondary = new_sec; }

istring file_info::text_form() const
{
  istring to_return = raw()
      + isprintf(", size=%0.f, chksum=%d", _file_size, _checksum);
  if (_secondary->t())
    to_return += istring(", 2ndary=") + *_secondary;
  return to_return;
}

bool file_info::calculate(const istring &prefix, bool just_size,
    int checksum_edge)
{
  FUNCDEF("calculate");
  filename full;
  if (prefix.t()) full = prefix + "/" + *this;
  else full = *this;
  if (!full.exists()) {
#ifdef DEBUG_FILE_INFO
    LOG(istring("failed to find file: ") + full.raw());
#endif
    return false;
  }
  // open the file for reading.
  huge_file to_read(full.raw(), "rb");
  if (!to_read.good()) {
#ifdef DEBUG_FILE_INFO
    LOG(istring("file has non-good status: ") + full.raw());
#endif
    return false;  // why did that happen?
  }
  // set the size appropriately.
  _file_size = to_read.length();
  if (just_size)
    return true;  // done for that case.

  // now read the file and compute a checksum.
  uint16 curr_sum = 0;  // the current checksum being computed.
  byte_array chunk;  // temporary chunk of data from file.

//hmmm: make this optimization (hack) optional!

  // this algorithm takes a chunk on each end of the file for checksums.
  // this saves us from reading a huge amount of data, although it will be
  // fooled if a huge binary file is changed only in the middle and has the
  // same size as before.  for most purposes, this is not a problem, although
  // databases that are fixed size might fool us.  if records are written in
  // the middle without updating the head or tail sections, then we're hosed.

  bool skip_tail = false;  // true if we don't need the tail piece.
  double head_start = 0, head_end = 0, tail_start = 0,
      tail_end = _file_size - 1;
  if (_file_size <= double(2 * checksum_edge)) {
    // we're applying a rule for when the file is too small compared to
    // the chunk factor doubled; we'll just read the whole file.
    head_end = _file_size - 1;
    skip_tail = true;
  } else {
    // here we compute the ending of the head piece and the beginning of
    // the tail piece.  each will be about checksum_edge in size.
    head_end = minimum(_file_size / 2, double(checksum_edge)) - 1;
    tail_start = _file_size - minimum(_file_size / 2, double(checksum_edge));
  }

  // read the head end of the file.
  int size_read = 0;
  outcome ret = to_read.read(chunk, int(head_end - head_start + 1), size_read);
  if (ret != huge_file::OKAY) {
#ifdef DEBUG_FILE_INFO
    LOG(istring("reading file failed: ") + full.raw());
#endif
    return false;  // failed to read.
  }
  curr_sum = utility::rolling_fletcher_checksum(curr_sum, chunk.observe(),
      chunk.length());

  // read the tail end of the file.
  if (!skip_tail) {
    to_read.seek(tail_start, byte_filer::FROM_START);
    ret = to_read.read(chunk, int(tail_end - tail_start + 1), size_read);
    if (ret != huge_file::OKAY) {
#ifdef DEBUG_FILE_INFO
      LOG(istring("reading tail of file failed: ") + full.raw());
#endif
      return false;  // failed to read.
    }
    curr_sum = utility::rolling_fletcher_checksum(curr_sum, chunk.observe(),
        chunk.length());
  }

  _checksum = curr_sum;
  return true;
}

void file_info::pack(byte_array &packed_form) const
{
  filename::pack(packed_form);
  basis::attach(packed_form, _file_size);
  basis::attach(packed_form, _checksum);
  _secondary->pack(packed_form);
  basis::attach(packed_form, *_attachment);
}

bool file_info::unpack(byte_array &packed_form)
{
  if (!filename::unpack(packed_form))
    return false;
  if (!basis::detach(packed_form, _file_size))
    return false;
  if (!basis::detach(packed_form, _checksum))
    return false;
  if (!_secondary->unpack(packed_form))
    return false;
  if (!basis::detach(packed_form, *_attachment))
    return false;
  return true;
}

file_info &file_info::operator = (const file_info &to_copy)
{
  if (this == &to_copy)
    return *this;
  (filename &)(*this) = (filename &)to_copy;
  *_attachment = *to_copy._attachment;
  _file_size = to_copy._file_size;
  *_secondary = *to_copy._secondary;
  _checksum = to_copy._checksum;
  return *this;
}


#endif //FILE_INFO_IMPLEMENTATION_FILE

---