/home/brandes/workspace/LAMA/src/lama/io/XDRFileStream.hpp

Go to the documentation of this file.

#ifndef XDRFILESTREAM_HPP_
#define XDRFILESTREAM_HPP_

// for dll_import
#include <lama/config.hpp>
#include <lama/exception/Exception.hpp>

// others
#include <fstream>
#include <cstdlib>
#include <typeinfo>
#include <sstream>

namespace lama
{

class LAMA_DLL_IMPORTEXPORT XDRFileStream
{
public:
    XDRFileStream(const std::string& filename,
                  const std::ios_base::openmode openmode);

    virtual ~XDRFileStream();

    template <typename T>
    void read(T * const input, const std::streamsize n);

    template <typename T>
    void read(T * const input);


    template <typename T>
    void write(T * const input, const std::streamsize n);

    template <typename T>
    void write(T * const input);


    bool is_open();

    void close();

private:

    std::string m_filename;
    std::fstream m_filestream;

    std::ios_base::openmode m_openmode;

    void openFilePointer(const std::string filename,
                         const std::ios_base::openmode openmode);
    template <typename T>
    void xdrRead(T* const data);
    template <typename T>
    void xdrWrite(const T* const data);

    template <typename T>
    int getSize(const T);

    bool isLittleEndian();

}; //class XDRFileStream

template <typename T>
void XDRFileStream::write(T * const input, const std::streamsize n)
{
    if(m_openmode&std::ios::in)
    {
        LAMA_THROWEXCEPTION("XDRFileStream: Stream is not in Output mode");
    }
    for (std::streamsize i = 0; i<n; i++)
    {
        xdrWrite(&input[i]);
    }
}

template <typename T>
void XDRFileStream::write(T * const input)
{
    write(input,1);
}

template <typename T>
void XDRFileStream::read(T * const input, const std::streamsize n)
{
    if(m_openmode&std::ios::out)
    {
        LAMA_THROWEXCEPTION( "XDRFileStream: Stream is not in Input mode" );
    }
    for (std::streamsize i = 0; i<n; i++)
    {
        xdrRead(&input[i]);
    }
}

template <typename T>
void XDRFileStream::read(T * const input)
{
    read(input,1);
}

template <typename T>
void XDRFileStream::xdrRead(T* const data){
    if(!is_open())
    {
        LAMA_THROWEXCEPTION( "Error trying to read from closed XDRFileStream" );
    }
    const int length = getSize(*data);
    *data = 0;
    char* dataptr = reinterpret_cast<char*>(data);
    if(isLittleEndian())
    {
        for(int pos = length-1; pos >= 0; pos--)
        {
            m_filestream.read(dataptr+pos,1);
        }
    }else{
        m_filestream.read(dataptr,length);
    }
    //correct the signed bit
    if (typeid(T) == typeid(long))
    {
        int i = 0|static_cast<long>(*data);
        *data =0;
        *data = static_cast<T>( i );
    }
}
template <typename T>
void XDRFileStream::xdrWrite(const T* const data){
    if( !is_open() )
    {
        LAMA_THROWEXCEPTION( "Error trying to read from closed XDRFileStream" );
    }
    const int length = getSize(*data);
    //correct the signed bit
    T tempData = *data;
    if ( typeid(T) == typeid(unsigned long) )
    {
        //Check if unsigned long is over the limit of XDR
        if(((static_cast<long>(*data)))>((static_cast<long>(1)<<(length*8))-1))
        {
            LAMA_THROWEXCEPTION( "unsigned long is to big for XDR (Limit 4 Byte)" );
        }
    }
    if ( typeid(T) == typeid(long) )
    {
        if(std::abs(static_cast<long>(*data))>=(1<<30)-1)
        {
            LAMA_THROWEXCEPTION( "long is to big for XDR (Limit 4 Byte)" );
        }
        int temp = static_cast<long>(*data);
        tempData= static_cast<T>( 0|temp );
    }
    char* dataptr = reinterpret_cast<char*>(&tempData);
    if(isLittleEndian())
    {
        for(int pos = length-1; pos >= 0; pos--)
        {
            m_filestream.write(dataptr+pos,1);
        }
    }
    else
    {
        m_filestream.write(dataptr,length);
    }
}

template <typename T>
int XDRFileStream::getSize(const T)
{
    int size = 0;

    if(typeid(T) == typeid(double))
    {
        size = 8;
    }
    else if (typeid(T) == typeid(float))
    {
        size = 4;
    }
    else if (typeid(T) == typeid(int))
    {
        size = 4;
    }
    else if (typeid(T) == typeid(long))
    {
        size = 4;
    }
    else if (typeid(T) == typeid(unsigned long))
    {
        size = 4;
    }
    else if (typeid(T) == typeid(unsigned int))
    {
        size = 4;
    }
    else
    {
        LAMA_THROWEXCEPTION( (std::string("XDRFileStream: Type not permitted: ") + typeid(T).name()).c_str() );
    }
    return size;
}


} //namespace lama

#endif // XDRFILESTREAM_HPP_