ParaStrm.h

 
#ifndef PARASTRM_H_
#define PARASTRM_H_
 
#include <malloc.h>
 
#include "utils/mardyn_assert.h"
#include <cstddef>
#include <cstdlib>
#include <cstring>
 
class ParaStrm {
public:
    //enum Eparatype {UNDEF=0,DOUBLE,INT};
 
    ParaStrm() : m_size(0)/*, m_pos(0)*/, m_pstrm(NULL), m_readpos(NULL) { }
 
    ParaStrm( const ParaStrm& param_stream ) : m_size( param_stream.m_size ), m_pstrm(NULL), m_readpos(NULL) {
        m_pstrm = (char *) malloc(m_size);
        mardyn_assert(m_pstrm);
        memcpy( m_pstrm, param_stream.m_pstrm, m_size );
        m_readpos = m_pstrm;
    }
 
    ~ParaStrm() {
        if (m_pstrm)
            free(m_pstrm);
    }
 
    bool eos() const {
        return m_readpos >= m_pstrm + m_size;
    }
    bool empty() const {
        return m_size == 0;
    }
    void reset_read() {
        m_readpos = m_pstrm; /*m_pos=0;*/
    }
 
    ParaStrm& operator=( const ParaStrm& param_stream ) {
        m_size  = param_stream.m_size;
        m_pstrm = (char *) malloc(m_size);
        mardyn_assert(m_pstrm);
        memcpy( m_pstrm, param_stream.m_pstrm, m_size );
        m_readpos = m_pstrm;
        return *this;
    }
 
    template<class T> ParaStrm& operator <<(T p) {
        ptrdiff_t oldsize = m_size;
        // determine relative reading position
        ptrdiff_t readpos = m_readpos - m_pstrm;
        // enlarge vector
        m_size += sizeof(p);
        if (!m_pstrm)
            m_pstrm = (char*) malloc(m_size);
        else
            m_pstrm = (char*) realloc(m_pstrm, m_size);
        // realloc might change m_pstrm!
        mardyn_assert(m_pstrm);
        // save value
        *((T*) (m_pstrm + oldsize)) = p;
        //m_ptypes.push_back(UNDEF);
        // adjust m_readpos to maybe changed m_pstrm
        m_readpos = m_pstrm + readpos;
        return *this;
    }
 
    template<class T> ParaStrm& operator >>(T& p) {
        mardyn_assert(m_readpos+sizeof(T)<=m_pstrm+m_size);
        // get value
        p = *((T*) m_readpos);
        // move reading position
        m_readpos = (char*) ((T*) m_readpos + 1);
        //++m_pos;
        return *this;
    }
 
private:
    size_t m_size;  
    char *m_pstrm;  
    char *m_readpos;  
    // we also could check for valid types...
    //std::vector<Eparatype> m_ptypes;
    //std::size_t m_pos;
};
 
#endif /*PARASTRM_H_*/