lmsg/TransOutput.hh

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

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

class Time;

namespace lmsg {

    class Buffer;
    class MsgAddr;

    class TransOutput {
    public:
        TransOutput(Buffer& b);

        TransOutput(void);

        void align(size_type N);

        bool available(size_type N) const;

        bool full(void) const;

        void setBuffer(Buffer& b);

        template<class T> 
        size_type write(const T x[], size_type N=1);

        template<class T> 
        TransOutput& operator<<(const T& x) throw(std::runtime_error);

        TransOutput& operator<<(const char* x) throw(std::runtime_error);

        size_type getNBytes(void) const throw();

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


    inline bool
    TransOutput::available(size_type N) const {
        return mIndex + N <= mLength;
    }

    inline bool
    TransOutput::full(void) const {
        return mIndex >= mLength;
    }

    inline size_type
    TransOutput::getNBytes(void) const throw() {
        return mIndex;
    }

    //--------------------------------------  Implement write template
    template<> size_type TransOutput::write(const char x[], size_type N);

    template<> size_type TransOutput::write(const MsgAddr x[], size_type N);

    template<> size_type TransOutput::write(const std::string x[],size_type N);

    template<> size_type TransOutput::write(const Time x[], size_type N);

    template<class T> 
    inline size_type 
    TransOutput::write(const T x[], size_type N) {
        align(sizeof(T));
        if (full()) return 0;
        if (!available(N*sizeof(T))) N = (mLength - mIndex)/sizeof(T);
        export_format_grinder.SwapOut(x, mData+mIndex, N);
        mIndex += N*sizeof(T);
        return N;
    }

    //--------------------------------------  Implement << by template;
    template<class T>
    inline TransOutput&
    TransOutput::operator<<(const T& x) throw(std::runtime_error) {
        if (!write(&x)) throw std::runtime_error("Buffer overflow");
        return *this;
    }

    inline TransOutput& 
    TransOutput::operator<<(const char* x) throw(std::runtime_error) {
        return operator<<(std::string(x));
    }

}    // namespace lmsg

#endif  //  LMSG_TRANSOUTPUT_HH

---