BinaryStream.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_BINARY_STREAM_H_
#define _MIRA_BINARY_STREAM_H_

#include <iostream>
#include <string.h> // for strlen

#include <platform/Endian.h> // for conversion to network byte order

#include <utils/Buffer.h>
#include <utils/EnumToFlags.h>

#include <error/Exceptions.h>

namespace mira {


class BinaryIosBase
{
public:

    typedef enum
    {
        none = 0,
        net  = 1L << 0
    } fmtflags;
    MIRA_ENUM_TO_FLAGS_INCLASS(fmtflags)

    BinaryIosBase() : mFmtFlags(none) {}


    fmtflags setf(fmtflags flags)
    {
        fmtflags old = flags;
        mFmtFlags |= flags;
        return old;
    }

    void unsetf(fmtflags mask)
    {
        mFmtFlags &= ~mask;
    }


protected:

    // our format flags that were set by the manipulators or the setf() unsetf() methods
    fmtflags mFmtFlags;

};


class BinaryBufferStreamBase
{
public:

    // a couple of stl conform typedefs
    typedef Buffer<uint8> buffer_type;
    typedef buffer_type::value_type char_type;
    typedef std::size_t pos_type;

public:
    BinaryBufferStreamBase(buffer_type* buffer) :
        mBuffer(buffer), mGetPos(0), mPutPos(0), mFailBit(false)
    {
        if(mBuffer->size()==0)
            mBuffer->resize(1);
    }

public:

    // access to internal data buffer
    buffer_type* rdbuf()
    {
        return mBuffer;
    }

public:

    // keep this inline for performance reasons!!!
    void write(const char* data, std::size_t size)
    {
        std::size_t npos = mPutPos+size;

        // resize the vector buffer if necessary
        if(npos>mBuffer->size())
            mBuffer->resize(npos);

        memcpy(mBuffer->data()+mPutPos, data, size);
        mPutPos = npos;
    }

    // keep this inline for performance reasons!!!
    void read(char* data, std::size_t size)
    {
        std::size_t npos = mGetPos+size;

        // make sure that we do not read above end of buffer
        // (see istream::read)
        if(npos>mBuffer->size()) {
            size = mBuffer->size() - mGetPos;
            npos = mBuffer->size();
            mFailBit = true;
        }

        memcpy(data, mBuffer->data()+mGetPos, size);
        mGetPos = npos;
    }

public:

    std::size_t tellg() const {
        return mGetPos;
    }

    BinaryBufferStreamBase& seekg(std::size_t pos) {
        mGetPos = pos;
        return *this;
    }

    std::size_t tellp() const {
        return mPutPos;
    }

    BinaryBufferStreamBase& seekp(std::size_t pos) {
        mPutPos = pos;
        return *this;
    }

public:

    // keep this inline for performance reasons!!!
    bool eof() const {
        return mPutPos == mBuffer->size();
    }

    bool fail() const {
        return mFailBit;
    }

private:

    buffer_type* mBuffer;
    std::size_t  mGetPos;
    std::size_t  mPutPos;
    bool mFailBit;
};


template <typename StreamUnderlay = BinaryBufferStreamBase>
class BinaryOstream : public StreamUnderlay,
                      public BinaryIosBase // used as mixin
{
    typedef StreamUnderlay Base;

public:

    // a couple of stl conform typedefs
    typedef typename Base::char_type char_type;
    typedef decltype(std::declval<Base>().rdbuf()) streambuffer_pointer;
    typedef typename StreamUnderlay::pos_type pos_type;

public:

    BinaryOstream(streambuffer_pointer buffer) : Base(buffer) {}

    BinaryOstream(Base& s) : Base(s.rdbuf()) {}

    BinaryOstream(Base& s, pos_type pos) : Base(s.rdbuf()) { this->seekp(pos); }

    BinaryOstream& operator<<(const char* v)          {return writeString(v);}
    BinaryOstream& operator<<(const std::string& v)   {return writeString(v);}
    BinaryOstream& operator<<(const bool& v)          {return toBinary<bool>(v);}
    BinaryOstream& operator<<(const char& v)          {return toBinary<char>(v);}
    BinaryOstream& operator<<(const uint8& v)         {return toBinary<uint8>(v);}
    BinaryOstream& operator<<(const uint16& v)        {return toBinary<uint16>(v);}
    BinaryOstream& operator<<(const uint32& v)        {return toBinary<uint32>(v);}
    BinaryOstream& operator<<(const uint64& v)        {return toBinary<uint64>(v);}
    BinaryOstream& operator<<(const int8& v)          {return toBinary<int8>(v);}
    BinaryOstream& operator<<(const int16& v)         {return toBinary<int16>(v);}
    BinaryOstream& operator<<(const int32& v)         {return toBinary<int32>(v);}
    BinaryOstream& operator<<(const int64& v)         {return toBinary<int64>(v);}
    BinaryOstream& operator<<(const float& v)         {return toBinary<float>(v);}
    BinaryOstream& operator<<(const double& v)        {return toBinary<double>(v);}
    template<typename T>
    BinaryOstream& operator<<(const Buffer<T>& v) {
        uint64 size = v.size();
        *this << size;
        write(v.data(), v.size());
        return *this;
    }

    // Interface for manipulators
    BinaryOstream& operator<<(BinaryIosBase& (*manipFn) (BinaryIosBase&))
    {
        manipFn(*this); // call the manipulator
        return *this;
    }

public:

    template <typename T>
    void write(const T* data, std::size_t count)
    {
        static_assert(sizeof(char_type)==1, "binaryostream must have char_type of size 1");
        Base::write(reinterpret_cast<const char*>(data), count*sizeof(T));
    }

    BinaryOstream& writeString(const char* value)
    {
        writeString(value, (uint32)strlen(value));
        return *this;
    }

    BinaryOstream& writeString(const std::string& value)
    {
        writeString(value, (uint32)value.length());
        return *this;
    }

    BinaryOstream& writeString(const char* value, uint32 length)
    {
        this->operator<<(length); // write the length
        write(value, length);
        return *this;
    }

    BinaryOstream& writeString(const std::string& value, uint32 length)
    {
        this->operator<<(length); // write the length
        write(value.c_str(), length);
        return *this;
    }

protected:

    template<typename T>
    BinaryOstream& toBinary(const T& value)
    {
        if(mFmtFlags & net) { // write in network byte order
            // convert first
            typename NetworkTypeTrait<T>::Type v = hostToNetwork<T>(value);
            write(&v, 1);
        } else // write in host byte order
            write(&value, 1);
        return *this;
    }
};

using BinaryStlOstream = BinaryOstream<std::basic_ostream<char, std::char_traits<char>>>;

using BinaryBufferOstream = BinaryOstream<BinaryBufferStreamBase>;


template <typename StreamUnderlay = BinaryBufferStreamBase>
class BinaryIstream : public StreamUnderlay,
                      public BinaryIosBase // used as mixin
{
    typedef StreamUnderlay Base;

public:

    typedef typename Base::char_type char_type;
    typedef decltype(std::declval<Base>().rdbuf()) streambuffer_pointer;
    typedef typename StreamUnderlay::pos_type pos_type;

public:

    BinaryIstream(streambuffer_pointer buffer) : Base(buffer) {}

    BinaryIstream(Base& s) : Base(s.rdbuf()) {}

    BinaryIstream(Base& s, pos_type pos) : Base(s.rdbuf()) { this->seekg(pos); }

    BinaryIstream& operator>>(char* v)          { return stringFromBinary(v); }
    BinaryIstream& operator>>(std::string& v)   { return stringFromBinary(v); }
    BinaryIstream& operator>>(bool& v)          { return fromBinary<bool>(v);}
    BinaryIstream& operator>>(char& v)          { return fromBinary<char>(v);}
    BinaryIstream& operator>>(uint8& v)         { return fromBinary<uint8>(v);}
    BinaryIstream& operator>>(uint16& v)        { return fromBinary<uint16>(v);}
    BinaryIstream& operator>>(uint32& v)        { return fromBinary<uint32>(v);}
    BinaryIstream& operator>>(uint64& v)        { return fromBinary<uint64>(v);}
    BinaryIstream& operator>>(int8& v)          { return fromBinary<int8>(v);}
    BinaryIstream& operator>>(int16& v)         { return fromBinary<int16>(v);}
    BinaryIstream& operator>>(int32& v)         { return fromBinary<int32>(v);}
    BinaryIstream& operator>>(int64& v)         { return fromBinary<int64>(v);}
    BinaryIstream& operator>>(float& v)         { return fromBinary<float>(v);}
    BinaryIstream& operator>>(double& v)        { return fromBinary<double>(v);}
    template<typename T>
    BinaryIstream& operator>>(Buffer<T>& v) {
        uint64 size = 0;
        *this >> size;
        if(size!=0 && this->eof())
            MIRA_THROW(XIO, "Failed to read buffer from binary stream, premature end of stream");
        v.resize((std::size_t)size);
        read(v.data(), v.size());
        return *this;
    }

    BinaryIstream&
    operator>>(BinaryIosBase& (*manipFn) (BinaryIosBase&))
    {
        manipFn(*this); // call the manipulator
        return *this;
    }

public:

    template <typename T>
    void read(T* data, std::size_t count)
    {
        static_assert(sizeof(char_type)==1, "binaryistream must have char_type of size 1");
        Base::read(reinterpret_cast<char*>(data), count*sizeof(T));
    }


protected:

    template<typename T>
    BinaryIstream& fromBinary(T& value)
    {
        if(mFmtFlags & net) { // read in network byte order
            typename NetworkTypeTrait<T>::Type v;
            read(&v, 1);
            value = networkToHost<T>(v); // convert first
        } else // read in host byte order
            read(&value, 1);
        return *this;
    }

    BinaryIstream& stringFromBinary(char* value)
    {
        uint32 l;
        this->operator>>(l);  // read the length
        if(this->eof())
            MIRA_THROW(XIO, "Failed to read string from binary stream, premature end of stream");
        read(value, l);
        value[l]='\0';
        return *this;
    }

    BinaryIstream& stringFromBinary(std::string& value)
    {
        uint32 l;
        this->operator>>(l); // read the length

        if(this->eof())
            MIRA_THROW(XIO, "Failed to read string from binary stream, premature end of stream");

        value.resize(l);
        read((char*)value.c_str(), l);
        ((char*)value.c_str())[l]='\0';
        return *this;
    }
};

using BinaryStlIstream = BinaryIstream<std::basic_istream<char, std::char_traits<char>>>;

using BinaryBufferIstream = BinaryIstream<BinaryBufferStreamBase>;


inline BinaryIosBase& net(BinaryIosBase& stream)
{
    stream.setf(BinaryIosBase::net);
    return stream;
}

inline BinaryIosBase& host(BinaryIosBase& stream)
{
    stream.unsetf(BinaryIosBase::net); // remove net-format flag
    return stream;
}


}

#endif