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);
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 *,
                                                         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, 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 ()

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;
	gint flags;
} 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_prfd ()

struct PRFileDesc*  e_msgport_prfd                      (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 :


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 *,
                                                         void *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,
                                                         int 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,
                                                         void *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,
                                                         void *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,
                                                         void *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 ()

int                 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 ()

int                 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 ()

int                 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 ()

int                 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 ()

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

Warning

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

cond :

m :

Returns :