D:/work/code_by/IOStream/InputStream.cpp

查看本檔案說明文件.

#include <string.h>
#include "InputStream.h"

TInputStream::TInputStream()
{
}

TInputStream::~TInputStream()
{
  Close();
}

void TInputStream::Close(void)
{
}

int TInputStream::Reads(void *dst, int size)
{
  int i, b;
  unsigned char *p;

  p = (unsigned char *)dst;
  for (i = 0; i < size; i++)
  {
    b = Read();
    if (b == -1)
      break;
    *(p++) = b;
  }
  return i;
}

void TInputStream::Reset(void)
{
}

TFileInputStream::TFileInputStream()
{
  cacheSize = 1024;
  cache = new unsigned char[cacheSize];
  fin = NULL;
  Reset();
}

TFileInputStream::TFileInputStream(int cs)
{
  cacheSize = cs <= 0? 1024 : cs;
  cache = new unsigned char[cacheSize];
  fin = NULL;
  Reset();
}

TFileInputStream::~TFileInputStream()
{
  Close();
  delete[] cache;
}

bool TFileInputStream::Open(char *fname)
{
  Close();

  fin = fopen(fname, "rb");
  Reset();
  return fin != NULL;
}

int TFileInputStream::Available(void)
{
  return available;
}

void TFileInputStream::Close(void)
{
  if (fin != NULL)
    fclose(fin);  //直接關閉
  fin = NULL;
  available = position = 0;
}

int TFileInputStream::Position(void)
{
  return position;
}

int TFileInputStream::Read(void)
{
  if (available == 0)
    return -1;

  ++position;
  --available;
  if (cacheIndex >= cacheDataSize)
  {
    cacheDataSize = fread(cache, sizeof(char), cacheSize, fin);
    cacheIndex = 0;
  }
  return cache[cacheIndex++];
}

void TFileInputStream::Reset(void)
{
  if (fin == NULL)
    available = 0;
  else
  {
    fseek(fin, 0, SEEK_END);
    available = ftell(fin);
    fseek(fin, 0, SEEK_SET);
  }
  position = 0;
  cacheIndex = cacheDataSize = 0;
}

int TFileInputStream::Skip(int size)
{
  if (fin == NULL || size < 0)
    return 0;

  if (size > available)
    size = available;
  if (size > cacheDataSize - cacheIndex)
  {
    fseek(fin, size - cacheDataSize + cacheIndex, SEEK_CUR);
    cacheDataSize = 0;
  }
  else
    cacheIndex += size;

  position += size;
  available -= size;
  return size;
}

TFilterInputStream::TFilterInputStream(TInputStream *Stream)
{
  In = Stream;
}

TFilterInputStream::~TFilterInputStream()
{
  Close();
}

int TFilterInputStream::Available(void)
{
  return In->Available();
}

void TFilterInputStream::Close(void)
{
  In->Close();
}

int TFilterInputStream::Position(void)
{
  return In->Position();
}

int TFilterInputStream::Read(void)
{
  return In->Read();
}

void TFilterInputStream::Reset(void)
{
  In->Reset();
}

int TFilterInputStream::Skip(int size)
{
  return In->Skip(size);
}

TDataInputStream::TDataInputStream(TInputStream *Stream) : TFilterInputStream(Stream)
{
}

TDataInputStream::~TDataInputStream()
{
}

char TDataInputStream::ReadChar(void)
{
  return Read();
}

float TDataInputStream::ReadFloat(void)
{
  float f;

  Reads(&f, sizeof(float));
  return f;
}

double TDataInputStream::ReadDouble(void)
{
  double d;

  Reads(&d, sizeof(double));
  return d;
}

int TDataInputStream::ReadInt(void)
{
  int n;

  Reads(&n, sizeof(int));
  return n;
}

int TDataInputStream::ReadLine(char *str, int size)
{
  int i, n;

  i = 0;
  while (size-- > 0)
  {
    n = Read();
    if (n == -1 || n == 0x0A)
      break;
    if (n != 0x0D)
      str[i++] = n;
  }
  str[i] = '\0';

  return i;
}

TCipherInputStream::TCipherInputStream(TInputStream *Stream) : TFilterInputStream(Stream)
{
  key = NULL;
  SetKey(NULL);
}

TCipherInputStream::~TCipherInputStream()
{
  delete[] key;
}

void TCipherInputStream::SetKey(char *k)
{
  delete[] key;

  if (k == NULL)
  {
    key = NULL;
    keySize = 0;
    return;
  }
  keySize = strlen(k);
  key = new char[keySize + 1];
  strcpy(key, k);
  index = 0;
}

int TCipherInputStream::Read(void)
{
  int n;

  n = TFilterInputStream::Read();
  if (keySize != 0)
  {
    n ^= key[index];
    index = (index + 1) % keySize;
  }
  return n;
}

void TCipherInputStream::Reset(void)
{
  TFilterInputStream::Reset();
  index = 0;
}

int TCipherInputStream::Skip(int size)
{
  if (size < 0)
    return 0;

  size = TFilterInputStream::Skip(size);
  if (keySize != 0)
    index = (index + size) % keySize;

  return size;
}

---