FrameIterator.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_STREAM_FRAME_ITERATOR_H__
#define __ROGUE_INTERFACES_STREAM_FRAME_ITERATOR_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <cstring>
#include <memory>
#include <vector>
 
namespace rogue {
namespace interfaces {
namespace stream {
 
class Frame;
class Buffer;
 
class FrameIterator : public std::iterator<std::random_access_iterator_tag, uint8_t> {
    friend class Frame;
 
  private:
    // Creator
    FrameIterator(std::shared_ptr<rogue::interfaces::stream::Frame> frame, bool write, bool end);
 
    // write flag
    bool write_;
 
    // Associated frame
    std::shared_ptr<rogue::interfaces::stream::Frame> frame_;
 
    // Frame position
    int32_t framePos_;
 
    // Frame size
    int32_t frameSize_;
 
    // current buffer
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator buff_;
 
    // Buffer position
    int32_t buffBeg_;
 
    // Buffer size
    int32_t buffEnd_;
 
    // Current buffer iterator
    uint8_t* data_;
 
    // increment position
    inline void increment(int32_t diff);
 
    // decrement position
    inline void decrement(int32_t diff);
 
  public:
    FrameIterator();
 
    const rogue::interfaces::stream::FrameIterator operator=(const rogue::interfaces::stream::FrameIterator& rhs);
 
    rogue::interfaces::stream::FrameIterator endBuffer();
 
    uint32_t remBuffer();
 
    uint8_t& operator*() const;
 
    // uint8_t * operator ->() const;
 
    uint8_t* ptr() const;
 
    uint8_t operator[](const uint32_t offset) const;
 
    const rogue::interfaces::stream::FrameIterator& operator++();
 
    rogue::interfaces::stream::FrameIterator operator++(int);
 
    const rogue::interfaces::stream::FrameIterator& operator--();
 
    rogue::interfaces::stream::FrameIterator operator--(int);
 
    bool operator!=(const rogue::interfaces::stream::FrameIterator& other) const;
 
    bool operator==(const rogue::interfaces::stream::FrameIterator& other) const;
 
    bool operator<(const rogue::interfaces::stream::FrameIterator& other) const;
 
    bool operator>(const rogue::interfaces::stream::FrameIterator& other) const;
 
    bool operator<=(const rogue::interfaces::stream::FrameIterator& other) const;
 
    bool operator>=(const rogue::interfaces::stream::FrameIterator& other) const;
 
    rogue::interfaces::stream::FrameIterator operator+(const int32_t add) const;
 
    rogue::interfaces::stream::FrameIterator operator-(const int32_t sub) const;
 
    int32_t operator-(const rogue::interfaces::stream::FrameIterator& other) const;
 
    rogue::interfaces::stream::FrameIterator& operator+=(const int32_t add);
 
    rogue::interfaces::stream::FrameIterator& operator-=(const int32_t sub);
};
 
static inline void toFrame(rogue::interfaces::stream::FrameIterator& iter, uint32_t size, void* src) {
    uint8_t* ptr = reinterpret_cast<uint8_t*>(src);
    uint32_t csize;
 
    do {
        csize = (size > iter.remBuffer()) ? iter.remBuffer() : size;
        std::memcpy(iter.ptr(), ptr, csize);
        ptr += csize;
        iter += csize;
        size -= csize;
    } while (size > 0 && csize > 0);
}
 
static inline void fromFrame(rogue::interfaces::stream::FrameIterator& iter, uint32_t size, void* dst) {
    uint8_t* ptr = reinterpret_cast<uint8_t*>(dst);
    uint32_t csize;
 
    do {
        csize = (size > iter.remBuffer()) ? iter.remBuffer() : size;
        std::memcpy(ptr, iter.ptr(), csize);
        ptr += csize;
        iter += csize;
        size -= csize;
    } while (size > 0 && csize > 0);
}
 
static inline void copyFrame(rogue::interfaces::stream::FrameIterator& srcIter,
                             uint32_t size,
                             rogue::interfaces::stream::FrameIterator& dstIter) {
    uint32_t csize;
 
    do {
        csize = (size > srcIter.remBuffer()) ? srcIter.remBuffer() : size;
        csize = (csize > dstIter.remBuffer()) ? dstIter.remBuffer() : csize;
        std::memcpy(dstIter.ptr(), srcIter.ptr(), csize);
        srcIter += csize;
        dstIter += csize;
        size -= csize;
    } while (size > 0 && csize > 0);
}
}  // namespace stream
}  // namespace interfaces
}  // namespace rogue
 
#endif