write property values to nix

Author: mpsonntag

+nix/Section.m

@@ -95,6 +95,12 @@
             obj.propsCache.lastUpdate = 0;
         end;
 
+        function p = create_property_with_value(obj, name, val)
+            p = nix.Property(nix_mx('Section::createPropertyWithValue', ...
+                obj.nix_handle, name, val));
+            obj.propsCache.lastUpdate = 0;
+        end;
+
         function delCheck = delete_property(obj, del)
             if(isstruct(del) && isfield(del, 'id'))
                 delID = del.id;

nix_mx.cc

@@ -235,6 +235,7 @@ void mexFunction(int            nlhs,
             .reg("deleteProperty", REMOVER(nix::Property, nix::Section, deleteProperty));
         methods->add("Section::properties", nixsection::properties);
         methods->add("Section::createProperty", nixsection::create_property);
+        methods->add("Section::createPropertyWithValue", nixsection::create_property_with_value);
 
         classdef<nix::Feature>("Feature", methods)
             .desc(&nixfeature::describe)

src/nixsection.cc

@@ -69,4 +69,13 @@ void create_property(const extractor &input, infusor &output)
     output.set(0, handle(p));
 }
 
+void create_property_with_value(const extractor &input, infusor &output)
+{
+    nix::Section currObj = input.entity<nix::Section>(1);
+    std::vector<nix::Value> currVec = input.extractFromCells(3);
+
+    nix::Property p = currObj.createProperty(input.str(2), currVec);
+    output.set(0, handle(p));
+}
+
 } // namespace nixsection

src/nixsection.h

@@ -11,6 +11,8 @@ namespace nixsection {
 
     void create_property(const extractor &input, infusor &output);
 
+    void create_property_with_value(const extractor &input, infusor &output);
+
 } // namespace nixfile
 
-#endif
+#endif

src/utils/arguments.h

@@ -193,6 +193,74 @@ class extractor : public argument_helper<const mxArray> {
         return mxGetPr(array[pos]);
     }
 
+    std::vector<nix::Value> extractFromCells(size_t pos) const {
+
+        mwSize total_num_of_cells;
+        mwIndex index;
+        const mxArray *cell_element_ptr;
+
+        std::vector<nix::Value> vals;
+
+        total_num_of_cells = mxGetNumberOfElements(array[pos]);
+        for (index = 0; index<total_num_of_cells; index++)  {
+            cell_element_ptr = mxGetCell(array[pos], index);
+
+            nix::Value currVal;
+
+            switch (mxGetClassID(cell_element_ptr)) {
+                case mxLOGICAL_CLASS:
+                {
+                    const mxLogical *curr = mxGetLogicals(cell_element_ptr);
+                    currVal.set(curr[0]); break; }
+                case mxDOUBLE_CLASS:
+                {
+                    double curr;
+                    const void *data = mxGetData(cell_element_ptr);
+                    memcpy(&curr, data, sizeof(double));
+                    currVal.set(curr); break; }
+                case mxUINT32_CLASS:
+                {
+                    uint32_t curr;
+                    const void *data = mxGetData(cell_element_ptr);
+                    memcpy(&curr, data, sizeof(uint32_t));
+                    currVal.set(curr); break; }
+                case mxINT32_CLASS:
+                {
+                    int32_t curr;
+                    const void *data = mxGetData(cell_element_ptr);
+                    memcpy(&curr, data, sizeof(int32_t));
+                    currVal.set(curr); break; }
+                case mxUINT64_CLASS:
+                {
+                    uint64_t curr;
+                    const void *data = mxGetData(cell_element_ptr);
+                    memcpy(&curr, data, sizeof(uint64_t));
+                    currVal.set(curr); break; }
+                case mxINT64_CLASS:
+                {
+                    int64_t curr;
+                    const void *data = mxGetData(cell_element_ptr);
+                    memcpy(&curr, data, sizeof(int64_t));
+                    currVal.set(curr); break; }
+
+                case mxCHAR_CLASS:
+                {
+                    char *tmp = mxArrayToString(cell_element_ptr);
+                    std::string curr_string(tmp);
+                    currVal.set(curr_string);
+                    mxFree(tmp);
+                    break;
+                }
+                case mxUNKNOWN_CLASS:
+                { mexWarnMsgTxt("Unknown class."); break; }
+                default:
+                { mexWarnMsgTxt("Unsupported class."); break; }
+            }
+            vals.push_back(currVal);
+        }
+        return vals;
+    }
+
 private:
 };
 
@@ -214,4 +282,4 @@ class infusor : public argument_helper<mxArray> {
 private:
 };
 
-#endif
+#endif

tests/TestSection.m

@@ -11,7 +11,8 @@
     funcs{end+1} = @test_has_section;
     funcs{end+1} = @test_attrs;
     funcs{end+1} = @test_properties;
-    funcs{end+1} = @test_create_property_data_type;
+    funcs{end+1} = @test_create_property;
+    funcs{end+1} = @test_create_property_with_value;
     funcs{end+1} = @test_delete_property;
     funcs{end+1} = @test_open_property;
     funcs{end+1} = @test_link;
@@ -139,7 +140,7 @@
 end
 
 %% Test: Create property by data type
-function [] = test_create_property_data_type( varargin )
+function [] = test_create_property( varargin )
     f = nix.File(fullfile(pwd,'tests','testRW.h5'), nix.FileMode.Overwrite);
     s = f.createSection('mainSection', 'nixSection');
 
@@ -153,6 +154,31 @@
     assert(strcmp(s.allProperties{1}.name, 'newProperty1'));
 end
 
+%% Test: Create property with value
+function [] = test_create_property_with_value( varargin )
+    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.allProperties{1}.values{1} == 5);
+    assert(size(s.allProperties{1}.values, 2) == 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.allProperties{2}.values{1}, 'this'));
+    assert(size(s.allProperties{2}.values, 2) == 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.allProperties{3}.values{1});
+    assert(~s.allProperties{3}.values{2});
+    assert(size(s.allProperties{3}.values, 2) == 3);
+    assert(strcmpi(tmp.datatype, 'bool'));
+end
+
 %% Test: Delete property by entity, propertyStruct, ID and name
 function [] = test_delete_property( varargin )
     f = nix.File(fullfile(pwd,'tests','testRW.h5'), nix.FileMode.Overwrite);