---

ixlib_ring_queue.hh

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//  Description      : Ring queue container
// ----------------------------------------------------------------------------
//  (c) Copyright 1999 by iXiONmedia, all rights reserved.
// ----------------------------------------------------------------------------




#ifndef IXLIB_RING_QUEUE
#define IXLIB_RING_QUEUE




#include <ixlib_numeric.hh>
#include <ixlib_array.hh>




namespace ixion {
  template<class T,class Allocator = std::allocator<T> >
  class ring_queue {
    private:
      auto_array<T,Allocator>           Data;
      TIndex                            Head;
      TIndex                            Tail;
    
    public:
      ring_queue(TIndex capacity = 0)
        : Data(capacity),Head(0),Tail(0) {
        }
      
      TSize capacity() const {
        return Data.capacity();
        }
      
      TSize size() const {
        return NUM_CIRCLEDIST(Head,Tail,Data.capacity());
        }
      

      inline TSize pop(T *data,TSize maxcount = 1);
      
      inline void push(T *data,TSize count = 1);
      

      inline T *popPointer(TSize &maxcount);
      
      inline void popPointerCommit(TSize count);


      inline T *pushPointer(TSize &maxcount);
      
      inline void pushPointerCommit(TSize count);
      
      inline void allocate(TSize capacity) {
        Data.allocate(capacity);
        Head = 0;
        Tail = 0;
        }
    };
  }




template<class T,class Allocator>
ixion::TSize ixion::ring_queue<T,Allocator>::pop(T *data,TSize maxcount) {
  while (count) {
    TSize loopmax;
    T *buffer = popPointer(loopmax);
    if (loopmax == 0)
      EXGEN_THROW(EC_BUFFERUNDERFLOW)
    
    TSize countdown = loopmax;
    while (countdown--)
      *data++ = *buffer++;

    popPointerCommit(loopmax);
    count -= loopmax;
    }
  }




template<class T,class Allocator>
void ixion::ring_queue<T,Allocator>::push(T *data,TSize count) {
  TSize result = 0;
  while (count) {
    TSize loopmax;
    T *buffer = pushPointer(loopmax);
    if (loopmax == 0) break;
    
    TSize countdown = loopmax;
    while (countdown--)
      *buffer++ = *data++;

    pushPointerCommit(loopmax);
    count -= loopmax;
    result += loopmax;
    }
  return result;
  }




template<class T,class Allocator>
T *ixion::ring_queue<T,Allocator>::popPointer(TSize &maxcount) {
  if (Tail <= Head)
    maxcount = Head-Tail;
  else
    maxcount = Data.capacity() - Tail;
  return Data+Tail;
  }




template<class T,class Allocator>
void ixion::ring_queue<T,Allocator>::popPointerCommit(TSize count) {
  Tail = (Tail+count) % Data.capacity();
  }




template<class T,class Allocator>
T *ixion::ring_queue<T,Allocator>::pushPointer(TSize &maxcount) {
  if (Tail <= Head) {
    maxcount = Data.capacity() - Head;
    if (Tail == 0 && maxcount > 0) maxcount--;
    }
  else
    // we may not fill the buffer entirely, as head == tail means "empty"!
    maxcount = Tail - Head - 1;
  return Data+Head;
  }




template<class T,class Allocator>
void ixion::ring_queue<T,Allocator>::pushPointerCommit(TSize count) {
  Head = (Head+count) % Data.capacity();
  }




#endif

---