lmsg/TransInput.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef LMSG_TRANSINPUT_HH
#define LMSG_TRANSINPUT_HH

#include <stdexcept>
#include <string>
#include "lmsg/MsgTypes.hh"
#include "lmsg/Grinder.hh"

class Time;

namespace lmsg {

    class Buffer;

    class TransInput {
    public:
        TransInput(const Buffer& b);

        TransInput(void);

        void align(size_type bdry);

        bool available(size_type N) const;

        bool empty(void) const;

        template<class T> 
        size_type read(T x[], size_type N=1);
 
        template <class T> 
        TransInput& operator>>(T& x) throw(std::runtime_error);

    private:
        const char* mData;
        size_type      mIndex;
        size_type      mLength;
    };  //  class lmsg::TransInput

    //======================================  Specific templates

    template<> 
    size_type TransInput::read(char x[], size_type N);

    template<> 
    size_type TransInput::read(MsgAddr x[], size_type N);

    template<> 
    size_type TransInput::read(Time x[], size_type N);

    template<> 
    size_type TransInput::read(std::string x[], size_type N);

    //======================================  Inline methods
    template<class T>
    inline TransInput&
    TransInput::operator>> (T& x) throw(std::runtime_error) {
        if (!read(&x, 1)) throw std::runtime_error("End-Of-Data");
        return *this;
    }

    inline bool 
    TransInput::available(size_type N) const {
        return mIndex + N <= mLength;
    }
  
    inline bool
    TransInput::empty(void) const {
        return mIndex >= mLength;
    }

    template<class T> 
    inline size_type 
    TransInput::read(T x[], size_type N) {
        align(sizeof(T));
        if (empty()) return 0;
        if (!available(N*sizeof(T))) N = (mLength - mIndex)/sizeof(T);
        export_format_grinder.SwapIn(mData+mIndex, x, N);
        mIndex += N*sizeof(T);
        return N;
    }

}    // namespace lmsg

#endif  //  LMSG_TRANSINPUT_HH

---