jm_vector.h

Go to the documentation of this file.

/*
    Copyright (C) 2012 Modelon AB

    This program is free software: you can redistribute it and/or modify
    it under the terms of the BSD style license.

     This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    FMILIB_License.txt file for more details.

    You should have received a copy of the FMILIB_License.txt file
    along with this program. If not, contact Modelon AB <http://www.modelon.com>.
*/

#ifndef jm_vector_h_
#define jm_vector_h_
#include <assert.h>
#include <string.h>

#include "jm_callbacks.h"
#ifdef __cplusplus
extern "C" {
#endif

#define jm_mangle_ex(name, type)  name## _ ##type
#define jm_mangle(name, type)  jm_mangle_ex(name,type)

#define jm_vector(T) jm_mangle(jm_vector, T)

#define jm_vector_alloc(T) jm_mangle(jm_vector_alloc, T)

#define jm_vector_free(T) jm_mangle(jm_vector_free, T)

#define jm_vector_init(T) jm_mangle(jm_vector_init, T)

#define jm_vector_free_data(T) jm_mangle(jm_vector_free_data, T)

#define jm_vector_get_size(T) jm_mangle(jm_vector_get_size, T)

#define jm_vector_get_item(T) jm_mangle(jm_vector_get_item, T)

#define jm_vector_get_itemp(T) jm_mangle(jm_vector_get_itemp, T)


#define jm_vector_get_last(T) jm_mangle(jm_vector_get_last, T)

#define jm_vector_get_lastp(T) jm_mangle(jm_vector_get_lastp, T)

typedef int (*jm_compare_ft) (const void* , const void*);

#define jm_define_comp_f(F, T, COMPAR_OP) \
    static int F (const void* first, const void* second) { \
        return COMPAR_OP(  (*(T*)first), (*(T*)second)); \
    } \

#define jm_diff(first, second) (int)(first-second)

#define jm_vector_find(T) jm_mangle(jm_vector_find, T)
#define jm_vector_find_index(T) jm_mangle(jm_vector_find_index, T)

/*
    jm_vector_qsort uses standard quick sort to sort the vector contents.
    JM_COMPAR_OP is used for comparison.

    void jm_vector_qsort(T)(jm_vector(T)* v, jm_compare_ft f);
*/
#define jm_vector_qsort(T) jm_mangle(jm_vector_qsort, T)

#define jm_vector_bsearch(T) jm_mangle(jm_vector_bsearch, T)
#define jm_vector_bsearch_index(T) jm_mangle(jm_vector_bsearch_index, T)

#define jm_vector_set_item(T) jm_mangle(jm_vector_set_item, T)

#define jm_vector_zero(T) jm_mangle(jm_vector_zero, T)

#define jm_vector_resize(T) jm_mangle(jm_vector_resize, T)

#define jm_vector_reserve(T) jm_mangle(jm_vector_reserve, T)

#define jm_vector_copy(T) jm_mangle(jm_vector_copy, T)

#define jm_vector_clone(T) jm_mangle(jm_vector_clone, T)

#define jm_vector_append(T) jm_mangle(jm_vector_append, T)

#define jm_vector_insert(T) jm_mangle(jm_vector_insert, T)

#define jm_vector_remove_item(T) jm_mangle(jm_vector_remove_item, T)

#define jm_vector_resize1(T)  jm_mangle(jm_vector_resize1, T)

#define jm_vector_push_back(T) jm_mangle(jm_vector_push_back, T)

#define jm_vector_foreach(T) jm_mangle(jm_vector_foreach, T)
#define jm_vector_foreach_c(T) jm_mangle(jm_vector_foreach_c, T)

#define JM_VECTOR_MINIMAL_CAPACITY 16

#define JM_VECTOR_MAX_MEMORY_CHUNK 1024

#define jm_vector_declare_template(T)           \
typedef struct  jm_vector(T) {                \
        jm_callbacks* callbacks;                        \
        T  *items;                              \
        size_t size;                             \
        size_t capacity;                        \
        T preallocated[JM_VECTOR_MINIMAL_CAPACITY];                     \
} jm_vector(T);                                 \
 \
extern jm_vector(T)* jm_vector_alloc(T)(size_t size,size_t capacity, jm_callbacks*);    \
    \
extern size_t jm_vector_copy(T)(jm_vector(T)* destination, jm_vector(T)* source); \
static jm_vector(T)* jm_vector_clone(T)(jm_vector(T)* v) {      \
    jm_vector(T)* ret = jm_vector_alloc(T)(v->size, v->size, v->callbacks);\
    if(ret) jm_vector_copy(T)(ret, v) ; \
    return ret; \
}\
        \
extern void jm_vector_free(T)(jm_vector(T) * a); \
    \
extern size_t jm_vector_init(T)(jm_vector(T)* a, size_t size,jm_callbacks*);    \
\
static void jm_vector_free_data(T)(jm_vector(T)* a) { \
    if(a) { \
        if(a->items != a->preallocated) { \
          a->callbacks->free((void*)(a->items)); \
          a->items = a->preallocated; \
          a->capacity=JM_VECTOR_MINIMAL_CAPACITY;\
        } \
        a->size=0; \
    } \
} \
   \
static size_t jm_vector_get_size(T)(jm_vector(T)* a) { return a->size; } \
\
static T jm_vector_get_item(T)(jm_vector(T)* a, size_t index) { \
           assert(index < a->size); \
           return a->items[index]; \
}\
static T* jm_vector_get_itemp(T)(jm_vector(T)* a, size_t index) { \
           assert(index < a->size); \
           return (a->items+index); \
}\
 static T jm_vector_get_last(T)(jm_vector(T)* a) { \
        assert(a->size); \
        return (a->items[a->size-1]); \
} \
static T* jm_vector_get_lastp(T)(jm_vector(T)* a) { \
    if(a->size) return (a->items+(a->size-1)); \
    else return 0; \
} \
 static void jm_vector_set_item(T)(jm_vector(T)* a, size_t index, T item) {\
    *(jm_vector_get_itemp(T)(a, index)) = item; \
} \
extern size_t jm_vector_resize(T)(jm_vector(T)* a, size_t size); \
extern size_t jm_vector_reserve(T)(jm_vector(T)* a, size_t capacity); \
extern size_t jm_vector_append(T)(jm_vector(T)* destination, jm_vector(T)* source); \
extern T* jm_vector_insert(T)(jm_vector(T)* a, size_t index, T item);\
extern T* jm_vector_push_back(T)(jm_vector(T)* a, T item);\
extern T* jm_vector_resize1(T)(jm_vector(T)* a);\
extern void jm_vector_remove_item(T)(jm_vector(T)* v, size_t index); \
extern size_t jm_vector_find_index(T)(jm_vector(T)* a,  T *itemp, jm_compare_ft f); \
extern T* jm_vector_find(T)(jm_vector(T)* a,  T *itemp, jm_compare_ft f); \
extern void jm_vector_qsort(T)(jm_vector(T)* v, jm_compare_ft f); \
extern size_t jm_vector_bsearch_index(T)(jm_vector(T)* v, T* key, jm_compare_ft f); \
extern T* jm_vector_bsearch(T)(jm_vector(T)* v, T* key, jm_compare_ft f); \
extern void jm_vector_foreach(T)(jm_vector(T)* a, void (*f)(T)); \
extern void jm_vector_foreach_c(T)(jm_vector(T)* a, void (*f)(T, void*), void * data); \
extern void jm_vector_zero(T)(jm_vector(T)* a);    

jm_vector_declare_template(char)
static jm_string jm_vector_char2string(jm_vector(char)* v) {
    jm_string str = "";
    if(v->size) return v->items;
    return str;
}

jm_vector_declare_template(int)
jm_vector_declare_template(double)
jm_vector_declare_template(jm_voidp)
jm_vector_declare_template(size_t)
jm_vector_declare_template(jm_string)
jm_vector_declare_template(jm_name_ID_map_t)


jm_define_comp_f(jm_compare_voidp, int*, jm_diff)
jm_define_comp_f(jm_compare_int, int, jm_diff)
jm_define_comp_f(jm_compare_char, char, jm_diff)
jm_define_comp_f(jm_compare_double, double, jm_diff)
jm_define_comp_f(jm_compare_size_t, size_t, jm_diff)
jm_define_comp_f(jm_compare_string, jm_string, strcmp)

#define jm_diff_name(a, b) strcmp(a.name,b.name)
jm_define_comp_f(jm_compare_name, jm_name_ID_map_t, jm_diff_name)


#ifdef __cplusplus
}
#endif

#endif