e-memory

e-memory

Synopsis

                    EMemChunk;
EMemChunk*          e_memchunk_new                      (int atomcount,
                                                         int atomsize);
void*               e_memchunk_alloc                    (EMemChunk *m);
void*               e_memchunk_alloc0                   (EMemChunk *m);
void                e_memchunk_free                     (EMemChunk *m,
                                                         void *mem);
void                e_memchunk_empty                    (EMemChunk *m);
void                e_memchunk_clean                    (EMemChunk *m);
void                e_memchunk_destroy                  (EMemChunk *m);
                    EMemPool;
enum                EMemPoolFlags;
EMemPool*           e_mempool_new                       (int blocksize,
                                                         int threshold,
                                                         EMemPoolFlags flags);
void*               e_mempool_alloc                     (EMemPool *pool,
                                                         int size);
char*               e_mempool_strdup                    (EMemPool *pool,
                                                         const char *str);
void                e_mempool_flush                     (EMemPool *pool,
                                                         int freeall);
void                e_mempool_destroy                   (EMemPool *pool);
                    EStrv;
EStrv*              e_strv_new                          (int size);
EStrv*              e_strv_set_ref                      (EStrv *strv,
                                                         int index,
                                                         char *str);
EStrv*              e_strv_set_ref_free                 (EStrv *strv,
                                                         int index,
                                                         char *str);
EStrv*              e_strv_set                          (EStrv *strv,
                                                         int index,
                                                         const char *str);
EStrv*              e_strv_pack                         (EStrv *strv);
char*               e_strv_get                          (EStrv *strv,
                                                         int index);
void                e_strv_destroy                      (EStrv *strv);
                    EPoolv;
EPoolv*             e_poolv_new                         (unsigned int size);
EPoolv*             e_poolv_cpy                         (EPoolv *dest,
                                                         const EPoolv *src);
EPoolv*             e_poolv_set                         (EPoolv *poolv,
                                                         int index,
                                                         char *str,
                                                         int freeit);
const char*         e_poolv_get                         (EPoolv *poolv,
                                                         int index);
void                e_poolv_destroy                     (EPoolv *poolv);

Description

Details

EMemChunk

typedef struct _EMemChunk EMemChunk;


e_memchunk_new ()

EMemChunk*          e_memchunk_new                      (int atomcount,
                                                         int atomsize);

atomcount :

atomsize :

Returns :


e_memchunk_alloc ()

void*               e_memchunk_alloc                    (EMemChunk *m);

m :

Returns :


e_memchunk_alloc0 ()

void*               e_memchunk_alloc0                   (EMemChunk *m);

m :

Returns :


e_memchunk_free ()

void                e_memchunk_free                     (EMemChunk *m,
                                                         void *mem);

m :

mem :


e_memchunk_empty ()

void                e_memchunk_empty                    (EMemChunk *m);

m :


e_memchunk_clean ()

void                e_memchunk_clean                    (EMemChunk *m);

m :


e_memchunk_destroy ()

void                e_memchunk_destroy                  (EMemChunk *m);

m :


EMemPool

typedef struct _EMemPool EMemPool;


enum EMemPoolFlags

typedef enum {
	E_MEMPOOL_ALIGN_STRUCT = 0,	/* allocate to native structure alignment */
	E_MEMPOOL_ALIGN_WORD = 1,	/* allocate to words - 16 bit alignment */
	E_MEMPOOL_ALIGN_BYTE = 2,	/* allocate to bytes - 8 bit alignment */
	E_MEMPOOL_ALIGN_MASK = 3, /* which bits determine the alignment information */
} EMemPoolFlags;


e_mempool_new ()

EMemPool*           e_mempool_new                       (int blocksize,
                                                         int threshold,
                                                         EMemPoolFlags flags);

blocksize :

threshold :

flags :

Returns :


e_mempool_alloc ()

void*               e_mempool_alloc                     (EMemPool *pool,
                                                         int size);

pool :

size :

Returns :


e_mempool_strdup ()

char*               e_mempool_strdup                    (EMemPool *pool,
                                                         const char *str);

pool :

str :

Returns :


e_mempool_flush ()

void                e_mempool_flush                     (EMemPool *pool,
                                                         int freeall);

pool :

freeall :


e_mempool_destroy ()

void                e_mempool_destroy                   (EMemPool *pool);

pool :


EStrv

typedef struct _EStrv EStrv;


e_strv_new ()

EStrv*              e_strv_new                          (int size);

size :

Returns :


e_strv_set_ref ()

EStrv*              e_strv_set_ref                      (EStrv *strv,
                                                         int index,
                                                         char *str);

strv :

index :

str :

Returns :


e_strv_set_ref_free ()

EStrv*              e_strv_set_ref_free                 (EStrv *strv,
                                                         int index,
                                                         char *str);

strv :

index :

str :

Returns :


e_strv_set ()

EStrv*              e_strv_set                          (EStrv *strv,
                                                         int index,
                                                         const char *str);

strv :

index :

str :

Returns :


e_strv_pack ()

EStrv*              e_strv_pack                         (EStrv *strv);

strv :

Returns :


e_strv_get ()

char*               e_strv_get                          (EStrv *strv,
                                                         int index);

strv :

index :

Returns :


e_strv_destroy ()

void                e_strv_destroy                      (EStrv *strv);

strv :


EPoolv

typedef struct _EPoolv EPoolv;


e_poolv_new ()

EPoolv*             e_poolv_new                         (unsigned int size);

size :

Returns :


e_poolv_cpy ()

EPoolv*             e_poolv_cpy                         (EPoolv *dest,
                                                         const EPoolv *src);

dest :

src :

Returns :


e_poolv_set ()

EPoolv*             e_poolv_set                         (EPoolv *poolv,
                                                         int index,
                                                         char *str,
                                                         int freeit);

poolv :

index :

str :

freeit :

Returns :


e_poolv_get ()

const char*         e_poolv_get                         (EPoolv *poolv,
                                                         int index);

poolv :

index :

Returns :


e_poolv_destroy ()

void                e_poolv_destroy                     (EPoolv *poolv);

poolv :