binarystream.h

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
*/

#ifndef SHEEP_MISC_BINARYSTREAM_H
#define SHEEP_MISC_BINARYSTREAM_H

#include "config.h"

#include <algorithm>    // std::reverse<>()
#include <cassert>
#include <cstddef>
#include <cstdio>
#include <string>

namespace sheep {

    class BinaryStream {
    public:
        struct BaseException {};
        struct ReadException : public BaseException {};
        struct WriteException : public BaseException {};
        struct SeekException : public BaseException {};

        enum StreamMode {
            InputStream,
            OutputStream
        };

        enum Endianness {
            NativeEndian,
            LittleEndian,
            BigEndian
        };

        BinaryStream();
        BinaryStream(
            const std::string &filename,
            StreamMode mode,
            Endianness endianness = NativeEndian
        );

        ~BinaryStream();

        void Open(
            const std::string &filename,
            StreamMode mode,
            Endianness endianness = NativeEndian
        );

        void Close()
            throw(WriteException);

        bool IsOpen() const;

        //! Sets the I/O buffer size. 'size' is expressed in bytes.
        //! The smallest value for 'size' is 1. This method must be
        //! called before using the stream.
        void SetBufferSize(int size);

        void SetEndianness(Endianness endianness);

        enum SeekOrigin {
            SeekFromBeginning,
            SeekFromCurrent,
            SeekFromEnd
        };

        void Seek(long offset, SeekOrigin origin)
            throw(SeekException);

        long Tell() const
            throw(SeekException);

        //! Writes a sequence of contiguous bytes to the stream.
        //! No byte reordering is performed.
        void Write(const void *data, size_t size)
            throw(WriteException);

        //! Reads a sequence of contiguous bytes from the stream.
        //! No byte reordering is performed.
        void Read(void *data, size_t size)
            throw(ReadException);

        template<typename T>
        void Write(T t)
            throw(WriteException);

        template<typename T>
        void Read(T *t)
            throw(ReadException);

    private:
        FILE *m_file;           //!< The file to which is binded the stream.
        StreamMode m_mode;      //!< Stream mode (input or output).
        bool m_swap;            //!< True if bytes must be swapped (if host and target endianness differ).
        char *m_buffer_base;    //!< Base address of the buffer.
        char *m_buffer_end;     //!< In InputStream mode: one byte past the end of the data. In OutputStream mode: one byte past the end of the buffer.
        char *m_buffer_ptr;     //!< Current location in the buffer (points to the next byte to read/write).
        int m_buffer_size;      //!< Total size of the buffer.

        Endianness get_host_endianness() const;

        void initialize();

        void flush_output_buffer()
            throw(WriteException);

        size_t fill_input_buffer()
            throw(ReadException);

        void invalidate_input_buffer();

        //! Byte swapping function.
        template<typename T>
        void swap_bytes(T *t) const;
    };

#include "binarystream.inl"

}

#endif  // !SHEEP_MISC_BINARYSTREAM_H

---