BufferStream.hh

Go to the documentation of this file.

 
#ifndef CRL_MULTISENSE_BUFFERSTREAM_HH
#define CRL_MULTISENSE_BUFFERSTREAM_HH
 
#include "utility/Exception.hh"
#include "utility/TimeStamp.hh"
#include "utility/ReferenceCount.hh"
#include "utility/Portability.hh"
 
#include <stdint.h>
#include <cstddef>
#include <vector>
 
namespace crl {
namespace multisense {
namespace details {
namespace utility {
 
 
 
//
// The base storage class.
//
// To read/write from the stream, use the Reader/Writer
// derivatives below.
//
// SENSORPOD_FIRMWARE: microblaze build, no shared() interface
 
class BufferStream {
public:
 
    void        clear ()       { m_tell = 0;                  };
    std::size_t tell  () const { return m_tell;               };
    std::size_t size  () const { return m_size;               };
    void       *data  () const { return m_bufferP;            };
    void       *peek  () const { return &(m_bufferP[m_tell]); };
 
#ifndef SENSORPOD_FIRMWARE
    bool        shared() const { return m_ref.isShared();     };
#endif // SENSORPOD_FIRMWARE
 
    virtual void read (void *bufferP, std::size_t length) {
        (void) bufferP;
        (void) length;
        CRL_EXCEPTION("not implemented", "");
    };
    virtual void write(const void *bufferP, std::size_t length) {
        (void) bufferP;
        (void) length;
        CRL_EXCEPTION("not implemented", "");
    };
 
    //
    // Move the r/w pointer in the buffer, checking bounds
 
    void seek(std::size_t idx)  {
 
        if (idx > m_size)
            CRL_EXCEPTION("invalid seek location %lu, [0, %lu] valid\n",
                          idx, m_size);
        m_tell = idx;
    };
 
    //
    // Default constructor
 
    BufferStream() :
        m_alloced(false),
        m_size(0),
        m_tell(0),
        m_bufferP(NULL) {};
 
    //
    // Construction, we allocate memory
 
    BufferStream(std::size_t size) :
        m_alloced(false),
        m_size(size),
        m_tell(0),
        m_bufferP(NULL) {
 
        m_bufferP = new (std::nothrow) uint8_t[size];
        if (NULL == m_bufferP)
            CRL_EXCEPTION("unable to allocate %d bytes", size);
        m_alloced = true;
    };
 
    //
    // Construction, memory is already allocated
 
    BufferStream(uint8_t *bufP, std::size_t size) :
        m_alloced(false),
        m_size(size),
        m_tell(0),
        m_bufferP(bufP) {};
 
    //
    // Destruction, free memory only if we allocated
 
    virtual ~BufferStream() {
#ifdef SENSORPOD_FIRMWARE
        if (m_alloced)
#else
        if (m_alloced && false == m_ref.isShared())
#endif // SENSORPOD_FIRMWARE
            delete[] m_bufferP;
    };
 
    //
    // Copy constructor
 
    BufferStream(const BufferStream& source) {
        m_alloced = source.m_alloced;
        m_size    = source.m_size;
        m_tell    = 0;  // reset
        m_bufferP = source.m_bufferP;
 
#ifndef SENSORPOD_FIRMWARE
        m_ref     = source.m_ref;
#endif // SENSORPOD_FIRMWARE
    };
 
        //
        // Assignment Operator
 
    BufferStream& operator=(const BufferStream& source) {
        m_alloced = source.m_alloced;
        m_size    = source.m_size;
        m_tell    = 0;  // reset
        m_bufferP = source.m_bufferP;
 
#ifndef SENSORPOD_FIRMWARE
        m_ref     = source.m_ref;
#endif // SENSORPOD_FIRMWARE
 
        return *this;
    };
 
protected:
 
    bool         m_alloced;
    std::size_t  m_size;
    std::size_t  m_tell;
    uint8_t     *m_bufferP;
 
#ifndef SENSORPOD_FIRMWARE
    ReferenceCount m_ref;
#endif // SENSORPOD_FIRMWARE
};
 
//
// The input (deserialization) implementation. Must operate on
// non-const data.
 
class BufferStreamReader : public BufferStream {
public:
 
    BufferStreamReader() : BufferStream() {};
    BufferStreamReader(BufferStream& s) : BufferStream(s) {};
    BufferStreamReader(const uint8_t *p, std::size_t s) : BufferStream(const_cast<uint8_t*>(p), s) {};
    BufferStreamReader(std::size_t s) : BufferStream(s) {};
 
    virtual void read (void *bufferP, std::size_t length) {
 
        if (length > (m_size - m_tell))
            CRL_EXCEPTION("read overflow: tell=%d, size=%d, length=%d\n",
                          m_tell, m_size, length);
 
        memcpy(bufferP, &(m_bufferP[m_tell]), length);
        m_tell += length;
    }
 
    template <typename T> BufferStreamReader& operator&(T &value) {
        this->read(&value, sizeof(T));
        return *this;
    }
 
    template <typename T> BufferStreamReader& operator&(std::vector<T>& v) {
        uint16_t version;
        uint32_t num;
        *this & version;
        *this & num;
        v.resize(num);
        for(uint32_t i=0; i<num; i++)
            v[i].serialize(*this, version);
        return *this;
    }
 
    BufferStreamReader& operator&(std::string& value) {
        uint16_t length;
 
        this->read(&length, sizeof(length));
        if (length > 512)
            CRL_EXCEPTION("unusually large string: %d bytes",
                                   length);
        else if (length > 0) {
            char buffer[512+1]; // length is guaranteed to be less than or equal to 512
            buffer[length] = '\0';
            this->read(buffer, length);
            value = std::string(buffer);
        }
        return *this;
    }
 
    BufferStreamReader& operator&(TimeStamp& value) {
        uint32_t seconds;
        uint32_t microseconds;
 
        this->read(&seconds, sizeof(seconds));
        this->read(&microseconds, sizeof(microseconds));
 
        value.set(seconds, microseconds);
 
        return *this;
    }
};
 
//
// The output (serialization) implementation. Able to operate
// purely on const data.
 
class BufferStreamWriter : public BufferStream {
public:
 
    BufferStreamWriter() : BufferStream() {};
    BufferStreamWriter(BufferStream& s) : BufferStream(s) {};
    BufferStreamWriter(uint8_t *b, std::size_t s) : BufferStream(b, s) {};
    BufferStreamWriter(std::size_t s) : BufferStream(s) {};
 
    virtual void write(const void *bufferP, std::size_t length) {
 
        if ((length + m_tell) > m_size)
            CRL_EXCEPTION("write overflow: tell=%d, size=%d, length=%d\n",
                          m_tell, m_size, length);
 
        memcpy(&(m_bufferP[m_tell]), bufferP, length);
        m_tell += length;
    };
 
    template <typename T> BufferStreamWriter& operator&(const T& value) {
        this->write(&value, sizeof(T));
        return *this;
    }
 
    template <typename T> BufferStreamWriter& operator&(const std::vector<T>& v) {
        uint16_t version = T::VERSION;
        uint32_t num     = static_cast<uint32_t> (v.size());
        *this & version;
        *this & num;
        for(uint32_t i=0; i<num; i++)
            const_cast<T*>(&v[i])->serialize(*this, version);
        return *this;
    }
 
    BufferStreamWriter& operator&(const std::string& value) {
        size_t length = value.size();
 
        if (length > 512)
            CRL_EXCEPTION("unusually large string: %d bytes", length);
 
        uint16_t length16 = static_cast<uint16_t> (length);
        this->write(&length16, sizeof(length16));
 
        if (length > 0)
            this->write(value.c_str(), length);
        return *this;
    };
 
    BufferStreamWriter& operator&(const TimeStamp& value) {
        const uint32_t seconds      = value.getSeconds();
        const uint32_t microseconds = value.getMicroSeconds();
 
        this->write(&seconds, sizeof(seconds));
        this->write(&microseconds, sizeof(microseconds));
 
        return *this;
    };
};
 
}}}} // namespaces
 
#endif /* #ifndef CRL_MULTISENSE_BUFFERSTREAM_HH */