/Users/baford/proj/netsteria/sst/lib/xdr.h

Go to the documentation of this file.

#ifndef SST_XDR_H
#define SST_XDR_H

#include <QIODevice>

#include "os.h"

class QByteArray;


namespace SST {

class XdrStream : public QObject
{
public:
        enum Status {
                Ok = 0,
                ReadPastEnd,
                ReadCorruptData,
                IOError,
        };

private:
        QIODevice *dev;
        Status st;

        static char zeros[4];

public:
        XdrStream();

        XdrStream(QIODevice *d);

        XdrStream(QByteArray *a, QIODevice::OpenMode mode);

        XdrStream(const QByteArray &a);



        inline QIODevice *device() { return dev; }

        void setDevice(QIODevice *d);



        inline Status status() const { return st; }

        inline void setStatus(Status st) { this->st = st; }

        inline void resetStatus() { setStatus(Ok); }



        inline bool atEnd() { return dev->atEnd(); }

        inline void readRawData(void *buf, int len) {
                if (dev->read((char*)buf, len) < len)
                        setStatus(ReadPastEnd);
        }

        inline void skipRawData(int len) {
                if (!dev->seek(dev->pos() + len))
                        setStatus(IOError);
        }

        inline void writeRawData(const void *buf, int len) {
                if (dev->write((const char*)buf, len) < len)
                        setStatus(IOError);
        }



        void readPadData(void *buf, int len);

        void skipPadData(int len);

        void writePadData(const void *buf, int len);



        void readBytes(char *&s, qint32 &len);

        void writeBytes(const char *s, qint32 len);

        inline XdrStream &operator<<(bool b) {
                qint32 v = htonl(b);
                writeRawData(&v, 4);
                return *this;
        }

        inline XdrStream &operator<<(qint8 i) {
                qint32 v = htonl(i);
                writeRawData(&v, 4);
                return *this;
        }

        inline XdrStream &operator<<(qint16 i) {
                qint32 v = htonl(i);
                writeRawData(&v, 4);
                return *this;
        }

        inline XdrStream &operator<<(qint32 i) {
                qint32 v = htonl(i);
                writeRawData(&v, 4);
                return *this;
        }

        inline XdrStream &operator<<(qint64 i) {
                qint32 v[2] = { htonl(i >> 32), htonl(i) };
                Q_ASSERT(sizeof(v) == 8);
                writeRawData(&v, 8);
                return *this;
        }

        inline XdrStream &operator<<(quint8 i) {
                return *this << (qint8)i;
        }

        inline XdrStream &operator<<(quint16 i) {
                return *this << (qint16)i;
        }

        inline XdrStream &operator<<(quint32 i) {
                return *this << (qint32)i;
        }

        inline XdrStream &operator<<(quint64 i) {
                return *this << (qint64)i;
        }

        inline XdrStream &operator<<(float f) {
                Q_ASSERT(sizeof(f) == 4);
                return *this << *(qint32*)&f;
        }

        inline XdrStream &operator<<(double f) {
                Q_ASSERT(sizeof(f) == 8);
                return *this << *(qint64*)&f;
        }



        inline XdrStream &operator>>(bool &b) {
                qint32 v;
                readRawData(&v, 4);
                b = (v != 0);
                return *this;
        }

        inline XdrStream &operator>>(qint8 &i) {
                qint32 v;
                readRawData(&v, 4);
                i = ntohl(v);
                return *this;
        }

        inline XdrStream &operator>>(qint16 &i) {
                qint32 v;
                readRawData(&v, 4);
                i = ntohl(v);
                return *this;
        }

        inline XdrStream &operator>>(qint32 &i) {
                qint32 v;
                readRawData(&v, 4);
                i = ntohl(v);
                return *this;
        }

        inline XdrStream &operator>>(qint64 &i) {
                quint32 v[2];
                Q_ASSERT(sizeof(v) == 8);
                readRawData(&v, 8);
                i = ((quint64)(quint32)ntohl(v[0]) << 32) |
                        (quint32)ntohl(v[1]);
                return *this;
        }

        inline XdrStream &operator>>(quint8 &i) {
                return *this >> *(qint8*)&i;
        }

        inline XdrStream &operator>>(quint16 &i) {
                return *this >> *(qint16*)&i;
        }

        inline XdrStream &operator>>(quint32 &i) {
                return *this >> *(qint32*)&i;
        }

        inline XdrStream &operator>>(quint64 &i) {
                return *this >> *(qint64*)&i;
        }

        inline XdrStream &operator>>(float &f) {
                Q_ASSERT(sizeof(f) == 4);
                return *this >> *(qint32*)&f;
        }

        inline XdrStream &operator>>(double &f) {
                Q_ASSERT(sizeof(f) == 8);
                return *this >> *(qint64*)&f;
        }

        XdrStream &operator>>(QByteArray &a);

        XdrStream &operator<<(const QByteArray &a);

        XdrStream &operator<<(const QString &s);

        XdrStream &operator>>(QString &s);


        QString errorString();
};


// Helper functions for encoding/decoding vectors and arrays
template<class T>
void xdrEncodeVector(XdrStream &xs, const QList<T> &l, int len)
{
        Q_ASSERT(l.size() == len);
        for (int i = 0; i < len; i++) {
                if (xs.status() != xs.Ok)
                        return;
                xs << l.at(i);
        }
}

template<class T>
void xdrDecodeVector(XdrStream &xs, QList<T> &l, int len)
{
        l.clear();
        for (int i = 0; i < len; i++) {
                if (xs.status() != xs.Ok)
                        return;
                T v;
                xs >> v;
                l.append(v);
        }
}

template<class T>
void xdrEncodeArray(XdrStream &xs, const QList<T> &l, quint32 maxlen)
{
        quint32 len = l.size();
        Q_ASSERT(len <= maxlen);
        xs << len;
        for (quint32 i = 0; i < len; i++) {
                if (xs.status() != xs.Ok)
                        return;
                xs << l.at(i);
        }
}

template<class T>
void xdrDecodeArray(XdrStream &xs, QList<T> &l, quint32 maxlen)
{
        quint32 len;
        xs >> len;
        if (len > maxlen)
                return xs.setStatus(xs.ReadCorruptData);
        l.clear();
        for (quint32 i = 0; i < len; i++) {
                if (xs.status() != xs.Ok)
                        return;
                T v;
                xs >> v;
                l.append(v);
        }
}


// Helper functions for encoding/decoding byte vectors and arrays
inline void xdrEncodeVector(XdrStream &xs, const QByteArray &v, int len)
{
        Q_ASSERT(v.size() == len);
        xs.writeRawData(v.constData(), len);
}

inline void xdrDecodeVector(XdrStream &xs, QByteArray &v, int len)
{
        v.resize(len);
        xs.readRawData(v.data(), len);
}

inline void xdrEncodeArray(XdrStream &xs, const QByteArray &v, quint32 maxlen)
{
        Q_ASSERT((quint32)v.size() <= maxlen);
        xs << v;
}

inline void xdrDecodeArray(XdrStream &xs, QByteArray &v, quint32 maxlen)
{
        xs >> v;
        if ((quint32)v.size() > maxlen)
                return xs.setStatus(xs.ReadCorruptData);
}



template<class T> class XdrPointer
{
private:
        T *i;

public:
        inline XdrPointer() : i(0) { }
        inline XdrPointer(const T &o) : i(new T(o)) { }
        inline XdrPointer(const XdrPointer<T> &o)
                : i(o.i ? new T(*o.i) : 0) { }

        inline ~XdrPointer() { if (i) delete i; }

        inline bool isNull() const { return i == 0; }
        inline void clear() { if (i) { delete i; i = 0; } }
        inline T& alloc() { if (!i) i = new T; return *i; }

        inline XdrPointer<T> &operator=(const XdrPointer<T> &o)
                { clear(); if (o.i) i = new T(*o.i); }
        inline XdrPointer<T> &operator=(T *o)
                { clear(); if (o) i = new T(o); }

        inline T* operator->() const { return i; }
        inline T& operator*() const { return *i; }
        inline operator T*() const { return i; }
};

template<class T>
inline XdrStream &operator<<(XdrStream &xs, const XdrPointer<T> &p)
        { if (p) { xs << true << *p; } else { xs << false; }; return xs; }
template<class T>
inline XdrStream &operator>>(XdrStream &xs, XdrPointer<T> &p)
        { bool f; xs >> f; if (f) { xs >> p.alloc(); } else p.clear();
          return xs; }


template<class T> class XdrOption
{
private:
        T *i;                           // Decoded option value
        QByteArray enc;                 // Encoded option value

public:
        inline XdrOption() : i(NULL) { }
        inline XdrOption(const T &o) : i(new T(o)) { }
        inline XdrOption(const XdrOption<T> &o)
                : i(o.i ? new T(*o.i) : NULL), enc(o.enc) { }

        inline ~XdrOption() { if (i) { delete i; i = NULL; } }

        inline bool isNull() const { return i == NULL; }

        inline bool isEmpty() const { return i == NULL && enc.isEmpty(); }

        // Set or clear the item's decoded representation
        inline T& alloc() { enc.clear(); if (!i) i = new T; return *i; }
        inline void clear() { enc.clear(); if (i) { delete i; i = NULL; } }

        // Set or clear the item's encoded representation
        inline QByteArray getEncoded() const { return enc; }
        inline void setEncoded(const QByteArray &e)
                { clear(); enc = e; }

        inline XdrOption<T> &operator=(const XdrOption<T> &o)
                { clear(); if (o.i) i = new T(*o.i); enc = o.enc;
                  return *this; }
        inline XdrOption<T> &operator=(T *o)
                { clear(); if (o) i = new T(o); return *this; }

        inline T* operator->() const { return i; }
        inline T& operator*() const { return *i; }
        inline operator T*() const { return i; }
};

template<class T>
XdrStream &operator<<(XdrStream &xs, const XdrOption<T> &o)
{
        if (!o.isNull()) {
                QByteArray buf;
                XdrStream bxs(&buf, QIODevice::WriteOnly);
                bxs << *o;
                xs << buf;
        } else
                xs << o.getEncoded();
        return xs;
}

template<class T>
XdrStream &operator>>(XdrStream &xs, XdrOption<T> &o)
{
        QByteArray buf;
        xs >> buf;
        if (buf.isEmpty()) {
                o.clear();
                return xs;
        }
        XdrStream bxs(&buf, QIODevice::ReadOnly);
        bxs >> o.alloc();
        if (bxs.status() != bxs.Ok)
                o.setEncoded(buf);
        return xs;
}

} // namespace SST

#endif  // SST_XDR_H

---