Binary_IO.hh

Go to the documentation of this file.

/*  Binary_IO

PIRL CVS ID: $Id: Binary_IO.hh,v 1.17 2010/11/11 20:31:46 castalia Exp $

Copyright (C) 2003-2010  Arizona Board of Regents on behalf of the
Planetary Image Research Laboratory,  Lunar and Planetary Laboratory at
the University of Arizona.

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License, version 2.1,
as published by the Free Software Foundation.

This library 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
Lesser General Public License for more details.

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

#include    <istream>
#include    <ostream>

#include    "endian.hh"

#if defined (DEBUG)
/*=*****************************************************************************
    DEBUG controls
*/
#define DEBUG_BINARY_IO     (1 << 13)

//  Default DEBUG value
#if (DEBUG +0 == DEBUG_BINARY_IO)
#define BINARY_IO_DEBUG
#endif

#include    <iostream>
using std::cerr;

#include    <iomanip>
using std::endl;

#endif  //  DEBUG


namespace PIRL
{
/*=*****************************************************************************
    Data_Binder
*/
template<typename Bindor_object>
class Data_Binder
{
public:
Bindor_object&
    Bindor;

mutable char*
    Data;
unsigned long
    Amount;

Data_Binder
    (
    const Bindor_object&    bindor,
    char*                   data,
    unsigned long           amount
    )
    :   Bindor (const_cast<Bindor_object&>(bindor)),
        Data (data),
        Amount (amount)
{}
};

/*=*****************************************************************************
    Binary_IO
*/
class Binary_IO
{
public:
/*==============================================================================
    Types
*/
typedef std::istream& (* Reader) (std::istream&, char*, unsigned long);
typedef std::ostream& (* Writer) (std::ostream&, const char*, unsigned long);

typedef Data_Binder<Binary_IO>    Binder;

/*==============================================================================
    Constants
*/
static const char*
    ID;

enum Data_Order
    {
    MSB,
    LSB
    };

#define REVERSED    true
#define NATIVE      false

/*==============================================================================
    Constructors
*/
explicit Binary_IO
    (
    bool        reverse = false
    )
{reversed (reverse);}

explicit Binary_IO
    (
    Data_Order  data_order
    )
{IO (data_order);}

/*==============================================================================
    Accessors
*/
bool reversed () const
{return Reversed;}

Binary_IO& reversed (bool reverse)
{
if ((Reversed = reverse))
    {
    read = &read_backwards;
    write = &write_backwards;
    }
else
    {
    read = &read_forwards;
    write = &write_forwards;
    }
return *this;
}

Data_Order IO ()
{
if (Reversed)
    return low_endian_host () ? MSB : LSB;
return high_endian_host () ? MSB : LSB;
}

Binary_IO& IO (Data_Order data_order)
{
return reversed ((data_order == MSB) ?
    low_endian_host () :
    high_endian_host ());
}

/*==============================================================================
    Manipulator interface
*/
template<typename T>
Binder operator() (T& value) const
{return Binder (*this, reinterpret_cast<char*>(&value), sizeof (T));}

/*------------------------------------------------------------------------------
    IO
*/
/*..............................................................................
    Primary get/put generic interface
*/
template<typename T>
Binary_IO& get (std::istream& stream, T& value)
{
read (stream, reinterpret_cast<char*>(&value), sizeof (T));
return *this;
}

template<typename T>
Binary_IO& put (std::ostream& stream, T& value)
{
write (stream, reinterpret_cast<const char*>(&value), sizeof (T));
return *this;
}

template<typename T>
Binary_IO& get (std::istream& stream, T* value, unsigned int amount)
{
if (sizeof (T) == 1)
    read (stream, reinterpret_cast<char*>(value), amount);
else
    {
    //  Read each array element
    while (amount--)
        {
        read (stream, reinterpret_cast<char*>(value), sizeof (T));
        ++value;
        }
    }
return *this;
}

template<typename T>
Binary_IO& put (std::ostream& stream, T* value, unsigned int amount)
{
if (sizeof (T) == 1)
    write (stream, reinterpret_cast<const char*>(value), sizeof (T));
else
    {
    //  Write each array element
    while (amount--)
        {
        write (stream, reinterpret_cast<const char*>(value), sizeof (T));
        ++value;
        }
    }
return *this;
}

Binary_IO& get_3 (std::istream& stream, int& value)
{
static const int
    offset = (high_endian_host () ? 1 : 0);
read (stream, reinterpret_cast<char*>(&value) + offset, 3);
return *this;
}

Binary_IO& put_3 (std::ostream& stream, const int& value)
{
static const int
    offset = (high_endian_host () ? 1 : 0);
write (stream, reinterpret_cast<const char*>(&value) + offset, 3);
return *this;
}

/*..............................................................................
    Virtual read/write interface
*/
Reader
    read;

Writer
    write;

/*..............................................................................
    Static read/write_forwards/backwards system IO interface
*/
protected:
static std::istream&
read_forwards (std::istream& stream, char* data, unsigned long amount)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< Binary_IO::read_forwards: "
     << "    data @ " << (void*)data << ", amount = " << amount << endl;
#endif
return stream.read (data, amount);
}

static std::istream&
read_backwards (std::istream& stream, char* data, unsigned long amount)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< Binary_IO::read_backwards: "
     << "    data @ " << (void*)data << ", amount = " << amount << endl;
#endif
data += amount;
while (amount--)
    stream.get (*--data);
return stream;
}

static std::ostream&
write_forwards (std::ostream& stream, const char* data, unsigned long amount)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< Binary_IO::write_forwards: "
     << "    data @ " << (void*)data << ", amount = " << amount << endl;
#endif
return stream.write (data, amount);
}

static std::ostream&
write_backwards (std::ostream& stream, const char* data, unsigned long amount)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< Binary_IO::write_backwards: "
     << "    data @ " << (void*)data << ", amount = " << amount << endl;
#endif
data += amount;
while (amount--)
    stream.put (*--data);
return stream;
}

//..............................................................................
private:

bool
    Reversed;

};  //  class Binary_IO

/*=*****************************************************************************
    Input and Output subclases
*/
struct Binary_Input
:   public Binary_IO
{
explicit Binary_Input (std::istream& stream, bool reversed = false)
    :   Binary_IO (reversed),
        Stream (stream)
{}

explicit Binary_Input (std::istream& stream, Data_Order data_order)
    :   Binary_IO (data_order),
        Stream (stream)
{}

template<typename T>
Binary_Input& get (T& value)
{
Binary_IO::read (Stream, reinterpret_cast<char*>(&value), sizeof (T));
return *this;
}

template<typename T>
Binary_Input& get (T* value, unsigned int amount)
{
Binary_IO::get (Stream, value, amount);
return *this;
}

Binary_Input& get_3 (int& value)
{
Binary_IO::get_3 (Stream, value);
return *this;
}

std::istream&
    Stream;
};  //  class Binary_Input

struct Binary_Output
:   public Binary_IO
{
explicit Binary_Output (std::ostream& stream, bool reversed = false)
    :   Binary_IO (reversed),
        Stream (stream)
{}

explicit Binary_Output (std::ostream& stream, Data_Order data_order)
    :   Binary_IO (data_order),
        Stream (stream)
{}

template<typename T>
Binary_Output& put (T& value)
{
Binary_IO::write (Stream, reinterpret_cast<const char*>(&value), sizeof (T));
return *this;
}

template<typename T>
Binary_Output& put (T* value, unsigned int amount)
{
Binary_IO::put (Stream, value, amount);
return *this;
}

Binary_Output& put_3 (const int& value)
{
Binary_IO::put_3 (Stream, value);
return *this;
}

std::ostream&
    Stream;
};  //  class Binary_Output

/*==============================================================================
    Binary_IO methods bound to the Binary_IO Binder.
*/
inline std::istream&
operator>> (std::istream& stream, const Binary_IO::Binder& binder)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< operator>> (std::ostream& stream, const Binary_IO::Binder& binder)"
     << endl
     << "    binder.Data @ " << (void*)(binder.Data) << endl
     << "    binder.Amount = " << binder.Amount << endl;
#endif
return binder.Bindor.read (stream, binder.Data, binder.Amount);
}

inline std::ostream&
operator<< (std::ostream& stream, const Binary_IO::Binder& binder)
{
#ifdef BINARY_IO_DEBUG
cerr << ">-< operator<< (std::ostream& stream, const Binary_IO::Binder& binder)"
     << endl
     << "    binder.Data @ " << (void*)(binder.Data) << endl
     << "    binder.Amount = " << binder.Amount << endl;
#endif
return binder.Bindor.write (stream, binder.Data, binder.Amount);
}

}   //  namespace PIRL
#endif