binaryFile.cpp

//
// Copyright (c) Singular Inversions Inc. 2000
//
// Authors:             Andrew Beatty
// Created:     Sept. 4, 2000
//
 
#include "stdafx.h"
 
#include "binaryFile.hpp"
#include "FgFile.hpp"
#include "FgSerial.hpp"
 
using namespace std;
 
namespace Fg {
 
FutBinaryFileC::FutBinaryFileC(
        string                      a_fileId)
{
        fileId = a_fileId;
        FGASSERT(fileId.size() == 8);
        fptr = NULL;
    fileId[5] = '0';    // No encryption
}
 
// Shouldn't use this function if file is already openned.
void
FutBinaryFileC::changeFileId(string const &newFileId)
{
    FGASSERT(newFileId.size() == 8);
    FGASSERT(fptr == NULL);
 
    fileId = newFileId;
    fileId[5] = '0';
}
 
// Note that this function closes the file and reports an error if the file ID
// does not agree.
bool
FutBinaryFileC::openForRead(
        String8 const &    a_fname)
{
        close();                                                // Ensure any previous are closed.
 
        fptr = openFile(a_fname,false);
        if (fptr == NULL)
        fgThrow("Unable to read-open binary file",a_fname);
 
        vector<char>    buff(fileId.size()+1);
        
    if (!readHeader(&buff[0],static_cast<uint>(fileId.size()),1))
        return false;
 
    vector<char>    buff2 = buff;
    buff2[5] = fileId[5];
 
        if (fileId != &buff2[0])
        {
                close();
                fgThrow("Incorrect file type",a_fname);
        }
 
    if (buff[5] > '0' && fileId[5] != buff[5])
    {
        close();
        fgThrow("Incorrect file type",a_fname);
    }
    fileId[5] = buff[5];
 
        m_fname = a_fname;
        return true;
}
 
// Return false if error.
bool
FutBinaryFileC::openForOverwrite(
        String8 const & a_fname)
{
        close();                                                // Ensure any previous are closed.
 
        fptr = openFile(a_fname,true);
        if (fptr == NULL)
        fgThrow("Unable to write-open file",a_fname);
 
    // Save file id. (No encryption for writing fileID).
        if (!writeHeader(fileId.c_str(),static_cast<uint>(fileId.size()),1))
        {
                close();
                fgThrow("Unable to write to file",a_fname);
        }
 
        m_fname = a_fname;                              // Save name for error reporting.
        return true;
}
 
bool
FutBinaryFileC::writeHeader(const void *data, uint size, uint num)
{
        if (fptr == NULL) return false;         // This way the client doesn't have
                                                                                // to check for an error after every
                                                                                // single write - can just check at the
                                                                                // end.
        if (fwrite(data,size,num,fptr) != num)
        {
                close();
                fgThrow("Unable to write header data to file");
        }
 
        return true;
}
 
bool
FutBinaryFileC::readHeader(void *data, uint size, uint num)
{
        if (fptr == NULL) return false;
        if (fread(data,size,num,fptr) != num)
        {
                close();
                fgThrow("Unable to read header data from file");
        }
        return true;
}
 
// This function just calls writeHeader().  It is defined as a separate
// function so that it can be overided by derived classes.
bool
FutBinaryFileC::write(
        const void      *data,                                  // Pointer to data
        uint            size,                                   // size of each item
        uint            num)                                    // number of data items in sequence
{
    return writeHeader(data,size,num);
}
 
// This function just calls readHeader().  It is defined as a separate
// function so that it can be overided by derived classes.
bool
FutBinaryFileC::read(
                         
        void            *data,                                  // Pointer to data
        uint            size,                                   // size of each item
        uint            num)                                    // number of data items in sequence
{
        return readHeader(data,size,num);
}
 
 
// Moves current file pointer to a specified offset location from the 
// beginning of file.
// Returns true if successful.
bool
FutBinaryFileC::seek(long offsetFromBeginning)
{
        if (fptr == NULL) return false;
    if (fseek(fptr,offsetFromBeginning,SEEK_SET))
    {
        close();
        fgThrow("Unable to seek-read from file");
    }
    return true;
}
 
void
FutBinaryFileC::close()
{
        if (fptr != NULL)
                fclose(fptr);
 
        m_fname = "";
        fptr = NULL;
}
 
bool
FutBinaryFileC::eof()
{
    FGASSERT(fptr != NULL);
    long    pos = ftell(fptr);
    bool    ret = (getc(fptr) == EOF) ? true : false;
    fseek(fptr,pos,0);
    return ret;
}
 
}