FrameIterator.cpp

Go to the documentation of this file.

 
#include "rogue/interfaces/stream/FrameIterator.h"
 
#include "rogue/interfaces/stream/Buffer.h"
#include "rogue/interfaces/stream/Frame.h"
 
namespace ris = rogue::interfaces::stream;
 
ris::FrameIterator::FrameIterator(ris::FramePtr frame, bool write, bool end) {
    write_     = write;
    frame_     = frame;
    frameSize_ = (write_) ? frame_->getSize() : frame_->getPayload();
 
    // end iterator
    if (end) {
        buff_     = frame_->endBuffer();
        framePos_ = frameSize_;
        buffBeg_  = frameSize_;
        buffEnd_  = frameSize_;
        data_     = NULL;
    } else {
        buff_     = frame_->beginBuffer();
        framePos_ = 0;
        buffBeg_  = 0;
        buffEnd_  = (write_) ? (*buff_)->getSize() : (*buff_)->getPayload();
        data_     = (*buff_)->begin();
    }
}
 
void ris::FrameIterator::increment(int32_t diff) {
    framePos_ += diff;
    data_ += diff;
 
    // Past end of buffer
    if (framePos_ >= buffEnd_) {
        // Past end of frame
        if (framePos_ >= frameSize_) {
            framePos_ = frameSize_;
            buffBeg_  = frameSize_;
            buffEnd_  = frameSize_;
            buff_     = frame_->endBuffer();
            data_     = NULL;
 
            // Move forward in buffer chain
        } else {
            // Increment current buffer until we find the location of the data position
            // Iterator always contains one extra buffer index
            while (framePos_ >= buffEnd_) {
                buff_++;
                buffBeg_ = buffEnd_;
                buffEnd_ += (write_) ? (*buff_)->getSize() : (*buff_)->getPayload();
            }
 
            // Set pointer
            data_ = (*buff_)->begin() + (framePos_ - buffBeg_);
        }
    }
}
 
void ris::FrameIterator::decrement(int32_t diff) {
    framePos_ += diff;
    data_ += diff;
 
    // Before start of buffer
    if (framePos_ < buffBeg_) {
        // Before beginning of frame
        if (framePos_ < 0) {
            framePos_ = frameSize_;
            buffBeg_  = frameSize_;
            buffEnd_  = frameSize_;
            buff_     = frame_->endBuffer();
            data_     = NULL;
 
            // Move backwards in buffer chain
        } else {
            // Decrement current buffer until the desired frame position is greater than
            // the bottom of the buffer
            while (framePos_ < buffBeg_) {
                buff_--;
                buffEnd_ = buffBeg_;
                buffBeg_ -= (write_) ? (*buff_)->getSize() : (*buff_)->getPayload();
            }
 
            // Set pointer
            data_ = (*buff_)->begin() + (framePos_ - buffBeg_);
        }
    }
}
 
ris::FrameIterator::FrameIterator() {
    write_     = false;
    framePos_  = 0;
    frameSize_ = 0;
    buffBeg_   = 0;
    buffEnd_   = 0;
    data_      = NULL;
}
 
const ris::FrameIterator ris::FrameIterator::operator=(const ris::FrameIterator& rhs) {
    this->write_     = rhs.write_;
    this->frame_     = rhs.frame_;
    this->framePos_  = rhs.framePos_;
    this->frameSize_ = rhs.frameSize_;
    this->buff_      = rhs.buff_;
    this->buffBeg_   = rhs.buffBeg_;
    this->buffEnd_   = rhs.buffEnd_;
    this->data_      = rhs.data_;
    return *this;
}
 
ris::FrameIterator ris::FrameIterator::endBuffer() {
    ris::FrameIterator ret(*this);
    ret.increment(buffEnd_ - framePos_);
    return ret;
}
 
uint32_t ris::FrameIterator::remBuffer() {
    return (buffEnd_ - framePos_);
}
 
uint8_t& ris::FrameIterator::operator*() const {
    return *data_;
}
 
// uint8_t * ris::FrameIterator::operator ->() const {
// return data_;
//}
 
uint8_t* ris::FrameIterator::ptr() const {
    return data_;
}
 
uint8_t ris::FrameIterator::operator[](const uint32_t offset) const {
    ris::FrameIterator ret(*this);
    ret.increment(static_cast<int32_t>(offset));
    return *ret;
}
 
const ris::FrameIterator& ris::FrameIterator::operator++() {
    this->increment(1);
    return *this;
}
 
ris::FrameIterator ris::FrameIterator::operator++(int) {
    ris::FrameIterator ret(*this);
    this->increment(1);
    return ret;
}
 
const ris::FrameIterator& ris::FrameIterator::operator--() {
    this->decrement(-1);
    return *this;
}
 
ris::FrameIterator ris::FrameIterator::operator--(int) {
    ris::FrameIterator ret(*this);
    this->decrement(-1);
    return ret;
}
 
bool ris::FrameIterator::operator!=(const ris::FrameIterator& other) const {
    return (this->framePos_ != other.framePos_);
}
 
bool ris::FrameIterator::operator==(const ris::FrameIterator& other) const {
    return (this->framePos_ == other.framePos_);
}
 
bool ris::FrameIterator::operator<(const ris::FrameIterator& other) const {
    return (this->framePos_ < other.framePos_);
}
 
bool ris::FrameIterator::operator>(const ris::FrameIterator& other) const {
    return (this->framePos_ > other.framePos_);
}
 
bool ris::FrameIterator::operator<=(const ris::FrameIterator& other) const {
    return (this->framePos_ <= other.framePos_);
}
 
bool ris::FrameIterator::operator>=(const ris::FrameIterator& other) const {
    return (this->framePos_ >= other.framePos_);
}
 
ris::FrameIterator ris::FrameIterator::operator+(const int32_t add) const {
    ris::FrameIterator ret(*this);
    if (add > 0)
        ret.increment(add);
    else
        ret.decrement(add);
    return ret;
}
 
ris::FrameIterator ris::FrameIterator::operator-(const int32_t sub) const {
    ris::FrameIterator ret(*this);
    if (sub > 0)
        ret.decrement(-1 * sub);
    else
        ret.increment(-1 * sub);
    return ret;
}
 
int32_t ris::FrameIterator::operator-(const ris::FrameIterator& other) const {
    return (this->framePos_ - other.framePos_);
}
 
ris::FrameIterator& ris::FrameIterator::operator+=(const int32_t add) {
    if (add > 0)
        this->increment(add);
    else
        this->decrement(add);
    return *this;
}
 
ris::FrameIterator& ris::FrameIterator::operator-=(const int32_t sub) {
    if (sub > 0)
        this->decrement(-1 * sub);
    else
        this->increment(-1 * sub);
    return *this;
}