#include <rlfifo.h>

Collaboration diagram for rlFifo:

Classes
struct	_MessageList_
Public Types
enum	FifoEnum { DATA_AVAILABLE = -1, NO_DATA_AVAILABLE = -2, MESSAGE_TO_BIG = -3, FIFO_FULL = -4 }
Public Member Functions
	rlFifo (int maxmessages=0)
virtual	~rlFifo ()
int	read (void *buf, int maxlen)
int	poll ()
int	write (const void *buf, int len)
int	printf (const char *format,...)
Private Types
typedef struct rlFifo::_MessageList_	MessageList
Private Attributes
int	maxmes
int	nmes
MessageList *	list
WSEMAPHORE	semaphore
pthread_mutex_t	mutex

Detailed Description

class for a fifo. (first in first out)

Definition at line 25 of file rlfifo.h.

Member Typedef Documentation

typedef struct rlFifo::_MessageList_ rlFifo::MessageList [private]

Member Enumeration Documentation

enum rlFifo::FifoEnum

Enumerator:

DATA_AVAILABLE
NO_DATA_AVAILABLE
MESSAGE_TO_BIG
FIFO_FULL

Definition at line 39 of file rlfifo.h.

                {
       DATA_AVAILABLE=-1, NO_DATA_AVAILABLE=-2, MESSAGE_TO_BIG=-3, FIFO_FULL=-4
  };

Constructor & Destructor Documentation

rlFifo::rlFifo ( int maxmessages = 0 )

Definition at line 22 of file rlfifo.cpp.

{
  maxmes = maxmessages;
  nmes = 0;
  list = NULL;
  rlwthread_mutex_init(&mutex, NULL);
  rlwrapinit_semaphore(&semaphore, 1000);
}

rlFifo::~rlFifo ( ) [virtual]

Definition at line 31 of file rlfifo.cpp.

{
MessageList *ptr,*lastptr;

  ptr = list;
  if(ptr != NULL)
  {
    do
    {
      lastptr = ptr;
      ptr = ptr->next;
      delete [] lastptr->mes;
      delete lastptr;
    }
    while(ptr != NULL);
  }
  rlwthread_mutex_destroy(&mutex);
  rlwrapdestroy_semaphore(&semaphore);
}

Member Function Documentation

int rlFifo::poll ( )

Definition at line 93 of file rlfifo.cpp.

{
  if(nmes > 0) return DATA_AVAILABLE;
  return              NO_DATA_AVAILABLE;
}

int rlFifo::printf	(	const char *	format,
			...
	)

Definition at line 136 of file rlfifo.cpp.

{
  int ret;
  char message[rl_PRINTF_LENGTH]; // should be big enough

  va_list ap;
  va_start(ap,format);
  ret = rlvsnprintf(message, rl_PRINTF_LENGTH - 1, format, ap);
  va_end(ap);
  if(ret < 0) return ret;
  return write(message,strlen(message));
}

int rlFifo::read	(	void *	buf,
		int	maxlen
	)

Definition at line 51 of file rlfifo.cpp.

{
  int retlen;
  MessageList *ptr;
  char *cbuf;

  cbuf = (char *) buf;
  rlwrapwait_semaphore(&semaphore);
  rlwthread_mutex_lock(&mutex);

  if(list->len > maxlen)
  {
    rlwrapincrement_semaphore(&semaphore);
    rlwthread_mutex_unlock(&mutex);
    return MESSAGE_TO_BIG;
  }

  ptr = list;
  if(ptr->next == NULL)
  {
    retlen = ptr->len;
    memcpy(buf,ptr->mes,retlen);
    delete [] ptr->mes;
    delete ptr;
    list = NULL;
    nmes--;
    rlwthread_mutex_unlock(&mutex);
    if(retlen < maxlen && retlen >= 0) cbuf[retlen] = '\0';
    return retlen;
  }
  ptr = ptr->next;
  retlen = list->len;
  memcpy(buf,list->mes,retlen);
  delete [] list->mes;
  delete list;
  list = ptr;
  nmes--;
  rlwthread_mutex_unlock(&mutex);
  if(retlen < maxlen && retlen >= 0) cbuf[retlen] = '\0';
  return retlen;
}

int rlFifo::write	(	const void *	buf,
		int	len
	)

Definition at line 99 of file rlfifo.cpp.

{
  MessageList *ptr;

  if(maxmes == 0);
  else if(nmes >= maxmes) return FIFO_FULL;

  rlwthread_mutex_lock(&mutex);
  if(list == NULL)
  {
    list = new MessageList;
    list->mes  = new char [len];
    list->len  = len;
    list->next = NULL;
    nmes++;
    memcpy(list->mes,buf,len);
    rlwthread_mutex_unlock(&mutex);
    rlwrapincrement_semaphore(&semaphore);
    return len;
  }

  // go to end of list
  ptr = list;
  while(ptr->next != NULL) ptr = ptr->next;

  ptr->next = new MessageList;
  ptr = ptr->next;
  ptr->mes  = new char [len];
  ptr->len  = len;
  ptr->next = NULL;
  nmes++;
  memcpy(ptr->mes,buf,len);
  rlwthread_mutex_unlock(&mutex);
  rlwrapincrement_semaphore(&semaphore);
  return len;
}