binarystream.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "binarystream.h"   // include first

#include <algorithm>    // std::min<>()

using namespace sheep;
using namespace std;

//! Default buffer size, in bytes.
const int DEFAULT_BUFFER_SIZE = 65536;

BinaryStream::BinaryStream() {
    initialize();
}

BinaryStream::BinaryStream(const std::string &filename,
                           StreamMode mode,
                           Endianness endianness /*= NativeEndian*/)
{
    initialize();
    Open(filename, mode, endianness);
}

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

void BinaryStream::Open(const std::string &filename,
                        StreamMode mode,
                        Endianness endianness /*= NativeEndian*/)
{
    assert(m_file == 0);

    m_mode = mode;

    if(mode == InputStream)
        m_file = fopen(filename.c_str(), "rb");
    else m_file = fopen(filename.c_str(), "wb");

    SetEndianness(endianness);
    SetBufferSize(DEFAULT_BUFFER_SIZE);
}

void BinaryStream::Close() throw(WriteException) {
    if(m_file) {
        if(m_mode == OutputStream)
            flush_output_buffer();

        fclose(m_file);
        m_file = 0;

        delete m_buffer_base;
        m_buffer_base = 0;
    }
}

bool BinaryStream::IsOpen() const {
    return m_file != 0;
}

void BinaryStream::SetBufferSize(int size) {
    assert(size > 0);

    delete m_buffer_base;

    m_buffer_base = new char[size];

    if(m_mode == InputStream)
        m_buffer_end = m_buffer_base;
    else m_buffer_end = m_buffer_base + size;

    m_buffer_ptr = m_buffer_base;
    m_buffer_size = size;
}

void BinaryStream::SetEndianness(Endianness endianness) {
    if(endianness == NativeEndian)
        m_swap = false;
    else m_swap = (endianness != get_host_endianness());
}

void BinaryStream::Seek(long offset, SeekOrigin origin) throw(SeekException) {
    assert(m_file);
    assert(m_mode == InputStream);
    assert(m_buffer_base);

    switch(origin) {
    case SeekFromBeginning:
        fseek(m_file, offset, SEEK_SET);
        break;
    case SeekFromCurrent:
        fseek(m_file, offset, SEEK_CUR);
        break;
    case SeekFromEnd:
        fseek(m_file, offset, SEEK_END);
        break;
    }

    if(ferror(m_file))
        throw SeekException();

    invalidate_input_buffer();
}

long BinaryStream::Tell() const throw(SeekException) {
    assert(m_file);

    const long position = ftell(m_file);

    if(ferror(m_file))
        throw SeekException();

    return position;
}

void BinaryStream::Write(const void *data, size_t size) throw(WriteException) {
    assert(m_file);
    assert(m_mode == OutputStream);
    assert(m_buffer_base);

    assert(data);
    assert(size >= 0);

    const char *data_ptr = static_cast<const char *>(data);

    while(size > 0) {
        // Calculate space available in the output buffer.
        const size_t room = m_buffer_end - m_buffer_ptr;
        assert(room >= 0);

        // Flush the output buffer if full.
        if(room == 0)
            flush_output_buffer();

        // Compute the amount of data to copy.
        const size_t block_size = min(size, room);
        assert(block_size > 0);

        // Append data to the output buffer.
        memcpy(m_buffer_ptr, data_ptr, block_size);

        // Advance source and destination pointers.
        data_ptr += block_size;
        m_buffer_ptr += block_size;

        // Compute the amount of data that remains to copy.
        size -= block_size;
    }
}

void BinaryStream::Read(void *data, size_t size) throw(ReadException) {
    assert(m_file);
    assert(m_mode == InputStream);
    assert(m_buffer_base);

    assert(data);
    assert(size >= 0);

    char *data_ptr = static_cast<char *>(data);

    while(size > 0) {
        // Compute the amount of data available in the input buffer.
        size_t remaining = m_buffer_end - m_buffer_ptr;
        assert(remaining >= 0);

        // Fill the input buffer if empty.
        if(remaining == 0) {
            remaining = fill_input_buffer();

            // Error: no more data.
            if(remaining == 0)
                throw ReadException();
        }

        // Compute the amount of data to copy.
        const size_t block_size = min(size, remaining);
        assert(block_size > 0);

        // Copy data from buffer.
        memcpy(data_ptr, m_buffer_ptr, block_size);

        // Advance source and destination pointers.
        data_ptr += block_size;
        m_buffer_ptr += block_size;

        // Compute the amount of data that remains to copy.
        size -= block_size;
    }
}

BinaryStream::Endianness BinaryStream::get_host_endianness() const {
    const long x = 1;
    const char *p = reinterpret_cast<const char *>(&x);

    return *p ? LittleEndian : BigEndian;
}

void BinaryStream::initialize() {
    m_file = 0;
    m_mode = InputStream;   // arbitrary
    m_swap = false;
    m_buffer_base = m_buffer_end = 0;
    m_buffer_ptr = 0;
    m_buffer_size = 0;
}

void BinaryStream::flush_output_buffer() throw(WriteException) {
    assert(m_file);
    assert(m_mode == OutputStream);
    assert(m_buffer_base);

    const size_t block_size = m_buffer_ptr - m_buffer_base;
    assert(block_size >= 0);

    const size_t written =
        fwrite(m_buffer_base, 1, block_size, m_file);

    if(written < block_size || ferror(m_file))
        throw WriteException();

    m_buffer_ptr = m_buffer_base;
}

size_t BinaryStream::fill_input_buffer() throw(ReadException) {
    assert(m_file);
    assert(m_mode == InputStream);
    assert(m_buffer_base);

    const size_t read =
        fread(m_buffer_base, 1, m_buffer_size, m_file);

    if(ferror(m_file))
        throw ReadException();

    m_buffer_ptr = m_buffer_base;
    m_buffer_end = m_buffer_base + read;

    return read;
}

void BinaryStream::invalidate_input_buffer() {
    m_buffer_end = m_buffer_base;
}

---