fifo.h

Go to the documentation of this file.

/* Queue operations */
#ifndef _ISIX_FIFO_H
#define _ISIX_FIFO_H

/*--------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
namespace isix {
#endif /*__cplusplus*/

/*--------------------------------------------------------------*/
struct fifo_struct;
typedef struct fifo_struct fifo_t;

/*--------------------------------------------------------------*/
fifo_t* isix_fifo_create(int n_elem, int elem_size);

/*--------------------------------------------------------------*/
int isix_fifo_write(fifo_t *fifo, const void *item, tick_t timeout);

/*--------------------------------------------------------------*/
int isix_fifo_write_isr(fifo_t *queue, const void *item);

/*--------------------------------------------------------------*/
int isix_fifo_destroy(fifo_t *fifo);

/*--------------------------------------------------------------*/
int isix_fifo_count(fifo_t *fifo);

/*--------------------------------------------------------------*/
int isix_fifo_read(fifo_t *fifo,void *item, tick_t timeout);

/*--------------------------------------------------------------*/
int isix_fifo_read_isr(fifo_t *queue, void *item);

/*--------------------------------------------------------------*/
#ifdef __cplusplus
}       //end namespace
}       //end extern-C
#endif /* __cplusplus */
/*--------------------------------------------------------------*/
//****************************** C++ API ***********************************
#ifdef __cplusplus
#include <cstddef>

namespace isix {
/*--------------------------------------------------------------*/
#ifdef ISIX_CONFIG_USE_MULTIOBJECTS
union ihandle;
#endif

/*--------------------------------------------------------------*/
class fifo_base
{
#ifdef ISIX_CONFIG_USE_MULTIOBJECTS
        friend union ihandle;
#endif
public:
        explicit fifo_base(fifo_t *hwnd_) : hwnd(hwnd_) {}
protected:
        fifo_t *hwnd;
private:
        fifo_base(const fifo_base&);
        fifo_base& operator=(const fifo_base&);
};

/*--------------------------------------------------------------*/
template <typename T> class fifo : public fifo_base
{
public:
        explicit fifo(std::size_t n_elem)
                : fifo_base(isix_fifo_create(n_elem,sizeof(T)))
        {
        }
        ~fifo()
        {
                isix_fifo_destroy(hwnd);
        }
        bool is_valid() { return hwnd!=0; }
        /* Push data in the queue
         * @param[in] c Reference to the object
         * @param[in] timeout Wait time when queue is not empty
         * @return ISIX_EOK if success else return an error
         */
        int push(const T &c,tick_t timeout=0)
        {
                return isix_fifo_write( hwnd, &c, timeout );
        }
        /* Push data in the queue from the ISR
         * @param[in] c Reference to the object
         * @param[in] timeout Wait time when queue is not empty
         * @return ISIX_EOK if success else return an error
         */
        int push_isr(const T &c)
        {
                return isix_fifo_write_isr( hwnd, &c );
        }
        int size() const
        {
                return isix_fifo_count( hwnd );
        }
        int pop(T &c, tick_t timeout=0)
        {
                return isix_fifo_read( hwnd, &c, timeout );
        }
        int pop_isr(T &c)
        {
                return isix_fifo_read_isr( hwnd, &c );
        }
private:
        fifo(const fifo&);
        fifo& operator=(const fifo&);
};

/*--------------------------------------------------------------*/
}
#endif /* __cplusplus */
/*--------------------------------------------------------------*/

#endif /* __ISIX_FIFO_H */
/*--------------------------------------------------------------*/