org.simantics.fmil.core/native/FMILibrary/src/Import/src/FMI2/fmi2_import_variable_list.c

   1 /*
   2     Copyright (C) 2012 Modelon AB
   3
   4     This program is free software: you can redistribute it and/or modify
   5     it under the terms of the BSD style license.
   6
   7      This program is distributed in the hope that it will be useful,
   8     but WITHOUT ANY WARRANTY; without even the implied warranty of
   9     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10     FMILIB_License.txt file for more details.
  11
  12     You should have received a copy of the FMILIB_License.txt file
  13     along with this program. If not, contact Modelon AB <http://www.modelon.com>.
  14 */
  15 #include <string.h>
  16
  17 #include "fmi2_import_impl.h"
  18 #include "fmi2_import_variable_list_impl.h"
  19
  20 fmi2_import_variable_list_t* fmi2_import_alloc_variable_list(fmi2_import_t* fmu, size_t size) {
  21         jm_callbacks* cb = fmu->callbacks;
  22         fmi2_import_variable_list_t* vl = (fmi2_import_variable_list_t*)cb->malloc(sizeof(fmi2_import_variable_list_t));
  23     if(!vl) return 0;
  24     vl->vr = 0;
  25         vl->fmu = fmu;
  26     if(jm_vector_init(jm_voidp)(&vl->variables,size,cb) < size) {
  27         fmi2_import_free_variable_list(vl);
  28         return 0;
  29     }
  30     return vl;
  31 }
  32
  33 void fmi2_import_free_variable_list(fmi2_import_variable_list_t* vl) {
  34     jm_callbacks* cb;
  35         if(!vl) return;
  36         cb = vl->variables.callbacks;
  37         cb->free(vl->vr);
  38     jm_vector_free_data(jm_voidp)(&vl->variables);
  39     cb->free(vl);
  40 }
  41
  42 /* Get number of variables in a list */
  43 size_t  fmi2_import_get_variable_list_size(fmi2_import_variable_list_t* vl) {
  44         if(vl)
  45                 return jm_vector_get_size(jm_voidp)(&vl->variables);
  46         else
  47                 return 0;
  48 }
  49
  50 /* Make a copy */
  51 fmi2_import_variable_list_t* fmi2_import_clone_variable_list(fmi2_import_variable_list_t* vl) {
  52     fmi2_import_variable_list_t* copy = fmi2_import_alloc_variable_list(vl->fmu, fmi2_import_get_variable_list_size(vl));
  53     if(!copy) return 0;
  54     jm_vector_copy(jm_voidp)(&copy->variables, &vl->variables);
  55     return copy;
  56 }
  57
  58 fmi2_import_variable_list_t* fmi2_import_join_var_list(fmi2_import_variable_list_t* a, fmi2_import_variable_list_t* b) {
  59     size_t asize = fmi2_import_get_variable_list_size(a);
  60     size_t bsize = fmi2_import_get_variable_list_size(b);
  61     size_t joinSize = asize + bsize;
  62     fmi2_import_variable_list_t* list = fmi2_import_alloc_variable_list(a->fmu,joinSize);
  63     if(!list) {
  64         return list;
  65     }
  66     jm_vector_copy(jm_voidp)(&list->variables,&a->variables);
  67     jm_vector_resize(jm_voidp)(&list->variables,joinSize);
  68     memcpy((void*)jm_vector_get_itemp(jm_voidp)(&list->variables,asize), (void*)jm_vector_get_itemp(jm_voidp)(&b->variables,0), sizeof(jm_voidp)*bsize);
  69     return list;
  70 }
  71
  72 fmi2_import_variable_list_t* fmi2_import_create_var_list(fmi2_import_t* fmu,fmi2_import_variable_t* v) {
  73     fmi2_import_variable_list_t* list = fmi2_import_alloc_variable_list(fmu,1);
  74     if(!list ) {
  75         return list;
  76     }
  77     jm_vector_set_item(jm_voidp)(&list->variables,0,v);
  78     return list;
  79 }
  80
  81 fmi2_import_variable_list_t* fmi2_import_append_to_var_list(fmi2_import_variable_list_t* list, fmi2_import_variable_t* v) {
  82     fmi2_import_variable_list_t* out = fmi2_import_alloc_variable_list(list->fmu, fmi2_import_get_variable_list_size(list)+1);
  83     if(!out) return 0;
  84     jm_vector_copy(jm_voidp)(&out->variables,&list->variables);
  85     jm_vector_push_back(jm_voidp)(&out->variables, v);
  86     return out;
  87 }
  88
  89 fmi2_import_variable_list_t* fmi2_import_prepend_to_var_list(fmi2_import_variable_list_t* list, fmi2_import_variable_t* v) {
  90     size_t lsize = fmi2_import_get_variable_list_size(list);
  91     fmi2_import_variable_list_t* out = fmi2_import_alloc_variable_list(list->fmu, lsize+1);
  92     if(!out) return 0;
  93     jm_vector_set_item(jm_voidp)(&out->variables,0,v);
  94     memcpy((void*)jm_vector_get_itemp(jm_voidp)(&out->variables,1), (void*)jm_vector_get_itemp(jm_voidp)(&list->variables,0), sizeof(jm_voidp)*lsize);
  95     return out;
  96 }
  97
  98 jm_status_enu_t fmi2_import_var_list_push_back(fmi2_import_variable_list_t* list, fmi2_import_variable_t* v) {
  99     if(!jm_vector_push_back(jm_voidp)(&list->variables, v)) return jm_status_error;
 100     return jm_status_success;
 101 }
 102
 103 /* Get a pointer to the list of the value references for all the variables */
 104 const fmi2_value_reference_t* fmi2_import_get_value_referece_list(fmi2_import_variable_list_t* vl) {
 105     if(!vl->vr) {
 106                 jm_callbacks* cb = vl->fmu->callbacks;
 107         size_t i, nv = fmi2_import_get_variable_list_size(vl);
 108                 vl->vr = (fmi2_value_reference_t*)cb->malloc(nv * sizeof(fmi2_value_reference_t));
 109         if(vl->vr) {
 110             for(i = 0; i < nv; i++) {
 111                                 vl->vr[i] = fmi2_xml_get_variable_vr(fmi2_import_get_variable(vl, i));
 112             }
 113         }
 114                 else return 0;
 115     }
 116     return vl->vr;
 117 }
 118
 119 /* Get a single variable from the list*/
 120 fmi2_import_variable_t* fmi2_import_get_variable(fmi2_import_variable_list_t* vl, size_t  index) {
 121         if(index >= fmi2_import_get_variable_list_size(vl))
 122                 return 0;
 123         else
 124                 return (fmi2_import_variable_t*)jm_vector_get_item(jm_voidp)(&vl->variables, index);
 125 }
 126
 127 /* Operations on variable lists. Every operation creates a new list. */
 128 /* Select sub-lists */
 129 fmi2_import_variable_list_t* fmi2_import_get_sublist(fmi2_import_variable_list_t* vl, size_t  fromIndex, size_t  toIndex) {
 130     fmi2_import_variable_list_t* out;
 131     size_t size, i;
 132     if(fromIndex > toIndex) return 0;
 133     if(toIndex >=  fmi2_import_get_variable_list_size(vl)) return 0;
 134     size = toIndex - fromIndex + 1;
 135     out = fmi2_import_alloc_variable_list(vl->fmu, size);
 136     if(!out ) return 0;
 137     for(i=0; i < size; i++) {
 138         jm_vector_set_item(jm_voidp)(&out->variables, i, jm_vector_get_item(jm_voidp)(&vl->variables, fromIndex+i));
 139     }
 140     return out;
 141 }
 142
 143 /* fmi2_import_filter_variables calls  the provided 'filter' function on every variable in the list.
 144   It returns a sub-list list with the variables for which filter returned non-zero value. */
 145 fmi2_import_variable_list_t* fmi2_import_filter_variables(fmi2_import_variable_list_t* vl, fmi2_import_variable_filter_function_ft filter, void* context) {
 146     size_t nv, i;
 147     fmi2_import_variable_list_t* out = fmi2_import_alloc_variable_list(vl->fmu, 0);
 148         if(!out) return 0; /* out of memory */
 149     nv = fmi2_import_get_variable_list_size(vl);
 150     for(i=0; i < nv;i++) {
 151         fmi2_import_variable_t* variable = fmi2_import_get_variable(vl, i);
 152         if(filter(variable, context))
 153             if(!jm_vector_push_back(jm_voidp)(&out->variables, variable))
 154                 break;
 155     }
 156     if(i != nv) {
 157         fmi2_import_free_variable_list(out);
 158         out = 0;
 159     }
 160     return out;
 161 }