Buffer.c

Go to the documentation of this file.

/*
 * Routines for manipulating buffers.  These buffers are going to be circular.
 * 
 */
#include "Buffer.h"


Buffer *mkbuffer(int n, size_t len)
/*
 * mkbuffer creates a buffer for n records of length len and returns a pointer
 * to the created buffer.
 * Returns NULL if there is a problem.
 */ 
{
  Buffer *r;

  r = (Buffer *) malloc(sizeof(Buffer));
  if (r == NULL) 
    return NULL;
  
  r->data = (void *) malloc(n * len);
  if (r->data == NULL) {
    free(r);
    return NULL;
  }
  memset(r->data, 0, n * len);
  r->head=0;
  r->tail=0;
  r->full=0;
  r->n=n;
  r->len=len;
  return r;
}


int bsize(Buffer *b)
/*
 * returns the total size of the buffer (n)
 */
{
  return b->n;
}


int bhead(Buffer *b)
/*
 * returns the position of the buffer's head 
 */
{
  return b->head;
}


int btail(Buffer *b)
/*
 * returns the position of the buffer's tail
 */
{
  return b->tail;
}


void bwrite(Buffer *b, void *data)
/* 
 * writes a record from *data to the buffer
 *
 * returns void because it can never fail.
 */
{
  int offset = b->head*b->len;
  memcpy(b->data+offset, data, b->len);

  if ((b->head == b->tail) && b->full) {
    b->tail++;
    if (b->tail==b->n)
      b->tail=0;
  }
  b->head++;

  if (b->head == b->n)
    b->head=0;
  if (b->head == b->tail)
    b->full=1;
}


int bread(Buffer *b, void *data)
/* 
 * copies a record from the buffer to *data
 * 
 * returns:
 *   1 = ok
 *   0 = failed
 */
{
  if ((b->head==b->tail) && !(b->full))
    return 0;

  memcpy(data, b->data + b->tail*b->len, b->len);

  b->tail++;
  if (b->tail==b->n)
    b->tail=0;

  b->full=0;

  return 1;
}


int blevel(Buffer *b)
/*
 * returns the number of records in the buffer
 */
{
  if (b->head == b->tail) {
    if (b->full)
      return b->n;
    else
      return 0;
  }
  if (b->head > b->tail)
    return (b->head - b->tail);
  if (b->head < b->tail)
    return (b->n + b->head - b->tail);
}


void *bpeek(Buffer *b, int n)
/*
 * bpeek returns a pointer to the nth record in the buffer, or NULL if 
 * it there is no nth element.
 */
{
  if (n<0)
    return NULL;

  if (blevel(b) < n+1)
    return NULL;

  return (b->data + ((b->tail + n) % b->n) * b->len);
}


void closebuffer(Buffer *b)
/*
 * frees up memory used by buffer b
 */
{
  free(b->data);
  free(b);
}

---