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

查看本檔案說明文件.

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

TOutputStream::TOutputStream()
{
}

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

void TOutputStream::Close(void)
{
  Flush();
}

void TOutputStream::Flush(void)
{
}

void TOutputStream::Writes(void *src, int size)
{
  unsigned char *p;
  int i;

  p = (unsigned char *)src;
  for (i = 0; i < size; i++)
    Write(p[i]);
}

TFileOutputStream::TFileOutputStream()
{
  cacheSize = 1024;
  cache = new unsigned char[cacheSize];
  cacheDataSize = 0;
  fout = NULL;
}

TFileOutputStream::TFileOutputStream(int cs)
{
  cacheSize = cs <= 0? 1024 : cs;
  cache = new unsigned char[cacheSize];
  cacheDataSize = 0;
  fout = NULL;
}

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

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

  fout = fopen(fname, "wb");
  return fout != NULL;
}

void TFileOutputStream::Close(void)
{
  if (fout != NULL)
  {
    FlushCache();
    fclose(fout);
    fout = NULL;
  }
}

void TFileOutputStream::Flush(void)
{
  if (fout != NULL)
  {
    FlushCache();
    fflush(fout);
  }
}

int TFileOutputStream::Size(void)
{
  return fout == NULL? 0 : ftell(fout) + cacheDataSize;
}

void TFileOutputStream::Write(int n)
{
  if (fout != NULL)
  {
    cache[cacheDataSize++] = n;
    if (cacheDataSize >= cacheSize)
      FlushCache();
  }
}

void TFileOutputStream::FlushCache(void)
{
  fwrite(cache, sizeof(char), cacheDataSize, fout);
  cacheDataSize = 0;
}

TFilterOutputStream::TFilterOutputStream(TOutputStream *Stream)
{
  Out = Stream;
}

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

void TFilterOutputStream::Close(void)
{
  Out->Close();
}

void TFilterOutputStream::Flush(void)
{
  Out->Flush();
}

int TFilterOutputStream::Size(void)
{
  return Out->Size();
}

void TFilterOutputStream::Write(int n)
{
  Out->Write(n);
}

TDataOutputStream::TDataOutputStream(TOutputStream *Stream) : TFilterOutputStream(Stream)
{
}

TDataOutputStream::~TDataOutputStream()
{
}

void TDataOutputStream::WriteChar(char c)
{
  Writes(&c, sizeof(char));
}

void TDataOutputStream::WriteDouble(double d)
{
  Writes(&d, sizeof(double));
}

void TDataOutputStream::WriteFloat(float f)
{
  Writes(&f, sizeof(float));
}

void TDataOutputStream::WriteInt(int n)
{
  Writes(&n, sizeof(int));
}

void TDataOutputStream::WriteString(char *str)
{
  Writes(str, strlen(str));
}

TCipherOutputStream::TCipherOutputStream(TOutputStream *Stream) : TFilterOutputStream(Stream)
{
  key = NULL;
  SetKey(NULL);
}

TCipherOutputStream::~TCipherOutputStream()
{
  delete[] key;
}
void TCipherOutputStream::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;
}
void TCipherOutputStream::Write(int n)
{
  if (keySize != 0)
  {
    n ^= key[index];
    index = (index + 1) % keySize;
  }
  TFilterOutputStream::Write(n);
}

---