merged changes and resolved conflicts

asobolev · asobolev · commit fe37453392a1 · 2015-03-20T13:32:54.000+01:00
diff --git a/+nix/Property.m b/+nix/Property.m
@@ -30,7 +30,24 @@
         end
 
         function [] = set.values(obj, val)
-            nix_mx('Property::updateValues', obj.nix_handle, val);
+            values = val;
+            if (~iscell(values))
+                values = num2cell(val);
+            end
+            
+            for i = 1:length(values)
+                if (isstruct(values{i}))
+                    curr = values{i}.value;
+                else
+                    curr = values{i};
+                end
+                
+                if (~strcmpi(class(curr), obj.datatype))
+                    error('Values do not match property data type!');
+                end
+            end
+            
+            nix_mx('Property::updateValues', obj.nix_handle, values);
             obj.valuesCache.lastUpdate = 0;
 
             dispStr = 'Note: nix only supports updating the actual value at the moment.';
diff --git a/+nix/Section.m b/+nix/Section.m
@@ -96,6 +96,9 @@
         end;
 
         function p = create_property_with_value(obj, name, val)
+            if(~iscell(val))
+                val = num2cell(val);
+            end;
             p = nix.Property(nix_mx('Section::createPropertyWithValue', ...
                 obj.nix_handle, name, val));
             obj.propsCache.lastUpdate = 0;
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -42,8 +42,10 @@ namespace nixdataarray {
 
     void read_all(const extractor &input, infusor &output)
     {
+        //nix::DataArray da = input.entity<nix::DataArray>(1);
+
         nix::DataArray da = input.entity<nix::DataArray>(1);
-        mxArray *data = make_mx_array(da);
+        mxArray *data = make_mx_array_from_ds(da);
         output.set(0, data);
     }
 
diff --git a/src/nixmultitag.cc b/src/nixmultitag.cc
@@ -49,7 +49,7 @@ namespace nixmultitag {
         double p_index = input.num<double>(2);
         double f_index = input.num<double>(3);
 
-        mxArray *data = make_mx_array(currObj.retrieveData(p_index, f_index));
+        mxArray *data = make_mx_array_from_ds(currObj.retrieveData(p_index, f_index));
         output.set(0, data);
     }
 
@@ -58,7 +58,7 @@ namespace nixmultitag {
         double p_index = input.num<double>(2);
         double f_index = input.num<double>(3);
 
-        mxArray *data = make_mx_array(currObj.retrieveFeatureData(p_index, f_index));
+        mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(p_index, f_index));
         output.set(0, data);
     }
 
diff --git a/src/nixproperty.cc b/src/nixproperty.cc
@@ -1,7 +1,6 @@
 #include "nixproperty.h"
-
 #include "mex.h"
-
+#include "datatypes.h"
 #include <nix.hpp>
 
 #include "handle.h"
@@ -19,7 +18,7 @@ namespace nixproperty {
         sb.set(prop.definition());
         sb.set(prop.unit());
         sb.set(prop.mapping());
-        sb.set(nix::data_type_to_string(prop.dataType()));
+        sb.set(string_nix2mex(prop.dataType()));
 
         return sb.array();
     }
@@ -55,6 +54,7 @@ namespace nixproperty {
     {
         nix::Property prop = input.entity<nix::Property>(1);
         prop.deleteValues();
+
         std::vector<nix::Value> getVals = input.vec(2);
         prop.values(getVals);
     }
diff --git a/src/nixsection.cc b/src/nixsection.cc
@@ -1,5 +1,4 @@
 #include "nixsection.h"
-
 #include "mex.h"
 #include <nix.hpp>
 
@@ -68,9 +67,9 @@ void create_property(const extractor &input, infusor &output)
 void create_property_with_value(const extractor &input, infusor &output)
 {
     nix::Section currObj = input.entity<nix::Section>(1);
-    std::vector<nix::Value> currVec = input.vec(3);
 
-    nix::Property p = currObj.createProperty(input.str(2), currVec);
+    std::vector<nix::Value> vals = input.vec(3);
+    nix::Property p = currObj.createProperty(input.str(2), vals);
     output.set(0, handle(p));
 }
 
diff --git a/src/nixtag.cc b/src/nixtag.cc
@@ -50,15 +50,15 @@ namespace nixtag {
         nix::Tag currObj = input.entity<nix::Tag>(1);
         double index = input.num<double>(2);
 
-        mxArray *data = make_mx_array(currObj.retrieveData(index));
+        mxArray *data = make_mx_array_from_ds(currObj.retrieveData(index));
         output.set(0, data);
     }
 
     void retrieve_feature_data(const extractor &input, infusor &output) {
         nix::Tag currObj = input.entity<nix::Tag>(1);
         double index = input.num<double>(2);
 
-        mxArray *data = make_mx_array(currObj.retrieveFeatureData(index));
+        mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(index));
         output.set(0, data);
     }
 
diff --git a/src/utils/datatypes.h b/src/utils/datatypes.h
@@ -69,4 +69,20 @@ inline DType2 dtype_nix2mex (nix::DataType dtype) {
 	return dt;
 }
 
+inline std::string string_nix2mex(nix::DataType dtype) {
+    std::string dt;
+
+    switch (dtype) {
+    case nix::DataType::Bool: dt = "logical"; break;
+    case nix::DataType::String: dt = "char"; break;
+    case nix::DataType::Float: dt = "single"; break;
+
+    default: dt = nix::data_type_to_string(dtype);
+    }
+
+    std::transform(dt.begin(), dt.end(), dt.begin(), ::tolower);
+
+    return dt;
+}
+
 #endif
diff --git a/src/utils/mkarray.cc b/src/utils/mkarray.cc
@@ -2,7 +2,7 @@
 #include "mex.h"
 #include <nix.hpp>
 
-mxArray* make_mx_array(const nix::DataSet &da) {
+mxArray* make_mx_array_from_ds(const nix::DataSet &da) {
     nix::NDSize size = da.dataExtent();
     const size_t len = size.size();
     std::vector<mwSize> dims(len);
diff --git a/src/utils/mkarray.h b/src/utils/mkarray.h
@@ -19,7 +19,7 @@ inline mxArray* make_mx_array(const std::string &s)
 	return mxCreateString(s.c_str());
 }
 
-mxArray* make_mx_array(const nix::DataSet &da);
+mxArray* make_mx_array_from_ds(const nix::DataSet &da);
 
 mxArray* make_mx_array(const nix::Value &value);
 
diff --git a/src/utils/mknix.cc b/src/utils/mknix.cc
@@ -164,8 +164,7 @@ std::vector<nix::Value> mx_to_values(const mxArray *arr) {
     To convert to a vector of Values we actually expect either
     - a cell array with scalar values, or
     - a cell array with structs each having Value attrs
-    (uncertainty, checksum etc.) as fields, or
-    - a regular array
+    (uncertainty, checksum etc.) as fields
     */
     std::vector<nix::Value> vals;
     const mxArray *cell_element_ptr;
diff --git a/tests/TestProperty.m b/tests/TestProperty.m
@@ -15,7 +15,7 @@
     p = s.create_property('testProperty1', nix.DataType.String);
 
     assert(~isempty(p.id));
-    assert(strcmpi(p.datatype, 'string'));
+    assert(strcmpi(p.datatype, 'char'));
     assert(strcmp(p.name, 'testProperty1'));
 
     assert(isempty(p.definition));
@@ -78,4 +78,26 @@
     assert(updateDouble.values{1}.value == 2);
     updateDouble.values{1}.value = 2.2;
     assert(updateDouble.values{1}.value == 2.2);
+    
+    %-- test remove values from property
+    delValues = s.open_property(s.allProperties{3}.id);
+    assert(size(delValues.values, 1) == 4);
+    delValues.values = {};
+    assert(size(delValues.values, 1) == 0);
+    clear delValues;
+    
+    %-- test add new values to empty value property
+    newValues = s.open_property(s.allProperties{3}.id);
+    newValues.values = [1,2,3,4,5];
+    assert(newValues.values{5}.value == 5);
+    newValues.values = {};
+    newValues.values = {6,7,8};
+    assert(newValues.values{3}.value == 8);
+    
+    %-- test add new values by value structure
+    val1 = newValues.values{1};
+    val2 = newValues.values{2};
+    updateNewDouble = s.create_property('doubleProperty2', nix.DataType.Double);
+    updateNewDouble.values = {val1, val2};
+    assert(s.open_property(s.allProperties{end}.id).values{2}.value == val2.value);
 end
diff --git a/tests/TestSection.m b/tests/TestSection.m
@@ -156,24 +156,58 @@
     f = nix.File(fullfile(pwd,'tests','testRW.h5'), nix.FileMode.Overwrite);
     s = f.createSection('mainSection', 'nixSection');
 
-    tmp = s.create_property_with_value('doubleProperty', {5, 6, 7, 8});
-    assert(strcmp(s.allProperties{1}.name, 'doubleProperty'));
-    assert(s.open_property(s.allProperties{1}.id).values{1}.value == 5);
-    assert(size(s.open_property(s.allProperties{1}.id).values, 1) == 4);
+    tmp = s.create_property_with_value('doubleProperty1', [5, 6, 7, 8]);
+    assert(strcmp(s.allProperties{end}.name, 'doubleProperty1'));
+    assert(s.open_property(s.allProperties{end}.id).values{1}.value == 5);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 4);
+    assert(strcmpi(tmp.datatype,'double'));
+    
+    tmp = s.create_property_with_value('doubleProperty2', {5, 6, 7, 8});
+    assert(strcmp(s.allProperties{end}.name, 'doubleProperty2'));
+    assert(s.open_property(s.allProperties{end}.id).values{1}.value == 5);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 4);
     assert(strcmpi(tmp.datatype,'double'));
 
-    tmp = s.create_property_with_value('stringProperty', {'this', 'has', 'strings'});
-    assert(strcmp(s.allProperties{2}.name, 'stringProperty'));
-    assert(strcmp(s.open_property(s.allProperties{2}.id).values{1}.value, 'this'));
-    assert(size(s.open_property(s.allProperties{2}.id).values, 1) == 3);
-    assert(strcmpi(tmp.datatype, 'string'));
-
-    tmp = s.create_property_with_value('booleanProperty', {true, false, true});
-    assert(strcmp(s.allProperties{3}.name, 'booleanProperty'));
-    assert(s.open_property(s.allProperties{3}.id).values{1}.value);
-    assert(~s.open_property(s.allProperties{3}.id).values{2}.value);
-    assert(size(s.open_property(s.allProperties{3}.id).values, 1) == 3);
-    assert(strcmpi(tmp.datatype, 'bool'));
+    tmp = s.create_property_with_value('stringProperty1', ['a', 'string']);
+    assert(strcmp(s.allProperties{end}.name, 'stringProperty1'));
+    assert(strcmp(s.open_property(s.allProperties{end}.id).values{1}.value, 'a'));
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 7);
+    assert(strcmpi(tmp.datatype, 'char'));
+    
+    tmp = s.create_property_with_value('stringProperty2', {'this', 'has', 'strings'});
+    assert(strcmp(s.allProperties{end}.name, 'stringProperty2'));
+    assert(strcmp(s.open_property(s.allProperties{end}.id).values{1}.value, 'this'));
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 3);
+    assert(strcmpi(tmp.datatype, 'char'));
+
+    tmp = s.create_property_with_value('booleanProperty1', [true, false, true]);
+    assert(strcmp(s.allProperties{end}.name, 'booleanProperty1'));
+    assert(s.open_property(s.allProperties{end}.id).values{1}.value);
+    assert(~s.open_property(s.allProperties{end}.id).values{2}.value);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 3);
+    assert(strcmpi(tmp.datatype, 'logical'));
+
+    tmp = s.create_property_with_value('booleanProperty2', {true, false, true});
+    assert(strcmp(s.allProperties{end}.name, 'booleanProperty2'));
+    assert(s.open_property(s.allProperties{end}.id).values{1}.value);
+    assert(~s.open_property(s.allProperties{end}.id).values{2}.value);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 3);
+    assert(strcmpi(tmp.datatype, 'logical'));
+    
+    val1 = s.open_property(s.allProperties{1}.id).values{1};
+    val2 = s.open_property(s.allProperties{1}.id).values{2};
+    tmp = s.create_property_with_value('doubleByStrunct1', [val1, val2]);
+    assert(strcmp(s.allProperties{end}.name, 'doubleByStrunct1'));
+    assert(s.open_property(s.allProperties{end}.id).values{1}.value == 5);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 2);
+    assert(strcmpi(tmp.datatype,'double'));
+    
+    val3 = s.open_property(s.allProperties{1}.id).values{3};
+    tmp = s.create_property_with_value('doubleByStrunct2', {val1, val2, val3});
+    assert(strcmp(s.allProperties{end}.name, 'doubleByStrunct2'));
+    assert(s.open_property(s.allProperties{end}.id).values{3}.value == 7);
+    assert(size(s.open_property(s.allProperties{end}.id).values, 1) == 3);
+    assert(strcmpi(tmp.datatype,'double'));
 end
 
 %% Test: Delete property by entity, propertyStruct, ID and name

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,10 @@ namespace nixdataarray {`
`42`	`42`
`43`	`43`	`void read_all(const extractor &input, infusor &output)`
`44`	`44`	`{`
	`45`	`+ //nix::DataArray da = input.entity<nix::DataArray>(1);`
	`46`	`+`
`45`	`47`	`nix::DataArray da = input.entity<nix::DataArray>(1);`
`46`		`- mxArray *data = make_mx_array(da);`
	`48`	`+ mxArray *data = make_mx_array_from_ds(da);`
`47`	`49`	`output.set(0, data);`
`48`	`50`	`}`
`49`	`51`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ namespace nixmultitag {`
`49`	`49`	`double p_index = input.num<double>(2);`
`50`	`50`	`double f_index = input.num<double>(3);`
`51`	`51`
`52`		`- mxArray *data = make_mx_array(currObj.retrieveData(p_index, f_index));`
	`52`	`+ mxArray *data = make_mx_array_from_ds(currObj.retrieveData(p_index, f_index));`
`53`	`53`	`output.set(0, data);`
`54`	`54`	`}`
`55`	`55`
`@@ -58,7 +58,7 @@ namespace nixmultitag {`
`58`	`58`	`double p_index = input.num<double>(2);`
`59`	`59`	`double f_index = input.num<double>(3);`
`60`	`60`
`61`		`- mxArray *data = make_mx_array(currObj.retrieveFeatureData(p_index, f_index));`
	`61`	`+ mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(p_index, f_index));`
`62`	`62`	`output.set(0, data);`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`#include "nixsection.h"`
`2`		`-`
`3`	`2`	`#include "mex.h"`
`4`	`3`	`#include <nix.hpp>`
`5`	`4`
`@@ -68,9 +67,9 @@ void create_property(const extractor &input, infusor &output)`
`68`	`67`	`void create_property_with_value(const extractor &input, infusor &output)`
`69`	`68`	`{`
`70`	`69`	`nix::Section currObj = input.entity<nix::Section>(1);`
`71`		`- std::vector<nix::Value> currVec = input.vec(3);`
`72`	`70`
`73`		`- nix::Property p = currObj.createProperty(input.str(2), currVec);`
	`71`	`+ std::vector<nix::Value> vals = input.vec(3);`
	`72`	`+ nix::Property p = currObj.createProperty(input.str(2), vals);`
`74`	`73`	`output.set(0, handle(p));`
`75`	`74`	`}`
`76`	`75`
Original file line number	Diff line number	Diff line change
`@@ -50,15 +50,15 @@ namespace nixtag {`
`50`	`50`	`nix::Tag currObj = input.entity<nix::Tag>(1);`
`51`	`51`	`double index = input.num<double>(2);`
`52`	`52`
`53`		`- mxArray *data = make_mx_array(currObj.retrieveData(index));`
	`53`	`+ mxArray *data = make_mx_array_from_ds(currObj.retrieveData(index));`
`54`	`54`	`output.set(0, data);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`void retrieve_feature_data(const extractor &input, infusor &output) {`
`58`	`58`	`nix::Tag currObj = input.entity<nix::Tag>(1);`
`59`	`59`	`double index = input.num<double>(2);`
`60`	`60`
`61`		`- mxArray *data = make_mx_array(currObj.retrieveFeatureData(index));`
	`61`	`+ mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(index));`
`62`	`62`	`output.set(0, data);`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ inline mxArray* make_mx_array(const std::string &s)`
`19`	`19`	`return mxCreateString(s.c_str());`
`20`	`20`	`}`
`21`	`21`
`22`		`-mxArray* make_mx_array(const nix::DataSet &da);`
	`22`	`+mxArray* make_mx_array_from_ds(const nix::DataSet &da);`
`23`	`23`
`24`	`24`	`mxArray* make_mx_array(const nix::Value &value);`
`25`	`25`