IFStreamBinary.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
//- retains certain rights in this software.
//- 
//- BSD Open Source License.
//- All rights reserved.
//- 
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-    * Neither the name of Sandia National Laboratories nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//- 
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef IFSTREAMBINARY_OBJECT_H
#define IFSTREAMBINARY_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <cstring>
#include <fstream>
#include <vector>
#include <sstream>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "CPPUtils.h"
#include "GeoTessUtils.h"
#include "GeoTessException.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP IFStreamBinary
{
  protected:
 
        string*                 bData;
 
        int                         bDataPos;
 
        int                         bSize;
 
        bool                        bAlign;
 
        bool                        bReverse;
 
        bool                        bOwnStr;
 
        string                  bFileName;
 
        int                         bMemIncr;
 
    void                        align2Byte()
        {
            int sm = bDataPos % CPPUtils::SSHT;
            if (sm && bAlign) bDataPos += CPPUtils::SSHT - sm;
        }
 
    void                        align4Byte()
        {
            int sm = bDataPos % CPPUtils::SINT;
            if (sm && bAlign) bDataPos += CPPUtils::SINT - sm;
        }
 
    void                        align8Byte()
        {
            int sm = bDataPos % CPPUtils::SDBL;
            if (sm && bAlign) bDataPos += CPPUtils::SDBL - sm;
        }
 
    void                        checkBufferSize(int sincr)
        {
            if (bDataPos + sincr > (int) bData->size())
            {
                if (sincr + bData->size() > bData->capacity())
                    bData->reserve(bData->capacity() + bMemIncr);
                bData->append(bDataPos + sincr - bData->size(), ' ');
            }
        }
 
        /*
         * Reverses each s-byte element of array a containing n elements
         * (s*n bytes). The element size s must be 2, 4, or 8.
         */
        static void         reverseBOArray(int n, char* a, int s);
 
        /*
         * Reverses the byte order of each element of a where a is an array of n
         * 2, 4, or 8 byte elements. Used to convert between big-and
         * little-endian formats.
         */
        static void         reverseBO2Array(int n, char* a);
        static void         reverseBO4Array(int n, char* a);
        static void         reverseBO8Array(int n, char* a);
 
        /*
         * Reverses the byte order of d, where d is a 2, 4, or 8 byte array. Used
         * to convert between big-and little-endian formats.
         */
        static void         reverseBO2(char* d);
        static void         reverseBO4(char* d);
        static void         reverseBO8(char* d);
 
    public:
 
                                        IFStreamBinary();
 
                                        IFStreamBinary(bool align);
 
                                        IFStreamBinary(const string& filename);
 
                                        IFStreamBinary(const string& filename, int num_bytes);
 
                                        IFStreamBinary(string* str);
 
                                        IFStreamBinary(const IFStreamBinary& db);
 
        virtual                 ~IFStreamBinary();
 
        IFStreamBinary& operator=(const IFStreamBinary& db);
 
        void                        dumpBuffer();
 
        static bool         exists(const string& filename);
 
        void                        writeToFile(const string& filename);
 
        void                        writeToFile(ofstream& ofs);
 
        void                        readFromFile(const string& filename);
 
        void                        readFromFile(const string& filename, int num_bytes);
 
//      void                        readFromFile(ifstream& ifs, streampos file_pos,
//                                                                  int num_bytes);
 
        void                        readFromFile(ifstream& ifs, int num_bytes);
 
        const string&       getFileName() const { return bFileName; }
 
        void                        clear()
        {
            (*bData) = "";
            bDataPos = 0;
            bSize = 0;
        }
 
        void                        setMemoryCapacityIncrement(int mci)
        {
            if (mci > 0) bMemIncr = mci;
        }
 
        string                  readString();
        void                        readString(string& s);
        void                        readCharArray(string& s, int num_chars);
        void                        readCharArray(char* array, int num_chars);
        void                        readType(string& s);
        void                        readTypeArray(string& array, int num_chars);
 
        bool                        readBool();
        bool                        readBool(int pos);
        void                        readBoolArray(bool* array, int num_bools);
        void                        readType(bool& b);
        void                        readTypeArray(bool* array, int num_bools);
 
        byte                        readByte();
        byte                        readByte(int pos);
        void                        readByteArray(byte* array, int num_bs);
        void                        readType(byte& b);
        void                        readTypeArray(byte* array, int num_bs);
 
        short                       readShort();
        short                       readShortNC();
        short                       readShort(int pos);
        void                        readShortArray(short* array, int num_shorts);
        void                        readType(short& s);
        void                        readTypeArray(short* array, int num_shorts);
 
        int                         readInt();
        int                         readIntNC();
        int                         readInt(int pos);
        void                        readIntArray(int* array, int num_ints);
        void                        readType(int& i);
        void                        readTypeArray(int* array, int num_ints);
 
        LONG_INT                        readLong();
        LONG_INT                        readLongNC();
        LONG_INT                        readLong(int pos);
        void                        readLongArray(LONG_INT* array, int num_longs);
        void                        readType(LONG_INT& l);
        void                        readTypeArray(LONG_INT* array, int num_longs);
 
        float                       readFloat();
        float                       readFloatNC();
        float                       readFloat(int pos);
        void                        readFloatArray(float* array, int num_floats);
        void                        readType(float& f);
        void                        readTypeArray(float* array, int num_floats);
 
        double                  readDouble();
        double                  readDoubleNC();
        double                  readDouble(int pos);
        void                        readDoubleArray(double* array, int num_doubles);
        void                        readType(double& d);
        void                        readTypeArray(double* array, int num_doubles);
 
        void                        writeString(const string& str);
        void                        writeString(const char* char_string);
        void                        writeCharArray(const char* array, int num_chars);
        void            writeType(const string& str);
        void                        writeType(const char* char_string);
 
        void                        writeBool(bool b);
        void                        writeBoolNC(bool b);
        void                        writeBool(bool b, int pos);
        void                        writeBoolArray(const bool* array, int num_bools);
        void                        writeType(bool b);
        void                        writeTypeArray(const bool* array, int num_bools);
 
        void                        writeByte(byte b);
        void                        writeByteNC(byte b);
        void                        writeByte(byte b, int pos);
        void                        writeByteArray(const byte* array, int num_bytes);
        void                        writeType(byte b);
        void                        writeTypeArray(const byte* array, int num_bytes);
 
        void                        writeShort(short i);
        void                        writeShortNC(short i);
        void                        writeShort(short i, int pos);
        void                        writeShortArray(const short* array, int num_ints);
        void                        writeType(short i);
        void                        writeTypeArray(const short* array, int num_ints);
 
        void                        writeInt(int i);
        void                        writeIntNC(int i);
        void                        writeInt(int i, int pos);
        void                        writeIntArray(const int* array, int num_ints);
        void                        writeType(int i);
        void                        writeTypeArray(const int* array, int num_ints);
 
        void                        writeLong(LONG_INT l);
        void                        writeLongNC(LONG_INT l);
        void                        writeLong(LONG_INT l, int pos);
        void                        writeLongArray(const LONG_INT* array, int num_longs);
        void                        writeType(LONG_INT l);
        void                        writeTypeArray(const LONG_INT* array, int num_longs);
 
        void                        writeFloat(float f);
        void                        writeFloatNC(float f);
        void                        writeFloat(float f, int pos);
        void                        writeFloatArray(const float* array, int num_floats);
        void                        writeType(float f);
        void                        writeTypeArray(const float* array, int num_floats);
 
        void                        writeDouble(double d);
        void                        writeDoubleNC(double d);
        void                        writeDouble(double d, int pos);
        void                        writeDoubleArray(const double* array, int num_doubles);
        void                        writeType(double d);
        void                        writeTypeArray(const double* array, int num_doubles);
 
        /*
         * Return class name.
         */
        static string       className()
        { return "IFStreamBinary"; }
 
        /*
         * Return class size.
         */
        static int          classSize()
        { return (int) sizeof(IFStreamBinary); }
 
        void                        reSize(int spc)
        { bData->resize(spc); }
 
        void                        reserve(int sze)
        { bData->reserve(sze); }
 
        int                         size()
        {
            if (bDataPos > bSize) bSize = bDataPos;
            return bSize;
        }
 
        void                        resetPos()
        {
            if (bDataPos > bSize) bSize = bDataPos;
            bDataPos = 0;
        }
 
        void                        setPosToEnd()
        {
            if (bDataPos > bSize) bSize = bDataPos;
            bDataPos = bSize;
        }
 
        int                         getPos() const
        { return bDataPos; }
 
        void                        incrementPos(int increment = 1)
        { bDataPos += increment; }
 
        void                        decrementPos(int decrement = 1)
        { bDataPos -= decrement; }
 
        const string&       getData() const
        {   return *bData; }
 
        int                         getCapacity() const
        { return (int) bData->capacity(); }
 
        char*                       getPosPointer()
        {   return getPosPointer(bDataPos); }
 
        char*                       getPosPointer(int pos)
        {
            char* p = &(*bData)[pos];
            return p;
        }
 
        void                        setByteOrderReverse(bool bor)
        { bReverse = bor; }
 
        void                        byteOrderReverseOn()
        { bReverse = true; }
 
        void                        byteOrderReverseOff()
        { bReverse = false; }
 
        bool                        isByteOrderReversalOn() const
        { return bReverse; }
 
        void                        setBoundaryAlignment(bool align)
        { bAlign = align; }
 
        void                        boundaryAlignmentOn()
        { bAlign = true; }
 
        void                        boundaryAlignmentOff()
        { bAlign = false; }
 
        bool                        isBoundaryAlignmentOn() const
        { return bAlign; }
 
}; // end class IFStreamBinary
 
//************* Read Strings **************************************************
 
inline string IFStreamBinary::readString()
{
  string s;
  readString(s);
  return s;
}
 
inline void IFStreamBinary::readString(string& s)
{
  int len;
  // check for zero added by sballar 2013-01-04
  len = readInt();
  if (len == 0)
      s="";
  else
  {
      // read the data
      s = bData->substr(bDataPos, len);
      bDataPos += len;
  }
}
 
inline void IFStreamBinary::readCharArray(string& s, int num_chars)
{
    s.resize(num_chars);
    readCharArray(&s[0], num_chars);
}
 
inline void IFStreamBinary::readCharArray(char* array, int num_chars)
{
  // read the data
 
  memcpy(array, &(*bData)[bDataPos], num_chars);
  bDataPos += num_chars;
}
 
inline void IFStreamBinary::readType(string& s)
{
    readString(s);
}
 
inline void IFStreamBinary::readTypeArray(string& s, int num_chars)
{
    readCharArray(s, num_chars);
}
 
//************* Read Bools ****************************************************
 
inline bool IFStreamBinary::readBool()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SBOL;
    return readBool(pos);
}
 
inline bool IFStreamBinary::readBool(int pos)
{
  return *((bool*) &(*bData)[pos]);
}
 
inline void IFStreamBinary::readBoolArray(bool* array, int num_bools)
{
    // get bytes and perform alignment
 
  int num_bytes = num_bools * CPPUtils::SBOL;
 
    // copy from buffer into array ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(bool& b)
{
    b = readBool();
}
 
inline void IFStreamBinary::readTypeArray(bool* array, int num_bools)
{
    readBoolArray(array, num_bools);
}
 
//************* Read Bytes ****************************************************
 
inline byte IFStreamBinary::readByte()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SBYT;
    return readByte(pos);
}
 
inline byte IFStreamBinary::readByte(int pos)
{
  return *((byte*) &(*bData)[pos]);
}
 
inline void IFStreamBinary::readByteArray(byte* array, int num_bytes)
{
    // get bytes and perform alignment
 
  num_bytes *= CPPUtils::SBYT;
 
    // copy from buffer into array ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(byte& b)
{
    b = readByte();
}
 
inline void IFStreamBinary::readTypeArray(byte* array, int num_bytes)
{
    readByteArray(array, num_bytes);
}
 
//************* Read Shorts ***************************************************
 
inline short IFStreamBinary::readShort()
{
  align2Byte();
  return readShortNC();
}
 
inline short IFStreamBinary::readShortNC()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SSHT;
    return readShort(pos);
}
 
inline short IFStreamBinary::readShort(int pos)
{
  // read the data ... use memcpy if alignment is off
 
    short s;
    if (bAlign)
    s = *((short*) &(*bData)[pos]);
    else
      memcpy(&s, &(*bData)[pos], 2);
 
  if (bReverse) reverseBO2((char*) &s);
    return s;
}
 
inline void IFStreamBinary::readShortArray(short* array, int num_shorts)
{
    // get bytes and perform alignment
 
  int num_bytes = num_shorts * CPPUtils::SSHT;
  align2Byte();
 
    // copy from buffer into array ... reverse data if necessary ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  if (bReverse) reverseBO2Array(num_shorts, (char*) array);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(short& s)
{
    s = readShort();
}
 
inline void IFStreamBinary::readTypeArray(short* array, int num_shorts)
{
    readShortArray(array, num_shorts);
}
 
//************* Read Ints *****************************************************
 
inline int IFStreamBinary::readInt()
{
  align4Byte();
  return readIntNC();
}
 
inline int IFStreamBinary::readIntNC()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SINT;
    return readInt(pos);
}
 
inline int IFStreamBinary::readInt(int pos)
{
  // read the data ... use memcpy if alignment is off
 
    int i;
    if (bAlign)
        i = *((int*) &(*bData)[pos]);
    else
        memcpy(&i, &(*bData)[pos], 4);
 
  if (bReverse) reverseBO4((char*) &i);
    return i;
}
 
inline void IFStreamBinary::readIntArray(int* array, int num_ints)
{
    // get bytes and perform alignment
 
  int num_bytes = num_ints * CPPUtils::SINT;
  align4Byte();
 
    // copy from buffer into array ... reverse data if necessary ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  if (bReverse) reverseBO4Array(num_ints, (char*) array);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(int& i)
{
    i = readInt();
}
 
inline void IFStreamBinary::readTypeArray(int* array, int num_ints)
{
    readIntArray(array, num_ints);
}
 
//************* Read Longs ****************************************************
 
inline LONG_INT IFStreamBinary::readLong()
{
  align8Byte();
  return readLongNC();
}
 
inline LONG_INT IFStreamBinary::readLongNC()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SLNG;
    return readLong(pos);
}
 
inline LONG_INT IFStreamBinary::readLong(int pos)
{
  // read the data ... use memcpy if alignment is off
 
    LONG_INT l;
    if (bAlign)
        l = *((LONG_INT*) &(*bData)[pos]);
    else
      memcpy(&l, &(*bData)[pos], 8);
 
  if (bReverse) reverseBO8((char*) &l);
    return l;
}
 
inline void IFStreamBinary::readLongArray(LONG_INT* array, int num_longs)
{
    // get bytes and perform alignment
 
  int num_bytes = num_longs * CPPUtils::SLNG;
  align8Byte();
 
    // copy from buffer into array ... reverse data if necessary ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  if (bReverse) reverseBO8Array(num_longs, (char*) array);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(LONG_INT& l)
{
    l = readLong();
}
 
inline void IFStreamBinary::readTypeArray(LONG_INT* array, int num_longs)
{
    readLongArray(array, num_longs);
}
 
//************* Read Floats ***************************************************
 
inline float IFStreamBinary::readFloat()
{
  align4Byte();
  return readFloatNC();
}
 
inline float IFStreamBinary::readFloatNC()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SFLT;
    return readFloat(pos);
}
 
inline float IFStreamBinary::readFloat(int pos)
{
  // read the data ... use memcpy if alignment is off
 
    float f;
    if (bAlign)
        f = *((float*) &(*bData)[pos]);
    else
      memcpy(&f, &(*bData)[pos], 4);
 
  if (bReverse) reverseBO4((char*) &f);
    return f;
}
 
inline void IFStreamBinary::readFloatArray(float* array, int num_floats)
{
    // get bytes and perform alignment
 
  int num_bytes = num_floats * CPPUtils::SFLT;
  align4Byte();
 
    // copy from buffer into array ... reverse data if necessary ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  if (bReverse) reverseBO4Array(num_floats, (char*) array);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(float& f)
{
    f = readFloat();
}
 
inline void IFStreamBinary::readTypeArray(float* array, int num_floats)
{
    readFloatArray(array, num_floats);
}
 
//************* Read Doubles **************************************************
 
inline double IFStreamBinary::readDouble()
{
  align8Byte();
  return readDoubleNC();
}
 
inline double IFStreamBinary::readDoubleNC()
{
  // read the data
 
    int pos = bDataPos;
    bDataPos += CPPUtils::SDBL;
    return readDouble(pos);
}
 
inline double IFStreamBinary::readDouble(int pos)
{
  // read the data ... use memcpy if alignment is off
 
    double d;
    if (bAlign)
        d = *((double*) &(*bData)[pos]);
    else
      memcpy(&d, &(*bData)[pos], 8);
 
  if (bReverse) reverseBO8((char*) &d);
    return d;
}
 
inline void IFStreamBinary::readDoubleArray(double* array, int num_doubles)
{
    // get bytes and perform alignment
 
  int num_bytes = num_doubles * CPPUtils::SDBL;
  align8Byte();
 
    // copy from buffer into array ... reverse data if necessary ...
    // update buffer position and exit
 
  memcpy(array, &(*bData)[bDataPos], num_bytes);
  if (bReverse) reverseBO8Array(num_doubles, (char*) array);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::readType(double& d)
{
    d = readDouble();
}
 
inline void IFStreamBinary::readTypeArray(double* array, int num_doubles)
{
    readDoubleArray(array, num_doubles);
}
 
//************* Write Strings *************************************************
 
inline void IFStreamBinary::writeString(const string& str)
{
  // get total size, align, and check capacity
 
    int sz = (int) str.size() + CPPUtils::SINT;
  align4Byte();
  checkBufferSize(sz);
 
  // write the data
 
    writeIntNC((int) str.size());
  memcpy(&(*bData)[bDataPos], &str[0], str.size());
  bDataPos += (int) str.size();
}
 
inline void IFStreamBinary::writeString(const char* char_string)
{
  string tmp_string = char_string;
  writeString(tmp_string);
}
 
inline void IFStreamBinary::writeCharArray(const char* array, int num_chars)
{
  checkBufferSize(num_chars);
 
  // write data
 
  memcpy(&(*bData)[bDataPos], array, num_chars);
  bDataPos += num_chars;
}
 
inline void IFStreamBinary::writeType(const string& str)
{
    writeString(str);
}
 
inline void IFStreamBinary::writeType(const char* char_string)
{
    writeString(char_string);
}
 
//************* Write Bools ***************************************************
 
inline void IFStreamBinary::writeBool(bool b)
{
    checkBufferSize(CPPUtils::SBOL);
 
  writeBoolNC(b);
}
 
inline void IFStreamBinary::writeBoolNC(bool b)
{
    writeBool(b, bDataPos);
  bDataPos += CPPUtils::SBOL;
}
 
inline void IFStreamBinary::writeBool(bool b, int pos)
{
  *((bool*) &(*bData)[pos]) = b;
}
 
inline void IFStreamBinary::writeBoolArray(const bool* array, int num_bools)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  num_bools *= CPPUtils::SBOL;
  checkBufferSize(num_bools);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bools);
  bDataPos += num_bools;
}
 
inline void IFStreamBinary::writeType(bool b)
{
    writeBool(b);
}
 
inline void IFStreamBinary::writeTypeArray(const bool* array, int num_bools)
{
    writeBoolArray(array, num_bools);
}
 
//************* Write Bytes ***************************************************
 
inline void IFStreamBinary::writeByte(byte b)
{
  checkBufferSize(CPPUtils::SBYT);
 
  writeByteNC(b);
}
 
inline void IFStreamBinary::writeByteNC(byte b)
{
    writeByte(b, bDataPos);
  bDataPos += CPPUtils::SBYT;
}
 
inline void IFStreamBinary::writeByte(byte b, int pos)
{
  *((byte*) &(*bData)[pos]) = b;
}
 
inline void IFStreamBinary::writeByteArray(const byte* array, int num_bytes)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  num_bytes *= CPPUtils::SBYT;
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(byte b)
{
    writeByte(b);
}
 
inline void IFStreamBinary::writeTypeArray(const byte* array, int num_bytes)
{
    writeByteArray(array, num_bytes);
}
 
//************* Write Shorts **************************************************
 
inline void IFStreamBinary::writeShort(short s)
{
  align2Byte();
  checkBufferSize(CPPUtils::SSHT);
 
  writeShortNC(s);
}
 
inline void IFStreamBinary::writeShortNC(short s)
{
    writeShort(s, bDataPos);
  bDataPos += CPPUtils::SSHT;
}
 
inline void IFStreamBinary::writeShort(short s, int pos)
{
  if (bReverse) reverseBO2((char*) &s);
 
  if (bAlign)
    *((short*) &(*bData)[pos]) = s;
  else
    memcpy(&(*bData)[pos], &s, CPPUtils::SSHT);
}
 
inline void IFStreamBinary::writeShortArray(const short* array, int num_shorts)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  int num_bytes = num_shorts * CPPUtils::SSHT;
  align2Byte();
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  if (bReverse) reverseBO2Array(num_shorts, &(*bData)[bDataPos]);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(short s)
{
    writeShort(s);
}
 
inline void IFStreamBinary::writeTypeArray(const short* array, int num_shorts)
{
    writeShortArray(array, num_shorts);
}
 
//************* Write Ints ****************************************************
 
inline void IFStreamBinary::writeInt(int i)
{
  align4Byte();
  checkBufferSize(CPPUtils::SINT);
 
  writeIntNC(i);
}
 
inline void IFStreamBinary::writeIntNC(int i)
{
    writeInt(i, bDataPos);
  bDataPos += CPPUtils::SINT;
}
 
inline void IFStreamBinary::writeInt(int i, int pos)
{
  if (bReverse) reverseBO4((char*) &i);
 
  if (bAlign)
    *((int*) &(*bData)[pos]) = i;
  else
    memcpy(&(*bData)[pos], &i, CPPUtils::SINT);
}
 
inline void IFStreamBinary::writeIntArray(const int* array, int num_ints)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  int num_bytes = num_ints * CPPUtils::SINT;
  align4Byte();
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  if (bReverse) reverseBO4Array(num_ints, &(*bData)[bDataPos]);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(int i)
{
    writeInt(i);
}
 
inline void IFStreamBinary::writeTypeArray(const int* array, int num_ints)
{
    writeIntArray(array, num_ints);
}
 
//************* Write Longs ***************************************************
 
inline void IFStreamBinary::writeLong(LONG_INT l)
{
  align8Byte();
  checkBufferSize(CPPUtils::SLNG);
 
  writeLongNC(l);
}
 
inline void IFStreamBinary::writeLongNC(LONG_INT l)
{
    writeLong(l, bDataPos);
  bDataPos += CPPUtils::SLNG;
}
 
inline void IFStreamBinary::writeLong(LONG_INT l, int pos)
{
  if (bReverse) reverseBO8((char*) &l);
 
  if (bAlign)
    *((LONG_INT*) &(*bData)[pos]) = l;
  else
    memcpy(&(*bData)[pos], &l, CPPUtils::SLNG);
}
 
inline void IFStreamBinary::writeLongArray(const LONG_INT* array, int num_longs)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  int num_bytes = num_longs * CPPUtils::SLNG;
  align8Byte();
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  if (bReverse) reverseBO8Array(num_longs, &(*bData)[bDataPos]);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(LONG_INT l)
{
    writeLong(l);
}
 
inline void IFStreamBinary::writeTypeArray(const LONG_INT* array, int num_longs)
{
    writeLongArray(array, num_longs);
}
 
//************* Write Floats **************************************************
 
inline void IFStreamBinary::writeFloat(float f)
{
  align4Byte();
  checkBufferSize(CPPUtils::SFLT);
 
  writeFloatNC(f);
}
 
inline void IFStreamBinary::writeFloatNC(float f)
{
    writeFloat(f, bDataPos);
  bDataPos += CPPUtils::SFLT;
}
 
inline void IFStreamBinary::writeFloat(float f, int pos)
{
  if (bReverse) reverseBO4((char*) &f);
 
  if (bAlign)
    *((float*) &(*bData)[pos]) = f;
  else
    memcpy(&(*bData)[pos], &f, CPPUtils::SFLT);
}
 
inline void IFStreamBinary::writeFloatArray(const float* array, int num_floats)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  int num_bytes = num_floats * CPPUtils::SFLT;
  align4Byte();
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  if (bReverse) reverseBO4Array(num_floats, &(*bData)[bDataPos]);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(float f)
{
    writeFloat(f);
}
 
inline void IFStreamBinary::writeTypeArray(const float* array, int num_floats)
{
    writeFloatArray(array, num_floats);
}
 
//************* Write Doubles *************************************************
 
inline void IFStreamBinary::writeDouble(double d)
{
  align8Byte();
    checkBufferSize(CPPUtils::SDBL);
 
  writeDoubleNC(d);
}
 
inline void IFStreamBinary::writeDoubleNC(double d)
{
    writeDouble(d, bDataPos);
  bDataPos += CPPUtils::SDBL;
}
 
inline void IFStreamBinary::writeDouble(double d, int pos)
{
  if (bReverse) reverseBO8((char*) &d);
 
  if (bAlign)
    *((double*) &(*bData)[pos]) = d;
  else
    memcpy(&(*bData)[pos], &d, CPPUtils::SDBL);
}
 
inline void IFStreamBinary::writeDoubleArray(const double* array, int num_doubles)
{
    // get number of bytes to be written and check for alignment and buffer
    // size
 
  int num_bytes = num_doubles * CPPUtils::SDBL;
  align8Byte();
  checkBufferSize(num_bytes);
 
    // copy array into data buffer. Reverse data buffer entries if necessary
    // and increment the buffer output pointer.
 
  memcpy(&(*bData)[bDataPos], array, num_bytes);
  if (bReverse) reverseBO8Array(num_doubles, &(*bData)[bDataPos]);
  bDataPos += num_bytes;
}
 
inline void IFStreamBinary::writeType(double d)
{
    writeDouble(d);
}
 
inline void IFStreamBinary::writeTypeArray(const double* array, int num_doubles)
{
    writeDoubleArray(array, num_doubles);
}
 
//************* Byte reversal functions ***************************************
 
inline void IFStreamBinary::reverseBO2(char* d)
{
  char tmp = d[0];
  d[0] = d[1];
  d[1] = tmp;
}
 
inline void IFStreamBinary::reverseBO4(char* d)
{
  char tmp = d[0];
  d[0] = d[3];
  d[3] = tmp;
 
  tmp = d[1];
  d[1] = d[2];
  d[2] = tmp;
}
 
inline void IFStreamBinary::reverseBO8(char* d)
{
  char tmp = d[0];
  d[0] = d[7];
  d[7] = tmp;
 
  tmp = d[1];
  d[1] = d[6];
  d[6] = tmp;
 
  tmp = d[2];
  d[2] = d[5];
  d[5] = tmp;
 
  tmp = d[3];
  d[3] = d[4];
  d[4] = tmp;
}
 
} // end namespace geotess
 
#endif  // IFSTREAMBINARY_OBJECT_H