/simpletypesystem/trunk

#include "RingBuffer.h"

/* These are just to reduce code redundancy.
 */
#define err_on_full(S, E) {\
  if (self->len >= S->size) {\
    E = TRUE;\
    s_err_print ("Buffer full. Needs to be reallocated.\n"\
                 "    (This is not done automatically. Returning.)");\
    return;\
  }\
}

#define err_seems_full(E) {\
  s_err_print ("Array seems to be full... Returning.");\
  E = TRUE;\
  return;\
}

#define err_on_empty(S, E) {\
  if (s_ring_buffer_is_empty (S)) {\
    s_warn_print ("Ring buffer is empty, nothing to return");\
    E = TRUE;\
    return 0;\
  }\
}


struct SRingBuffer {
  size_t size;   /* The number of elemets in the array */
  size_t len;    /* The "length" of the buffered data */
  
  size_t start;  /* The index of the "first" element in the buffer in the array
                  */
  size_t end;    /* The index of the "last" element in the buffer in the array
                  */
  
  sbyte * array; /* The array that is used to implement the buffer */
}


SRingBuffer *
s_ring_buffer_new (size_t len) {
  SRingBuffer * self = s_malloc (sizeof (SRingBuffer));
  self->array = s_calloc (len, size_t (sbyte));
  
  self->size = size;
  self->start = 0;
  self->end = 0;
  self->len = 0;
  
  return self;
}


void
s_ring_buffer_free (SRingBuffer * self) {
  s_free (self->array);
  s_free (self);
}

sboolean
s_ring_buffer_is_empty (SRingBuffer * self) {
  /* If the data data two pointers are the same and the the length is zero,
   * the array is most likely empty... */
  return ((self->start == self->end) && self->len == 0 );
}

void
s_ring_buffer_push (SRingBuffer * self,
                    sbyte data,
                    sboolean * err) {
  *err = FALSE;
  err_on_full (self, *err);
  /* The buffer should only have three different states so this should do.
   *    (exept there are five states... Idiot...)
   *
   * The first state here is the normal state where the end is after the start.
   *
   * The second state is when the end pointer is at the end of the array.
   *   This has two substates, one where the array is full (the start pointer
   *   is zero and the end pointer points to the last lement of the array), the
   *   second state is when the stat pointer does not point to zero and is thus
   *   free to use so we set the end pointer to zero.
   *
   * The third state is when the array loops back on itself (see headerfile).
   *   This has two substates, one where the next element that should be set is
   *   actially the start element, thus the array is full. The second substates
   *   is when that is not true and we can use that slot.
   */
  if (self->end <= self->size) {
    self->end = self->end + 1;
  } else if (self->end == self->size) {
    if (self->start == 0) {
      err_seems_full (*err);
    } else {
      self->end = 0;
    }
  } else if (self->end < self->start) {
    if ((self->end + 1) == self->start ) {
      err_seems_full (*err);
    } else {
      self->end = self->end + 1;
    }
  } else {
    /* This is an unknown state... some bad shit has gone down if you end up
    * here */
    s_err_print ("Reaching a place that should not be reached. Returning");
    *err = TRUE;
    return;
  }
  self->len = self->len + 1;
  self->array[self->end] = data;
}


void
s_ring_buffer_push_front (SRingBuffer * self,
                          sbyte data,
                          sboolean * err) {
  *err = FALSE;
  err_on_full (self, *err);
  
  /* This is pretty much the same as s_ring_buffer_push (), save for the states
   * beeing in a different order order is different to make it actially work as
   * inteded, I think.
   *
   * LOL.
   */
  if (self->start == 0) {
    if (self->end == self->size) {
      err_seems_full (*err);
    } else {
      self->start = self->size;
    }
  } else if (self->start <= self-end) {
    self->start = self->start - 1;
  } else if (self->start > self->end) {
    if ((self->start - 1) == self->end ) {
      err_seems_full (*err);
    } else {
      self->start = self->start - 1;
    }
  } else {
    s_err_print ("Reaching a place that should not be reached. Returning");
    *err = TRUE;
    return;
  }
  self->len = self->len + 1;
  self->array[self->start] = data;
}

/*
 * When doing poping we do not override the data in the buffer.
 * This to alleviate some processing time form usage of the data structure.
 */
sbyte
s_ring_buffer_pop (SRingBuffer * self, sboolean * err) {
  err_on_empty (self, *err);
  sbyte ret_val = self->array[self->end];
  self->len = self->len - 1;
  self->end = self->end - 1;
  return ret_val;
}


sbyte
s_ring_buffer_pop_front (SRingBuffer * self, sboolean * err) {
  err_on_empty (self, *err);
  *err = FALSE;
  sbyte ret_val = self->array[self->start];
  self->start = self->start + 1;
  self->len = self->len - 1;
  return ret_val;
}


sbyte
s_ring_buffer_peek (SRingBuffer * self, sboolean * err) {
  err_on_empty (self, *err);
  *err = FALSE;
  return self->array[self->end];
}

sbyte
s_ring_buffer_peek_front (SRingBuffer * self, sboolean * err) {
  err_on_empty (self, *err);
  *err = FALSE;
  return self->array[self->start];
}

void
s_ring_buffer_realloc (SRingBuffer * self,
                       size_t len,
                       sboolean * err);


size_t
s_ring_buffer_len (SRingBuffer * self) {
  return self->len;
}


size_t
s_ring_buffer_size (SRingBuffer * self) {
  return self->size;
}


void
s_ring_buffer_for_each (SRingBuffer * self,
                        ForEachFunc func,
                        spointer user_data,
                        sboolean * err) {
  err_on_empty (self, *err);
  
}