circular_buffer

gistfile1.cpp

#ifndef __CIRCULAR_BUFFER_H__
#define __CIRCULAR_BUFFER_H__

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif

#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif

// 无锁缓冲队列.
class circular_buffer
{
public:
   circular_buffer(int buf_size)
      : m_buffer_size(buf_size)
      , m_circle_buffer(NULL)
      , m_write_p(0)
      , m_read_p(0)
   {
      m_circle_buffer = new char[m_buffer_size];
   }

   ~circular_buffer()
   {
      if (m_circle_buffer)
         delete[] m_circle_buffer;
      m_circle_buffer = NULL;
   }

   void clear()
   {
      m_write_p = 0;
      m_read_p = 0;
   }

   unsigned int size()
   {
      return m_buffer_size - (m_write_p - m_read_p);
   }

   unsigned int used()
   {
      return m_write_p - m_read_p;
   }

   unsigned int put_data(char* buffer, unsigned int len)
   {
      unsigned int l;
      len = _min(len, m_buffer_size - m_write_p + m_read_p);
      /* first put the data starting from fifo->in to buffer end */
      l = _min(len, m_buffer_size - (m_write_p & (m_buffer_size - 1)));
      memcpy(m_circle_buffer + (m_write_p & (m_buffer_size - 1)), buffer, l);
      /* then put the rest (if any) at the beginning of the buffer */
      memcpy(m_circle_buffer, buffer + l, len - l);
      m_write_p += len;
      return len;
   }

   unsigned int get_data(char* buffer, unsigned int len)
   {
      unsigned int l; 
      len = _min(len, m_write_p - m_read_p); 
      /* first get the data from fifo->out until the end of the buffer */ 
      l = _min(len, m_buffer_size - (m_read_p & (m_buffer_size - 1))); 
      memcpy(buffer, m_circle_buffer + (m_read_p & (m_buffer_size - 1)), l); 
      /* then get the rest (if any) from the beginning of the buffer */ 
      memcpy(buffer + l, m_circle_buffer, len - l); 
      m_read_p += len; 
      return len; 
   }

protected:
   inline unsigned int _max(unsigned int a, unsigned int b)
   {
      return max(a, b);
   }

   inline unsigned int _min(unsigned int a, unsigned int b)
   {
      return min(a, b);
   }

private:
   int m_buffer_size;
   char* m_circle_buffer;
   unsigned int m_write_p;
   unsigned int m_read_p;
};

#endif // __CIRCULAR_BUFFER_H__