org.simantics.fmil.core/native/FMILibrary/src/Import/src/FMI1/fmi1_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 "fmi1_import_impl.h"
  18 #include "fmi1_import_variable_list_impl.h"
  19
  20 fmi1_import_variable_list_t* fmi1_import_alloc_variable_list(fmi1_import_t* fmu, size_t size) {
  21         jm_callbacks* cb = fmu->callbacks;
  22         fmi1_import_variable_list_t* vl = (fmi1_import_variable_list_t*)cb->malloc(sizeof(fmi1_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         fmi1_import_free_variable_list(vl);
  28         return 0;
  29     }
  30     return vl;
  31 }
  32
  33 void fmi1_import_free_variable_list(fmi1_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  fmi1_import_get_variable_list_size(fmi1_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 fmi1_import_variable_list_t* fmi1_import_clone_variable_list(fmi1_import_variable_list_t* vl) {
  52     fmi1_import_variable_list_t* copy;
  53         if(!vl) return 0;
  54         copy = fmi1_import_alloc_variable_list(vl->fmu, fmi1_import_get_variable_list_size(vl));
  55     if(!copy) return 0;
  56     jm_vector_copy(jm_voidp)(&copy->variables, &vl->variables);
  57     return copy;
  58 }
  59
  60 fmi1_import_variable_list_t* fmi1_import_join_var_list(fmi1_import_variable_list_t* a, fmi1_import_variable_list_t* b) {
  61     size_t asize = fmi1_import_get_variable_list_size(a);
  62     size_t bsize = fmi1_import_get_variable_list_size(b);
  63     size_t joinSize = asize + bsize;
  64     fmi1_import_variable_list_t* list = fmi1_import_alloc_variable_list(a->fmu,joinSize);
  65     if(!list) {
  66         return list;
  67     }
  68         if(a)
  69                 jm_vector_copy(jm_voidp)(&list->variables,&a->variables);
  70         if(b) {
  71                 jm_vector_resize(jm_voidp)(&list->variables,joinSize);
  72                 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);
  73         }
  74     return list;
  75 }
  76
  77 fmi1_import_variable_list_t* fmi1_import_create_var_list(fmi1_import_t* fmu,fmi1_import_variable_t* v) {
  78     fmi1_import_variable_list_t* list = fmi1_import_alloc_variable_list(fmu,1);
  79     if(!list ) {
  80         return list;
  81     }
  82     jm_vector_set_item(jm_voidp)(&list->variables,0,v);
  83     return list;
  84 }
  85
  86 fmi1_import_variable_list_t* fmi1_import_append_to_var_list(fmi1_import_variable_list_t* list, fmi1_import_variable_t* v) {
  87     fmi1_import_variable_list_t* out = fmi1_import_alloc_variable_list(list->fmu, fmi1_import_get_variable_list_size(list)+1);
  88     if(!out) return 0;
  89     jm_vector_copy(jm_voidp)(&out->variables,&list->variables);
  90     jm_vector_push_back(jm_voidp)(&out->variables, v);
  91     return out;
  92 }
  93
  94 fmi1_import_variable_list_t* fmi1_import_prepend_to_var_list(fmi1_import_variable_list_t* list, fmi1_import_variable_t* v) {
  95     size_t lsize = fmi1_import_get_variable_list_size(list);
  96     fmi1_import_variable_list_t* out = fmi1_import_alloc_variable_list(list->fmu, lsize+1);
  97     if(!out) return 0;
  98     jm_vector_set_item(jm_voidp)(&out->variables,0,v);
  99     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);
 100     return out;
 101 }
 102
 103 jm_status_enu_t fmi1_import_var_list_push_back(fmi1_import_variable_list_t* list, fmi1_import_variable_t* v) {
 104     if(!jm_vector_push_back(jm_voidp)(&list->variables, v)) return jm_status_error;
 105     return jm_status_success;
 106 }
 107
 108 /* Get a pointer to the list of the value references for all the variables */
 109 const fmi1_value_reference_t* fmi1_import_get_value_referece_list(fmi1_import_variable_list_t* vl) {
 110     if(!vl->vr) {
 111                 jm_callbacks* cb = vl->fmu->callbacks;
 112         size_t nv = fmi1_import_get_variable_list_size(vl);
 113                 unsigned i = (unsigned)nv;
 114                 assert( i == nv);
 115                 vl->vr = (fmi1_value_reference_t*)cb->malloc(nv * sizeof(fmi1_value_reference_t));
 116         if(vl->vr) {
 117             for(i = 0; i < nv; i++) {
 118                                 vl->vr[i] = fmi1_xml_get_variable_vr(fmi1_import_get_variable(vl, i));
 119             }
 120         }
 121                 else return 0;
 122     }
 123     return vl->vr;
 124 }
 125
 126 /* Get a single variable from the list*/
 127 fmi1_import_variable_t* fmi1_import_get_variable(fmi1_import_variable_list_t* vl, unsigned int  index) {
 128         if(index >= fmi1_import_get_variable_list_size(vl))
 129                 return 0;
 130         else
 131                 return (fmi1_import_variable_t*)jm_vector_get_item(jm_voidp)(&vl->variables, index);
 132 }
 133
 134 /* Operations on variable lists. Every operation creates a new list. */
 135 /* Select sub-lists */
 136 fmi1_import_variable_list_t* fmi1_import_get_sublist(fmi1_import_variable_list_t* vl, unsigned int  fromIndex, unsigned int  toIndex) {
 137     fmi1_import_variable_list_t* out;
 138     size_t size, i;
 139     if(fromIndex > toIndex) return 0;
 140     if(toIndex >=  fmi1_import_get_variable_list_size(vl)) return 0;
 141     size = toIndex - fromIndex + 1;
 142     out = fmi1_import_alloc_variable_list(vl->fmu, size);
 143     if(!out ) return 0;
 144     for(i=0; i < size; i++) {
 145         jm_vector_set_item(jm_voidp)(&out->variables, i, jm_vector_get_item(jm_voidp)(&vl->variables, fromIndex+i));
 146     }
 147     return out;
 148 }
 149
 150 /* fmi1_import_filter_variables calls  the provided 'filter' function on every variable in the list.
 151   It returns a sub-list list with the variables for which filter returned non-zero value. */
 152 fmi1_import_variable_list_t* fmi1_import_filter_variables(fmi1_import_variable_list_t* vl, fmi1_import_variable_filter_function_ft filter, void* context) {
 153     size_t nv;
 154         unsigned i;
 155     fmi1_import_variable_list_t* out;
 156     nv = fmi1_import_get_variable_list_size(vl);
 157         i = (unsigned) nv;
 158         if(i != nv) return 0; /* this is not really possible */
 159         out = fmi1_import_alloc_variable_list(vl->fmu, 0);
 160         if(!out) return 0; /* out of memory */
 161     for(i=0; i < nv;i++) {
 162         fmi1_import_variable_t* variable = fmi1_import_get_variable(vl, i);
 163         if(filter(variable, context))
 164             if(!jm_vector_push_back(jm_voidp)(&out->variables, variable))
 165                 break;
 166     }
 167     if(i != nv) {
 168         fmi1_import_free_variable_list(out);
 169         out = 0;
 170     }
 171     return out;
 172 }