stream.h

Go to the documentation of this file.

/*
    Ishtar - A network transparent read/write interface with
    probing and enumeration support.
    network part : convenient cross-platform packaging for tcp/ip networking
    Copyright (C) 2003-2005 Stephane Magnenat <nct@ysagoon.com>

    This program 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.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __ISHTAR_STREAM_H
#define __ISHTAR_STREAM_H

#include <algorithm>


namespace Ishtar
{
    typedef signed char Int8;
    typedef unsigned char UInt8;
    typedef signed short Int16;
    typedef unsigned short UInt16;
    typedef signed int Int32;
    typedef unsigned int UInt32;
    typedef size_t Size;
    
    struct EndianDiscoverer
    {
        bool isLittleEndian;
        bool isInvertedDouble;
        
        EndianDiscoverer();
    };
    
    extern EndianDiscoverer endianDiscoverer;
    
    template<typename T> void swapBytesIfRequired(T &v)
    {
        // we save files in little endian as most user architecture are little endian
        if (!endianDiscoverer.isLittleEndian)
        {
            UInt8 *data = reinterpret_cast<UInt8 *>(&v);
            Size size = sizeof(T);
            for(Size p = 0; p < (size>>1); p++)
                std::swap(data[p], data[size-1-p]);
        }
    }
    
    // Endian safe read and write
    // ==========================
    
    class OutputStream
    {
    public:
        virtual ~OutputStream() { }
    
        virtual void write(const void *data, const Size size) = 0;
    
        virtual void flush(void) = 0;
    
        template<typename T> void writeEndianIndependant(const T &v)
        {
            T swapedValue = v;
            swapBytesIfRequired(swapedValue);
            write(&swapedValue, sizeof(T));
        }
    
        inline void writeInt8(const Int8 v) { this->write(&v, 1); }
        inline void writeUInt8(const UInt8 v) { this->write(&v, 1); }
        inline void writeInt16(const Int16 v) { this->writeEndianIndependant(v); }
        inline void writeUInt16(const UInt16 v) { this->writeEndianIndependant(v); }
        inline void writeInt32(const Int32 v) { this->writeEndianIndependant(v); }
        inline void writeUInt32(const UInt32 v) { this->writeEndianIndependant(v); }
        inline void writeFloat(const float v) { this->writeEndianIndependant(v); }
        inline void writeDouble(const double v)
        {
            double value = v;
            // arm inverted double forces us to do this
            if (endianDiscoverer.isInvertedDouble)
            {
                UInt32 *ptr = reinterpret_cast<UInt32 *>(&value);
                UInt32 tempValue = *ptr;
                *ptr = *(ptr+1);
                *(ptr+1) = tempValue;
            }
            this->writeEndianIndependant(value);
        }
    };
    
    class InputStream
    {
    public:
        virtual ~InputStream() { }
    
        virtual void read(void *data, Size size) = 0;
    
        template<typename T> T readEndianIndependant()
        {
            T v;
            read(&v, sizeof(T));
            swapBytesIfRequired(v);
            return v;
        }
    
        inline Int8 readInt8(void) { Int8 i; this->read(&i, 1); return i; }
        inline UInt8 readUInt8(void) { UInt8 i; this->read(&i, 1); return i; }
        inline Int16 readInt16(void) { return this->readEndianIndependant<Int16>(); }
        inline UInt16 readUInt16(void) { return this->readEndianIndependant<UInt16>(); }
        inline Int32 readInt32(void) { return this->readEndianIndependant<Int32>(); }
        inline UInt32 readUInt32(void) { return this->readEndianIndependant<UInt32>(); }
        inline float readFloat(void) { return this->readEndianIndependant<float>(); }
        inline double readDouble(void)
        {
            double value = this->readEndianIndependant<double>();
            // arm inverted double forces us to do this
            if (endianDiscoverer.isInvertedDouble)
            {
                UInt32 *ptr = reinterpret_cast<UInt32 *>(&value);
                UInt32 tempValue = *ptr;
                *ptr = *(ptr+1);
                *(ptr+1) = tempValue;
            }
            return value;
        }
    };
}

#endif

---