circularbufferposition.h

来自「C++封装的视频采集代码」· C头文件 代码 · 共 166 行

#ifndef CIRCULARBUFFERPOSITION_H
#define CIRCULARBUFFERPOSITION_H

namespace oxsemi
{
    namespace circular_buffer
    {
        class CircularBufferPosition
        {
        public:
            // Size of encoded representation, with any padding required to be a
            // multiple of the size of a quad
            static const unsigned long ENCODED_SIZE = (sizeof(unsigned long) * 3);

            explicit CircularBufferPosition(
                unsigned long maxOffset = 0,
                unsigned long offset = 0,
                unsigned long loopCount = 0);

            static CircularBufferPosition DecodeFromBuffer(const unsigned char* buffer);

            void EncodeToBuffer(unsigned char* buffer) const;

            bool operator==(const CircularBufferPosition& rhs) const;

            bool operator<(const CircularBufferPosition& rhs) const;

            CircularBufferPosition& operator-=(const CircularBufferPosition& rhs);

            CircularBufferPosition& operator-=(unsigned long offset);

            const CircularBufferPosition operator-(unsigned long offset);

            CircularBufferPosition& operator+=(unsigned long offset);

            const CircularBufferPosition operator+(unsigned long offset);

            void operator++();

            CircularBufferPosition operator++(int);

            unsigned long GetLoopCount() const;

            unsigned long GetMargin() const;

            unsigned long GetOffset() const;

            void Zeroise(unsigned long maxOffset);

            friend CircularBufferPosition operator-(
                const CircularBufferPosition& lhs,
                const CircularBufferPosition& rhs);

        private:
            unsigned long maxOffset_;
            unsigned long offset_;
            unsigned long loopCount_;
        };

        inline bool CircularBufferPosition::operator==(const CircularBufferPosition& rhs) const
        {
            return (loopCount_ == rhs.loopCount_) && (offset_ == rhs.offset_);
        }

        inline bool CircularBufferPosition::operator<(const CircularBufferPosition& rhs) const
        {
            return (loopCount_ < rhs.loopCount_) || ((loopCount_ == rhs.loopCount_) && (offset_ < rhs.offset_));
        }

        inline CircularBufferPosition& CircularBufferPosition::operator+=(unsigned long offset)
        {
            if (offset)
            {
                unsigned long margin = GetMargin();
                if (margin > offset)    // Changed
                {
                    offset_ += offset;
                }
                else
                {
                    ++loopCount_;
                    offset_ = offset - margin;
                }
            }
            return *this;
        }

        inline const CircularBufferPosition CircularBufferPosition::operator+(unsigned long offset)
        {
            return CircularBufferPosition(*this) += offset;
        }

        inline CircularBufferPosition& CircularBufferPosition::operator-=(const CircularBufferPosition& rhs)
        {
            loopCount_ -= rhs.loopCount_;

            if (rhs.offset_ <= offset_)
            {
                offset_ -= rhs.offset_;
            }
            else
            {
                --loopCount_;
                offset_ = maxOffset_ - (rhs.offset_ - offset_) + 1; // Changed (again)
            }
            return *this;
        }

        inline CircularBufferPosition& CircularBufferPosition::operator-=(unsigned long offset)
        {
            operator-=(CircularBufferPosition(0, offset, 0));
            return *this;
        }

        inline const CircularBufferPosition CircularBufferPosition::operator-(unsigned long offset)
        {
            return CircularBufferPosition(*this) -= offset;
        }

        inline void CircularBufferPosition::operator++()
        {
            if (offset_ == maxOffset_)
            {
                ++loopCount_;
                offset_ = 0;
            }
            else
            {
                ++offset_;
            }
        }

        inline CircularBufferPosition CircularBufferPosition::operator++(int)
        {
            CircularBufferPosition temp(*this);
            operator++();
            return temp;
        }

        inline unsigned long CircularBufferPosition::GetLoopCount() const
        {
            return loopCount_;
        }

        inline unsigned long CircularBufferPosition::GetMargin() const
        {
            return maxOffset_ ? maxOffset_ - offset_ + 1 : 0;
        }

        inline unsigned long CircularBufferPosition::GetOffset() const
        {
            return offset_;
        }

        inline CircularBufferPosition operator-(
            const CircularBufferPosition& lhs,
            const CircularBufferPosition& rhs)
        {
            return CircularBufferPosition(lhs) -= rhs;
        }
    }
}

#endif        //  #if !defined(__CIRCULARBUFFERPOSITION_H__)