## 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` : |