## e-msgport

e-msgport —

## Synopsis

                EDListNode;
                EDList;
    #define     E_DLIST_INITIALISER             (l)
    void        e_dlist_init                    (EDList *v);
    EDListNode* e_dlist_addhead                 (EDList *l,
                                                 EDListNode *n);
    EDListNode* e_dlist_addtail                 (EDList *l,
                                                 EDListNode *n);
    EDListNode* e_dlist_remove                  (EDListNode *n);
    EDListNode* e_dlist_remhead                 (EDList *l);
    EDListNode* e_dlist_remtail                 (EDList *l);
    int         e_dlist_empty                   (EDList *l);
    int         e_dlist_length                  (EDList *l);
                EMCache;
                EMCacheNode;
    EMCache*    em_cache_new                    (time_t timeout,
                                                 size_t nodesize,
                                                 GFreeFunc nodefree);
    void        em_cache_destroy                (EMCache *emc);
    EMCacheNode* em_cache_lookup                (EMCache *emc,
                                                 const char *key);
    EMCacheNode* em_cache_node_new              (EMCache *emc,
                                                 const char *key);
    void        em_cache_node_unref             (EMCache *emc,
                                                 EMCacheNode *n);
    void        em_cache_add                    (EMCache *emc,
                                                 EMCacheNode *n);
    void        em_cache_clear                  (EMCache *emc);
                EMsgPort;
                EMsg;
    EMsgPort*   e_msgport_new                   (void);
    void        e_msgport_destroy               (EMsgPort *mp);
    int         e_msgport_fd                    (EMsgPort *mp);
    void        e_msgport_put                   (EMsgPort *mp,
                                                 EMsg *msg);
    EMsg*       e_msgport_wait                  (EMsgPort *mp);
    EMsg*       e_msgport_get                   (EMsgPort *mp);
    void        e_msgport_reply                 (EMsg *msg);
    void        (*EThreadFunc)                  (EThread *,
                                                 EMsg *,
                                                 void *data);
    EThread*    e_thread_new                    (e_thread_t type);
    void        e_thread_destroy                (EThread *e);
    void        e_thread_set_queue_limit        (EThread *e,
                                                 int limit);
    void        e_thread_set_msg_lost           (EThread *e,
                                                 EThreadFunc destroy,
                                                 void *data);
    void        e_thread_set_msg_destroy        (EThread *e,
                                                 EThreadFunc destroy,
                                                 void *data);
    void        e_thread_set_reply_port         (EThread *e,
                                                 EMsgPort *reply_port);
    void        e_thread_set_msg_received       (EThread *e,
                                                 EThreadFunc received,
                                                 void *data);
    void        e_thread_put                    (EThread *e,
                                                 EMsg *msg);
    int         e_thread_busy                   (EThread *e);
                EMutex;
    enum        e_mutex_t;
    EMutex*     e_mutex_new                     (e_mutex_t type);
    int         e_mutex_destroy                 (EMutex *m);
    int         e_mutex_lock                    (EMutex *m);
    int         e_mutex_unlock                  (EMutex *m);
    void        e_mutex_assert_locked           (EMutex *m);
    int         e_mutex_cond_wait               (void *cond,
                                                 EMutex *m);

## Description

## Details

### EDListNode

    typedef struct {
    	struct _EDListNode *next;
    	struct _EDListNode *prev;
    } EDListNode;

### EDList

    typedef struct {
    	struct _EDListNode *head;
    	struct _EDListNode *tail;
    	struct _EDListNode *tailpred;
    } EDList;

### E_DLIST_INITIALISER()

    #define E_DLIST_INITIALISER(l) { (EDListNode *)&l.tail, 0, (EDListNode *)&l.head }

`l` : |

### e_dlist_init ()

    void        e_dlist_init                    (EDList *v);

`v` : |

### e_dlist_addhead ()

    EDListNode* e_dlist_addhead                 (EDList *l,
                                                 EDListNode *n);

`l` : |
`n` : |
Returns : |

### e_dlist_addtail ()

    EDListNode* e_dlist_addtail                 (EDList *l,
                                                 EDListNode *n);

`l` : |
`n` : |
Returns : |

### e_dlist_remove ()

    EDListNode* e_dlist_remove                  (EDListNode *n);

`n` : |
Returns : |

### e_dlist_remhead ()

    EDListNode* e_dlist_remhead                 (EDList *l);

`l` : |
Returns : |

### e_dlist_remtail ()

    EDListNode* e_dlist_remtail                 (EDList *l);

`l` : |
Returns : |

### e_dlist_empty ()

    int         e_dlist_empty                   (EDList *l);

`l` : |
Returns : |

### e_dlist_length ()

    int         e_dlist_length                  (EDList *l);

`l` : |
Returns : |

### EMCache

    typedef struct _EMCache EMCache;

### EMCacheNode

    typedef struct {
    	struct _EMCacheNode *next, *prev;
    	char *key;
    	int ref_count;
    	time_t stamp;
    } EMCacheNode;

### em_cache_new ()

    EMCache*    em_cache_new                    (time_t timeout,
                                                 size_t nodesize,
                                                 GFreeFunc nodefree);

Setup a new timeout cache. `nodesize` is the size of nodes in the cache, and `nodefree` will be called to free YOUR content.

`timeout` : |
`nodesize` : |
`nodefree` : |
Returns : |

### em_cache_destroy ()

    void        em_cache_destroy                (EMCache *emc);

destroy the cache, duh.

`emc` : |

### em_cache_lookup ()

    EMCacheNode* em_cache_lookup                (EMCache *emc,
                                                 const char *key);

Lookup a cache node. once you're finished with it, you need to unref it.

`emc` : |
`key` : |
Returns : |

### em_cache_node_new ()

    EMCacheNode* em_cache_node_new              (EMCache *emc,
                                                 const char *key);

Create a new key'd cache node. The node will not be added to the cache until you insert it.

`emc` : |
`key` : |
Returns : |

### em_cache_node_unref ()

    void        em_cache_node_unref             (EMCache *emc,
                                                 EMCacheNode *n);

unref a cache node, you can only unref nodes which have been looked up.

`emc` : |
`n` : |

### em_cache_add ()

    void        em_cache_add                    (EMCache *emc,
                                                 EMCacheNode *n);

Add a cache node to the cache, once added the memory is owned by the cache. If there are conflicts and the old node is still in use, then the new node is not added, otherwise it is added and any nodes older than the expire time are flushed.

`emc` : |
`n` : |

### em_cache_clear ()

    void        em_cache_clear                  (EMCache *emc);

clear the cache. just for api completeness.

`emc` : |

### EMsgPort

    typedef struct _EMsgPort EMsgPort;

### EMsg

    typedef struct {
    	EDListNode ln;
    	EMsgPort *reply_port;
    } EMsg;

### e_msgport_new ()

    EMsgPort*   e_msgport_new                   (void);

Returns : |

### e_msgport_destroy ()

    void        e_msgport_destroy               (EMsgPort *mp);

`mp` : |

### e_msgport_fd ()

    int         e_msgport_fd                    (EMsgPort *mp);

`mp` : |
Returns : |

### e_msgport_put ()

    void        e_msgport_put                   (EMsgPort *mp,
                                                 EMsg *msg);

`mp` : |
`msg` : |

### e_msgport_wait ()

    EMsg*       e_msgport_wait                  (EMsgPort *mp);

`mp` : |
Returns : |

### e_msgport_get ()

    EMsg*       e_msgport_get                   (EMsgPort *mp);

`mp` : |
Returns : |

### e_msgport_reply ()

    void        e_msgport_reply                 (EMsg *msg);

`msg` : |

### EThreadFunc ()

    void        (*EThreadFunc)                  (EThread *,
                                                 EMsg *,
                                                 void *data);

`Param1` : |
`Param2` : |
`data` : |

### e_thread_new ()

    EThread*    e_thread_new                    (e_thread_t type);

`type` : |
Returns : |

### e_thread_destroy ()

    void        e_thread_destroy                (EThread *e);

`e` : |

### e_thread_set_queue_limit ()

    void        e_thread_set_queue_limit        (EThread *e,
                                                 int limit);

`e` : |
`limit` : |

### e_thread_set_msg_lost ()

    void        e_thread_set_msg_lost           (EThread *e,
                                                 EThreadFunc destroy,
                                                 void *data);

`e` : |
`destroy` : |
`data` : |

### e_thread_set_msg_destroy ()

    void        e_thread_set_msg_destroy        (EThread *e,
                                                 EThreadFunc destroy,
                                                 void *data);

`e` : |
`destroy` : |
`data` : |

### e_thread_set_reply_port ()

    void        e_thread_set_reply_port         (EThread *e,
                                                 EMsgPort *reply_port);

`e` : |
`reply_port` : |

### e_thread_set_msg_received ()

    void        e_thread_set_msg_received       (EThread *e,
                                                 EThreadFunc received,
                                                 void *data);

`e` : |
`received` : |
`data` : |

### e_thread_put ()

    void        e_thread_put                    (EThread *e,
                                                 EMsg *msg);

`e` : |
`msg` : |

### e_thread_busy ()

    int         e_thread_busy                   (EThread *e);

`e` : |
Returns : |

### EMutex

    typedef struct _EMutex EMutex;

### enum e_mutex_t

    typedef enum _e_mutex_t {
    	E_MUTEX_SIMPLE,		/* == pthread_mutex */
    	E_MUTEX_REC,		/* recursive mutex */
    } e_mutex_t;

### e_mutex_new ()

    EMutex*     e_mutex_new                     (e_mutex_t type);

`type` : |
Returns : |

### e_mutex_destroy ()

    int         e_mutex_destroy                 (EMutex *m);

`m` : |
Returns : |

### e_mutex_lock ()

    int         e_mutex_lock                    (EMutex *m);

`m` : |
Returns : |

### e_mutex_unlock ()

    int         e_mutex_unlock                  (EMutex *m);

`m` : |
Returns : |

### e_mutex_assert_locked ()

    void        e_mutex_assert_locked           (EMutex *m);

`m` : |

### e_mutex_cond_wait ()

    int         e_mutex_cond_wait               (void *cond,
                                                 EMutex *m);

`cond` : |
`m` : |
Returns : |