Skip to content

Commit cd2cbbd

Browse files
mpsonntagmpsonntag
committed
add write values
1 parent c7371d1 commit cd2cbbd

File tree

3 files changed

+44
-86
lines changed

3 files changed

+44
-86
lines changed

‎+nix/Property.m‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,10 +28,17 @@
2828
[obj.valuesCache, retVals] = nix.Utils.fetchPropList(obj.updatedAt, ...
2929
'Property::values', obj.nix_handle, obj.valuesCache);
3030
end
31-
31+
3232
function [] = set.values(obj, val)
33+
% TODO: the properties cache in the parent nix.Section
34+
% cannot be easily invalidated and will therefore show stale
35+
% values at the moment.
3336
nix_mx('Property::updateValues', obj.nix_handle, val);
3437
obj.valuesCache.lastUpdate = 0;
38+
39+
dispStr = 'Note: nix only supports updating the actual value at the moment.';
40+
dispStr = [dispStr, char(10), 'Attributes like uncertainty or checksum cannot be set at the moment.'];
41+
disp(dispStr);
3542
end
3643
end
3744

‎src/nixproperty.cc‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,7 @@ namespace nixproperty {
5454
void update_values(const extractor &input, infusor &output)
5555
{
5656
nix::Property prop = input.entity<nix::Property>(1);
57+
prop.deleteValues();
5758
std::vector<nix::Value> getVals = input.extractFromStruct(2);
5859
prop.values(getVals);
5960
}

‎src/utils/arguments.h‎

Lines changed: 35 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -195,15 +195,11 @@ class extractor : public argument_helper<const mxArray> {
195195

196196
std::vector<nix::Value> extractFromCells(size_t pos) const {
197197

198-
mwSize total_num_of_cells;
199-
mwIndex index;
200-
const mxArray *cell_element_ptr;
201-
202198
std::vector<nix::Value> vals;
203199

204-
total_num_of_cells = mxGetNumberOfElements(array[pos]);
205-
for (index = 0; index<total_num_of_cells; index++) {
206-
cell_element_ptr = mxGetCell(array[pos], index);
200+
mwSize total_num_of_cells = mxGetNumberOfElements(array[pos]);
201+
for (mwIndex index = 0; index<total_num_of_cells; index++) {
202+
const mxArray *cell_element_ptr = mxGetCell(array[pos], index);
207203

208204
nix::Value currVal;
209205

@@ -246,7 +242,7 @@ class extractor : public argument_helper<const mxArray> {
246242
case mxCHAR_CLASS:
247243
{
248244
char *tmp = mxArrayToString(cell_element_ptr);
249-
std::string curr_string(tmp);
245+
std::string curr_string = tmp;
250246
currVal.set(curr_string);
251247
mxFree(tmp);
252248
break;
@@ -263,136 +259,90 @@ class extractor : public argument_helper<const mxArray> {
263259

264260
std::vector<nix::Value> extractFromStruct(size_t pos) const {
265261

266-
mwSize total_num_of_cells;
267-
mwIndex index;
268-
const mxArray *cell_element_ptr;
262+
// Note: nix::Value is not able to its attributes "uncertainty"
263+
// "checksum", "filename", "encoder" or "reference" at the moment.
264+
// The setters are implemented and the attribute values are
265+
// correctly set to the nix::Value entity, but they will not
266+
// actually be written to the nix file. Once this issue has been
267+
// fixed on the nix side, the current implementation should work
268+
// fine.
269269

270270
std::vector<nix::Value> vals;
271271

272-
total_num_of_cells = mxGetNumberOfElements(array[pos]);
273-
for (index = 0; index<total_num_of_cells; index++) {
274-
cell_element_ptr = mxGetCell(array[pos], index);
272+
mwSize total_num_of_cells = mxGetNumberOfElements(array[pos]);
273+
for (mwIndex index = 0; index<total_num_of_cells; index++) {
274+
const mxArray *cell_element_ptr = mxGetCell(array[pos], index);
275275

276276
if (mxGetClassID(cell_element_ptr) == mxSTRUCT_CLASS){
277277

278278
nix::Value currVal;
279279

280-
mwSize total_num_of_elements;
281-
mwIndex struct_idx;
282-
int number_of_fields;
283-
int field_index;
284-
285-
total_num_of_elements = mxGetNumberOfElements(cell_element_ptr);
286-
number_of_fields = mxGetNumberOfFields(cell_element_ptr);
287-
288-
mexPrintf("numEl: %d, numField: %d\n", total_num_of_elements, number_of_fields);
289-
290-
for (struct_idx = 0; struct_idx < total_num_of_elements; struct_idx++) {
291-
for (field_index = 0; field_index < number_of_fields; field_index++) {
292-
const char *field_name;
293-
const mxArray *field_array_ptr;
294-
field_name = mxGetFieldNameByNumber(cell_element_ptr, field_index);
295-
field_array_ptr = mxGetFieldByNumber(cell_element_ptr, struct_idx, field_index);
296-
mexPrintf("\n.%s, %d, %d\n", field_name, struct_idx, field_index);
297-
if (field_array_ptr == NULL) {
298-
mexPrintf("\tEmpty Field\n");
299-
}
300-
else
301-
{
280+
mwSize total_num_of_elements = mxGetNumberOfElements(cell_element_ptr);
281+
int number_of_fields = mxGetNumberOfFields(cell_element_ptr);
282+
283+
for (mwIndex struct_idx = 0; struct_idx < total_num_of_elements; struct_idx++) {
284+
for (int field_index = 0; field_index < number_of_fields; field_index++) {
285+
const char *field_name = mxGetFieldNameByNumber(cell_element_ptr, field_index);
286+
const mxArray *field_array_ptr = mxGetFieldByNumber(cell_element_ptr, struct_idx, field_index);
287+
288+
if (field_array_ptr != nullptr) {
302289
if (strcmp(field_name, "value") == 0){
303-
mexPrintf("class: %d\n", mxGetClassID(field_array_ptr));
304-
mexPrintf("1 field: %s, value: ", field_name);
305290
if (mxGetClassID(field_array_ptr) == mxDOUBLE_CLASS){
306-
mexPrintf("double\n");
307291
double curr;
308292
const void *data = mxGetData(field_array_ptr);
309293
memcpy(&curr, data, sizeof(double));
310294
currVal.set(curr);
311-
mexPrintf("%d\n", currVal.get<double>());
312295
}
313296
else if (mxGetClassID(field_array_ptr) == mxLOGICAL_CLASS){
314-
mexPrintf("logical\n");
315297
const mxLogical *curr = mxGetLogicals(field_array_ptr);
316298
currVal.set(curr[0]);
317299
}
318300
else if (mxGetClassID(field_array_ptr) == mxCHAR_CLASS){
319-
mexPrintf("string\n");
320301
char *tmp = mxArrayToString(field_array_ptr);
321-
if (*tmp != NULL)
322-
{
323-
std::string curr_string(tmp);
324-
currVal.set(curr_string);
325-
}
302+
std::string curr_string = tmp;
303+
currVal.set(curr_string);
326304
mxFree(tmp);
327-
mexPrintf("%s\n", currVal.get<std::string>());
328-
}
329-
else{
330-
mexPrintf("sometyhing else\n");
331305
}
306+
else { mexPrintf("Unsupported value data type\n"); }
332307

333308
}
334309
else if (strcmp(field_name, "uncertainty") == 0){
335-
mexPrintf("2 field: %s, value: ", field_name);
336310
if (mxGetClassID(field_array_ptr) == mxDOUBLE_CLASS){
337311
double curr;
338312
const void *data = mxGetData(field_array_ptr);
339313
memcpy(&curr, data, sizeof(double));
340314
currVal.uncertainty = curr;
341-
mexPrintf("%d, %d\n", curr, currVal.uncertainty);
342315
}
343316
}
344317
else if (strcmp(field_name, "checksum") == 0){
345-
mexPrintf("3 field: %s, value: \n", field_name);
346318
if (mxGetClassID(field_array_ptr) == mxCHAR_CLASS){
347319
char *tmp = mxArrayToString(field_array_ptr);
348-
if (tmp != NULL)
349-
{
350-
mexPrintf("get %s string, ", field_name);
351-
std::string curr_string(tmp);
352-
mexPrintf("set value %s\n", curr_string);
353-
currVal.checksum = curr_string;
354-
}
320+
std::string curr_string = tmp;
321+
currVal.checksum = curr_string;
355322
mxFree(tmp);
356323
}
357324
}
358325
else if (strcmp(field_name, "encoder") == 0){
359-
mexPrintf("4 field: %s, value: \n", field_name);
360326
if (mxGetClassID(field_array_ptr) == mxCHAR_CLASS){
361327
char *tmp = mxArrayToString(field_array_ptr);
362-
if (tmp != NULL)
363-
{
364-
mexPrintf("get %s string\n", field_name);
365-
std::string curr_string(tmp);
366-
currVal.encoder = curr_string;
367-
}
328+
std::string curr_string = tmp;
329+
currVal.encoder = curr_string;
368330
mxFree(tmp);
369331
}
370332
}
371333
else if (strcmp(field_name, "filename") == 0){
372-
mexPrintf("5 field: %s, value: \n", field_name);
373334
if (mxGetClassID(field_array_ptr) == mxCHAR_CLASS){
374335
char *tmp = mxArrayToString(field_array_ptr);
375-
if (tmp != NULL)
376-
{
377-
mexPrintf("get %s string\n", field_name);
378-
std::string curr_string(tmp);
379-
currVal.filename = curr_string;
380-
}
336+
std::string curr_string = tmp;
337+
currVal.filename = curr_string;
381338
mxFree(tmp);
382339
}
383340
}
384341
else if (strcmp(field_name, "reference") == 0){
385-
mexPrintf("6 field: %s, value: \n", field_name);
386342
if (mxGetClassID(field_array_ptr) == mxCHAR_CLASS){
387343
char *tmp = mxArrayToString(field_array_ptr);
388-
if (tmp != NULL)
389-
{
390-
mexPrintf("get %s string, set value %s", field_name, tmp);
391-
//std::string curr_string(tmp);
392-
//mexPrintf("set value %s\n", curr_string);
393-
currVal.reference = *tmp;
394-
mexPrintf("get %s string, get value %s", field_name, currVal.reference);
395-
}
344+
std::string curr_string(tmp);
345+
currVal.reference = tmp;
396346
mxFree(tmp);
397347
}
398348
}
@@ -403,7 +353,7 @@ class extractor : public argument_helper<const mxArray> {
403353
}
404354
else
405355
{
406-
mexWarnMsgTxt("Unsupported value wrapper type");
356+
mexWarnMsgTxt("Unsupported value wrapper data type");
407357
}
408358
}
409359
return vals;

0 commit comments

Comments
 (0)