buffer_queue.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_buffer_queue_h
#define INCL_evo_buffer_queue_h

#include "type.h"

namespace evo {


template<class T, class TSize=SizeT>
class BufferQueue {
public:
    typedef BufferQueue<T,TSize> This;      
    typedef TSize Size;                     
    typedef T     Item;                     

    static const Size MIN_SIZE     = 2;     
    static const Size DEFAULT_SIZE = 128;   

    BufferQueue(Size size=DEFAULT_SIZE) {
        size = adjust_size(size);
        buf_       = new T[size];
        size_      = size;
        size_mask_ = size - 1;
        used_      = 0;
        start_     = 0;
    }

    BufferQueue(const This& src) {
        buf_       = new T[src.size_];
        size_      = src.size_;
        size_mask_ = src.size_mask_;
        used_      = src.used_;
        start_     = src.start_;
        copydata(src);
    }

    ~BufferQueue() {
        delete [] buf_;
    }

    Size size() const {
        return size_;
    }

    Size used() const {
        return used_;
    }

    bool empty() const {
        return (used_ == 0);
    }

    bool full() const {
        return (used_ >= size_);
    }

    void clear() {
        used_  = 0;
        start_ = 0;
    }

    bool add(const T& item, bool force=false) {
        if (used_ < size_) {
            buf_[((uint64)start_ + used_) & size_mask_] = item;
            ++used_;
            return true;
        } else if (force) {
            buf_[start_] = item;
            start_ = (start_ + 1) & size_mask_;
        }
        return false;
    }

    T* advAdd(bool force=false) {
        if (used_ < size_) {
            return buf_ + (((uint64)start_ + used_++) & size_mask_);
        } else if (force) {
            T* item = buf_ + start_;
            start_ = (start_ + 1) & size_mask_;
            return item;
        }
        return NULL;
    }

    const T& peek() const {
        return buf_[start_];
    }

    const T* peek(Size& size) const {
        if (used_ > 0) {
            size = size_ - start_;
            if (size > used_)
                size = used_;
            return buf_ + start_;
        }
        size = 0;
        return NULL;
    }

    bool pop(T& item) {
        if (used_ > 0) {
            item = buf_[start_];
            start_ = (start_ + 1) & size_mask_;
            --used_;
            return true;
        }
        return false;
    }

    bool pop() {
        if (used_ > 0) {
            start_ = (start_ + 1) & size_mask_;
            --used_;
            return true;
        }
        return false;
    }

    Size pop_size(Size size) {
        if (used_ > 0) {
            if (size > used_)
                size = used_;
            start_ = (Size)(((uint64)start_ + size) & size_mask_);
            used_ -= size;
            return size;
        }
        return 0;
    }

    This& operator=(const This& src) {
        if (size_ != src.size_) {
            delete [] buf_;
            buf_       = new T[src.size_];
            size_mask_ = src.size_mask_;
            size_      = src.size_;
        }
        used_  = src.used_;
        start_ = src.start_;
        copydata(src);
        return *this;
    }

private:
    T*   buf_;
    Size size_;
    Size size_mask_;
    Size used_;
    Size start_;

    // This assumes buf_ is allocated and everything but buf_ data has been copied
    void copydata(const This& src) {
        if (used_ > 0) {
            Size copysize = size_ - start_;
            DataInit<T>::copy(buf_ + start_, src.buf_ + start_, copysize);
            if (copysize < used_) {
                copysize = used_ - copysize;
                DataInit<T>::copy(buf_, src.buf_, copysize);
            }
        }
    }

    // Make sure size is a power of 2
    static Size adjust_size(Size size) {
        assert( !IntegerT<Size>::SIGN );
        const Size MAX_SIZE = (IntegerT<Size>::MAX >> 1) + 1;
        if (size <= MIN_SIZE) {
            size = MIN_SIZE;
        } else if (size >= MAX_SIZE) {
            size = MAX_SIZE;
        } else {
            const Size targetsize = size;
            size = MIN_SIZE;
            while (size < targetsize)
                size <<= 1;
        }
        return size;
    }
};


}
#endif