ByteInBuffer.h

Go to the documentation of this file.

// $Id: ByteInBuffer.h 163 2006-05-28 08:59:43Z bingmann $

#ifndef VGS_ByteInBuffer_H
#define VGS_ByteInBuffer_H

#include <stdlib.h>
#include <assert.h>

#include <utility>
#include <string>
#include <stdexcept>

#include "ByteBuffer.h"

namespace VGServer {

class ByteInBuffer
{
private:
    const ByteBuffer    &buff;

    size_t _curr;

    inline void check_sizeof() {
        assert( sizeof(char) == 1 );
        assert( sizeof(short) == 2 );
        assert( sizeof(int) == 4 );
    }

public:
    inline ByteInBuffer(const ByteBuffer &_buff)
        : buff(_buff), _curr(0)
    {
        check_sizeof();
    }

    inline ByteInBuffer(const ByteInBuffer &o)
        : buff(o.buff), _curr(o._curr)
    {
    }

    // *** Cursor-Driven Read Functions ***

    inline void rewind()
    { _curr = 0; }

    inline size_t cursor() const
    { return _curr; }

    inline size_t remaining() const
    { return (_curr < buff.size()) ? (buff.size() - _curr) : 0; }

    inline bool cursor_available(unsigned int n) const
    { return (_curr + n <= buff.size()); }

    inline void check_available(unsigned int n) const
    { if (!cursor_available(n)) throw(std::underflow_error("ByteInBuffer underrun")); }

    template <typename Tp>
    inline Tp fetch()
    {
        check_available(sizeof(Tp));

        Tp ret = *reinterpret_cast<const Tp*>(buff.data() + _curr);
        _curr += sizeof(Tp);

        return ret;
    }

    // *** instanciations of the function template fetch, because with g++-3.3
    // *** in it doesnt work in the GraphParser class

    inline unsigned char fetch_unsigned_char()
    { return fetch<unsigned char>(); }

    inline unsigned short fetch_unsigned_short()
    { return fetch<unsigned short>(); }

    inline unsigned int fetch_unsigned_int()
    { return fetch<unsigned int>(); }
       
    inline std::string fetchString()
    {
        unsigned char slen = fetch<unsigned char>();

        check_available(slen);
        std::string ret(buff.data() + _curr, slen);

        _curr += slen;
        return ret;
    }

    inline std::string fetchLongString()
    {
        unsigned int slen = fetch<unsigned int>();

        check_available(slen);
        std::string ret(buff.data() + _curr, slen);

        _curr += slen;
        return ret;
    }

    inline void fetchBytes(char *dest, unsigned int len)
    {
        check_available(len);
        memcpy(dest, buff.data() + _curr, len);

        _curr += len;
    }

    inline void fetchBytes(ByteBuffer &dest, unsigned int len)
    {
        check_available(len);
        dest.assign_copy(buff.data() + _curr, len);

        _curr += len;
    }

    void        fetchAnyType(class AnyType &v);
};

} // namespace VGServer

#endif // VGS_ByteInBuffer_H

---