filetime.cpp

Go to the documentation of this file.

#ifndef FILETIME_IMPLEMENTATION_FILE
#define FILETIME_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : file_time                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$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 "filetime.h"

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

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

file_time::file_time(FILE *the_file)
: _when(0)
{ reset(the_file); }

file_time::file_time(const time_t &t)
: _when(t)
{}

file_time::file_time(const istring &filename)
: _when(0)
{
  FILE *ptr = fopen(filename.s(), "r");
  if (ptr) {
    reset(ptr);
    fclose(ptr);
  }
}

file_time::~file_time() {}

void file_time::reset(const time_t &t) { _when = t; }

void file_time::reset(const istring &filename)
{
  FILE *ptr = fopen(filename.s(), "r");
  if (ptr) {
    reset(ptr);
    fclose(ptr);
  }
}

void file_time::reset(FILE *the_file)
{
  FUNCDEF("reset");
  _when = 0;
  if (!the_file) {
    return;
  }
  struct stat stat_buffer;
  if (fstat(fileno(the_file), &stat_buffer) < 0) {
    LOG("stat failure on file");
  }
  _when = stat_buffer.st_mtime;
}

int file_time::compare(const file_time &b) const
{
  if (_when > b._when) return 1;
  else if (_when == b._when) return 0;
  else return -1;
}

bool file_time::operator < (const file_time &ft2) const
{ return bool(compare(ft2) < 0); }

bool file_time::operator > (const file_time &ft2) const
{ return bool(compare(ft2) > 0); }

bool file_time::operator <= (const file_time &ft2) const
{ return bool(compare(ft2) <= 0); }

bool file_time::operator >= (const file_time &ft2) const
{ return bool(compare(ft2) >= 0); }

bool file_time::operator != (const file_time &ft2) const
{ return bool(compare(ft2) != 0); }

bool file_time::operator == (const file_time &ft2) const
{ return bool(compare(ft2) == 0); }

// we are picking a constant sized 8 bytes regardless of the real size
// of the time_t.  this will hopefully be larger than the required size
// for a really long time.
void file_time::pack(byte_array &packed_form) const
{
//printf("pack, time curr = %ld\r\n", _when);

  byte_array to_add;
  time_t temp = _when;
  // pack in the part that's actually used, pushing to the right from posn 0.
  for (int i = 0; i < int(sizeof(time_t)); i++) {
    byte current = byte(temp % 256);
    temp /= 256;
    to_add.insert(0, 1);
    to_add[0] = current;
  }
  // pack extra bytes in for what's not used.
  for (int i = sizeof(time_t); i < 8; i++) {
    to_add.insert(0, 1);
    to_add[0] = 0;
  }
  packed_form += to_add;


//istring to_print;
//byte_format::text_dump(to_print, packed_form);
//printf("filetime pack\r\n%s", to_print.s());


}

bool file_time::unpack(byte_array &packed_form)
{

//istring to_print;
//byte_format::text_dump(to_print, packed_form);
//printf("filetime unpack\r\n%s", to_print.s());

  if (packed_form.length() < 8) return false;
  time_t temp = 0;
  int unused = 8 - sizeof(time_t);
  packed_form.zap(0, unused - 1);
  for (int i = 0; i < packed_form.length(); i++) {
//printf("current byte = %d\r\n", byte(packed_form[i]));
    temp *= 256;  // rotate up what's already stored.
    temp += packed_form[i];
  }
  // toss out the rest of the portion we've consumed.
  packed_form.zap(0, sizeof(time_t));
  _when = temp;

//printf("unpack, time curr = %ld\r\n", _when);

  return true;
}


#endif //FILETIME_IMPLEMENTATION_FILE

---