ringBuffer.h

#ifndef RING_BUFFER_H
#define RING_BUFFER_H

/*
  ・ー・ミ・テ・ユ・。
  Satofumi KAMIMURA
  $Id$
*/


template<class C> class RingBuffer {
  typedef unsigned long size_type;
  size_type real_size;
  size_type first;
  size_type last;
  C *buffer;
  RingBuffer(void);
 
public:
  RingBuffer(size_type size) : real_size(1), first(0), last(0) {
    while (size > (real_size -1)) {
      real_size <<= 1;
    }
    buffer = new C[real_size];
  }
    
  ~RingBuffer(void) {
    delete [] buffer;
  }
 
  size_type size(void) {
    return (last >= first) ? last - first : real_size - (first - last);
  }
  
  size_type free_size(void) {
    return real_size -1 - size();
  }
  
  void put(const C* data, size_type size) {
    size_type free_length = free_size();
    size_type len = (size > free_length) ? free_length : size;

    size_type put_end = (len > (real_size - last)) ? real_size : last + len;
    C *p = &buffer[last];
    C *q = (C *)data;
    for (size_type i = last; i < put_end; ++i) {
      *p++ = *q++;
    }

    C *data_last = (C *)data + len;
    if (q < data_last) {
      p = &buffer[0];
      while (q < data_last) {
        *p++ = *q++;
      }
    }
    last = (p - buffer) & (real_size -1);
  }
  
  void get(C* data, size_type size) {
    size_type filled_length = this->size();
    size_type len = (size > filled_length) ? filled_length : size;

    size_type get_end = (len > (real_size - first)) ? real_size : first + len;
    C *p = data;
    C *q = &buffer[first];
    for (size_type i = first; i < get_end; ++i) {
      *p++ = *q++;
    }

    C *data_last = data + len;
    if (p < data_last) {
      while (p < data_last) {
        *p++ = *q++;
      }
    }
    first = (q - buffer) & (real_size -1);
  }

  void clear(void) {
    first = 0;
    last = 0;
  }
};


#endif /* !RING_BUFFER_H */