utility.cpp

Go to the documentation of this file.

#ifndef UTILITY_IMPLEMENTATION_FILE
#define UTILITY_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : utility group                                                     *
*  Authors: 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 "earth_time.h"
#include "istring.h"
#include "utility.h"

#include <stdlib.h>

//#define DEBUG_UTILITY
  // uncomment this macro to cause more debugging checks and verbosity.

const int HIGHEST_MOD_VALUE = 32014;

unsigned int utility::bizarre_checksum(const byte *data, int length)
{
  int sum = 0;
  for (int i = 0; i < length; i++) sum += data[i] % 23 + i % 9;
  sum = (sum % (HIGHEST_MOD_VALUE - 1)) + 1;
  return (unsigned int)sum;
}

// fletcher checksum is from Dr. Dobbs Journal May 1992, pp. 32-38.

uint16 utility::fletcher_checksum(const byte *data, int length)
{
  int sum1 = 0;
  u_int sum2 = 0;
  const byte *buffer = data;

  while (length--) {
    sum1 += int(*buffer++);
    // check for overflow into high byte.
    if (sum1 > 255) sum1++;
    sum1 &= 0xFF;  // remove any bits in high byte for next sum.
    sum2 += u_int(sum1);
  }
  if (sum1 == 255) sum1 = 0;
  unsigned int fletch = u_int(sum2 & 0xFF);
  fletch <<= 8;
  fletch |= u_int(sum1 & 0xFF);

  return uint16(fletch);
}

uint16 utility::rolling_fletcher_checksum(uint16 previous, const byte *data,
    int len)
{ return previous ^ fletcher_checksum(data, len); }

byte utility::byte_checksum(const byte *data, int length)
{
  byte to_return = 0;
  for (int i = 0; i < length; i++) to_return += byte(data[i]);
  return to_return;
}

u_int utility::short_checksum(const byte *data, int length)
{
  u_int to_return = 0;
  for (int i = 0; i < length; i++) to_return += data[i];
  return to_return;
}

istring timestamp(bool add_space, bool add_date)
{ return utility::timestamp(add_space, add_date); }

istring utility::timestamp(bool add_space, bool add_date)
{
  using namespace earth_time;
  const time_locus the_time = now();
  istring to_return;
  if (add_date)
    the_time.text_form(to_return,
        clock_time::MILITARY | clock_time::MILLISECONDS);
  else
    the_time.clock_time::text_form(to_return, clock_time::MILITARY
        | clock_time::MILLISECONDS);
  if (add_space)
    to_return += " ";
  return to_return;
}

u_int utility::hash_bytes(const void *key_data, int key_length)
{
  if (!key_data) return 0;  // error!
  if (!key_length) return 0;  // ditto!

  byte *our_key = (byte *)key_data;
  byte hashed[4] = { 0, 0, 0, 0 };

  int fill_posn = 0;
  for (int i = 0; i < key_length; i++) {
    // add to the primary area.
    hashed[fill_posn] = hashed[fill_posn] + our_key[i];
    fill_posn++;
    if (fill_posn >= 4) fill_posn = 0;
    // add to the secondary area (the next in rotation after primary).
    hashed[fill_posn] = hashed[fill_posn] + (our_key[i] / 4);
  }

  u_int to_return = 0;
  for (int j = 0; j < 4; j++) to_return = (to_return << 8) + hashed[j];
  return to_return;
}


#endif //UTILITY_IMPLEMENTATION_FILE

---