e-msgport

## 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);
    gint                e_dlist_empty                       (EDList *l);
    gint                e_dlist_length                      (EDList *l);
                        EMCache;
                        EMCacheNode;
    EMCache *           em_cache_new                        (time_t timeout,
                                                             gsize nodesize,
                                                             GFreeFunc nodefree);
    void                em_cache_destroy                    (EMCache *emc);
    EMCacheNode *       em_cache_lookup                     (EMCache *emc,
                                                             const gchar *key);
    EMCacheNode *       em_cache_node_new                   (EMCache *emc,
                                                             const gchar *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);
    gint                e_msgport_fd                        (EMsgPort *mp);
    struct PRFileDesc * e_msgport_prfd                      (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);
                        EThread;
    enum                e_thread_t;
    void                (*EThreadFunc)                      (EThread *,
                                                             EMsg *,
                                                             gpointer data);
    EThread *           e_thread_new                        (e_thread_t type);
    void                e_thread_destroy                    (EThread *e);
    void                e_thread_set_queue_limit            (EThread *e,
                                                             gint limit);
    void                e_thread_set_msg_lost               (EThread *e,
                                                             EThreadFunc destroy,
                                                             gpointer data);
    void                e_thread_set_msg_destroy            (EThread *e,
                                                             EThreadFunc destroy,
                                                             gpointer data);
    void                e_thread_set_reply_port             (EThread *e,
                                                             EMsgPort *reply_port);
    void                e_thread_set_msg_received           (EThread *e,
                                                             EThreadFunc received,
                                                             gpointer data);
    void                e_thread_put                        (EThread *e,
                                                             EMsg *msg);
    gint                e_thread_busy                       (EThread *e);
                        EMutex;
    enum                e_mutex_t;
    EMutex *            e_mutex_new                         (e_mutex_t type);
    gint                e_mutex_destroy                     (EMutex *m);
    gint                e_mutex_lock                        (EMutex *m);
    gint                e_mutex_unlock                      (EMutex *m);
    void                e_mutex_assert_locked               (EMutex *m);
    gint                e_mutex_cond_wait                   (gpointer 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, NULL, (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 ()

    gint                e_dlist_empty                       (EDList *l);

`l` : |
Returns : |

### e_dlist_length ()

    gint                e_dlist_length                      (EDList *l);

`l` : |
Returns : |

### EMCache

    typedef struct _EMCache EMCache;

### EMCacheNode

    typedef struct {
    	struct _EMCacheNode *next, *prev;
    	gchar *key;
    	gint ref_count;
    	time_t stamp;
    } EMCacheNode;

### em_cache_new ()

    EMCache *           em_cache_new                        (time_t timeout,
                                                             gsize 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 gchar *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 gchar *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;

### Warning

`EMsgPort` is deprecated and should not be used in newly-written code.

### EMsg

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

### Warning

`EMsg` is deprecated and should not be used in newly-written code.

### e_msgport_new ()

    EMsgPort *          e_msgport_new                       (void);

### Warning

`e_msgport_new` is deprecated and should not be used in newly-written code.

Returns : |

### e_msgport_destroy ()

    void                e_msgport_destroy                   (EMsgPort *mp);

### Warning

`e_msgport_destroy` is deprecated and should not be used in newly-written code.

`mp` : |

### e_msgport_fd ()

    gint                e_msgport_fd                        (EMsgPort *mp);

### Warning

`e_msgport_fd` is deprecated and should not be used in newly-written code.

`mp` : |
Returns : |

### e_msgport_prfd ()

    struct PRFileDesc * e_msgport_prfd                      (EMsgPort *mp);

### Warning

`e_msgport_prfd` is deprecated and should not be used in newly-written code.

`mp` : |
Returns : |

### e_msgport_put ()

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

### Warning

`e_msgport_put` is deprecated and should not be used in newly-written code.

`mp` : |
`msg` : |

### e_msgport_wait ()

    EMsg *              e_msgport_wait                      (EMsgPort *mp);

### Warning

`e_msgport_wait` is deprecated and should not be used in newly-written code.

`mp` : |
Returns : |

### e_msgport_get ()

    EMsg *              e_msgport_get                       (EMsgPort *mp);

### Warning

`e_msgport_get` is deprecated and should not be used in newly-written code.

`mp` : |
Returns : |

### e_msgport_reply ()

    void                e_msgport_reply                     (EMsg *msg);

### Warning

`e_msgport_reply` is deprecated and should not be used in newly-written code.

`msg` : |

### EThread

    typedef struct _EThread EThread;

### Warning

`EThread` is deprecated and should not be used in newly-written code.

### enum e_thread_t

    typedef enum {
    	E_THREAD_QUEUE = 0,	/* run one by one, until done, if the queue_limit is reached, discard new request */
    	E_THREAD_DROP,		/* run one by one, until done, if the queue_limit is reached, discard oldest requests */
    	E_THREAD_NEW		/* always run in a new thread, if the queue limit is reached, new requests are
    				   stored in the queue until a thread becomes available for it, creating a thread pool */
    } e_thread_t;

### Warning

`e_thread_t` is deprecated and should not be used in newly-written code.

### EThreadFunc ()

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

### Warning

`EThreadFunc` is deprecated and should not be used in newly-written code.

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

### e_thread_new ()

    EThread *           e_thread_new                        (e_thread_t type);

### Warning

`e_thread_new` is deprecated and should not be used in newly-written code.

`type` : |
Returns : |

### e_thread_destroy ()

    void                e_thread_destroy                    (EThread *e);

### Warning

`e_thread_destroy` is deprecated and should not be used in newly-written code.

`e` : |

### e_thread_set_queue_limit ()

    void                e_thread_set_queue_limit            (EThread *e,
                                                             gint limit);

### Warning

`e_thread_set_queue_limit` is deprecated and should not be used in newly-written code.

`e` : |
`limit` : |

### e_thread_set_msg_lost ()

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

### Warning

`e_thread_set_msg_lost` is deprecated and should not be used in newly-written code.

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

### e_thread_set_msg_destroy ()

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

### Warning

`e_thread_set_msg_destroy` is deprecated and should not be used in newly-written code.

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

### e_thread_set_reply_port ()

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

### Warning

`e_thread_set_reply_port` is deprecated and should not be used in newly-written code.

`e` : |
`reply_port` : |

### e_thread_set_msg_received ()

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

### Warning

`e_thread_set_msg_received` is deprecated and should not be used in newly-written code.

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

### e_thread_put ()

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

### Warning

`e_thread_put` is deprecated and should not be used in newly-written code.

`e` : |
`msg` : |

### e_thread_busy ()

    gint                e_thread_busy                       (EThread *e);

### Warning

`e_thread_busy` is deprecated and should not be used in newly-written code.

`e` : |
Returns : |

### EMutex

    typedef struct _EMutex EMutex;

### Warning

`EMutex` is deprecated and should not be used in newly-written code.

### enum e_mutex_t

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

### Warning

`e_mutex_t` is deprecated and should not be used in newly-written code.

### e_mutex_new ()

    EMutex *            e_mutex_new                         (e_mutex_t type);

### Warning

`e_mutex_new` is deprecated and should not be used in newly-written code.

`type` : |
Returns : |

### e_mutex_destroy ()

    gint                e_mutex_destroy                     (EMutex *m);

### Warning

`e_mutex_destroy` is deprecated and should not be used in newly-written code.

`m` : |
Returns : |

### e_mutex_lock ()

    gint                e_mutex_lock                        (EMutex *m);

### Warning

`e_mutex_lock` is deprecated and should not be used in newly-written code.

`m` : |
Returns : |

### e_mutex_unlock ()

    gint                e_mutex_unlock                      (EMutex *m);

### Warning

`e_mutex_unlock` is deprecated and should not be used in newly-written code.

`m` : |
Returns : |

### e_mutex_assert_locked ()

    void                e_mutex_assert_locked               (EMutex *m);

### Warning

`e_mutex_assert_locked` is deprecated and should not be used in newly-written code.

`m` : |

### e_mutex_cond_wait ()

    gint                e_mutex_cond_wait                   (gpointer cond,
                                                             EMutex *m);

### Warning

`e_mutex_cond_wait` is deprecated and should not be used in newly-written code.

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