环形缓冲区-boost circular buffer & 读写锁(shared_mutex)

在涉及到缓存差值点数据的时候，一般会使用circular_buffer来实现。

It is a kind of sequence similar to std::list or std::deque. It supports random access iterators, constant time insert and erase operations at the beginning or the end of the buffer and interoperability with std algorithms.

#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>  // 读写锁
#include <boost/circular_buffer.hpp>
template<typename T>
class MyCircularBuffer
{
public:
    MyCircularBuffer(int size) :
            buffer_(size)
    {
    };
    bool push_back(const T& item)
    {
        boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
        if (buffer_.capacity() == 0)
            return false;

        if (!buffer_.full())
        {
            buffer_.push_back(item);
            return true;
        }
    };
    bool push_front(const T& item)
    {
        boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
        if (buffer_.capacity() == 0)
            return false;
        buffer_.push_front(item);
        return true;
    };
    void clear()
    {
        boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
        buffer_.clear();
    };
    T& front()
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        return buffer_.front();
    };
    void pop_front()
    {
        boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
        buffer_.pop_front();
    };
    void pop_back()
    {
        boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
        buffer_.pop_back();
    };
    unsigned int size()
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        return buffer_.size();
    };
    bool empty()
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        return buffer_.empty();
    };
    bool full()
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        return buffer_.full();
    };
    T& at(size_t index)
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        try
        {
            buffer_.at(index);
        }
        catch(std::out_of_range& ex)
        {
            throw(ex);
        }
        return buffer_[index];
    };
    T& operator[](size_t index)
    {
        boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
        return buffer_[index];
    };
private:
    boost::circular_buffer<T> buffer_;
    boost::shared_mutex  buffer_mutex_;

};

example:

#include <boost/circular_buffer.hpp>
#include <iostream>

int main()
{
  typedef boost::circular_buffer<int> circular_buffer;
  circular_buffer cb{3};  // c++11 统一初始化方式

  std::cout << cb.capacity() << '\n';
  std::cout << cb.size() << '\n';

  cb.push_back(0);
  cb.push_back(1);
  cb.push_back(2);

  std::cout << cb.size() << '\n';

  cb.push_back(3);
  cb.push_back(4);
  cb.push_back(5);

  std::cout << cb.size() << '\n';

  for (int i : cb)
    std::cout << i << '\n';
}