extractor for vector of strings + setters on Tag

Author: asobolev

nix_mx.cc

@@ -171,8 +171,13 @@ void mexFunction(int            nlhs,
             .reg("openFeature", GETBYSTR(nix::Feature, nix::Tag, getFeature))
             .reg("openSource", GETBYSTR(nix::Source, nix::Tag, getSource))
             .reg("openMetadataSection", GETCONTENT(nix::Section, nix::Tag, metadata))
+            .reg("set_units", SETTER(const std::vector<std::string>&, nix::Tag, units))
+            .reg("set_none_units", SETTER(const boost::none_t, nix::Tag, units))
             .reg("set_metadata", SETTER(const std::string&, nix::Tag, metadata))
             .reg("set_none_metadata", SETTER(const boost::none_t, nix::Tag, metadata))
+            .reg("set_type", SETTER(const std::string&, nix::Tag, type))
+            .reg("set_definition", SETTER(const std::string&, nix::Tag, definition))
+            .reg("set_none_definition", SETTER(const boost::none_t, nix::Tag, definition))
             .reg("removeReference", REMOVER(nix::DataArray, nix::Tag, removeReference))
             .reg("removeSource", REMOVER(nix::Source, nix::Tag, removeSource))
             .reg("deleteFeature", REMOVER(nix::Feature, nix::Tag, deleteFeature));

src/utils/arguments.h

@@ -88,7 +88,11 @@ class extractor : public argument_helper<const mxArray> {
     template<typename T>
     std::vector<T> vec(size_t pos) const {
         std::vector<T> res;
-        T *pr = mxGetPr(array[pos]);
+
+        T *pr;
+        void *voidp = mxGetData(array[pos]);
+        assert(sizeof(pr) == sizeof(voidp));
+        memcpy(&pr, &voidp, sizeof(pr));
 
         mwSize input_size = mxGetNumberOfElements(array[pos]);
         for (mwSize index = 0; index < input_size; index++)  {
@@ -98,6 +102,35 @@ class extractor : public argument_helper<const mxArray> {
         return res;
     }
 
+    template<>
+    std::vector<std::string> vec(size_t pos) const {
+        /*
+        To convert to a string vector we actually expect a cell 
+        array of strings. It's a logical representation since matlab 
+        arrays require that elements have equal length.
+        */
+        std::vector<std::string> res;
+        const mxArray *el_ptr;
+
+        mwSize length = mxGetNumberOfElements(array[pos]);
+        mwIndex index;
+
+        for (index = 0; index < length; index++)  {
+            el_ptr = mxGetCell(array[pos], index);
+
+            if (!mxIsChar(el_ptr)) {
+                throw std::invalid_argument("All elements of a cell array should be of a string type");
+            }
+
+            char *tmp = mxArrayToString(el_ptr);
+            std::string the_string(tmp);
+            res.push_back(the_string);
+            mxFree(tmp);
+        }
+
+        return res;
+    }
+
     nix::NDSize ndsize(size_t pos) const {
         return mx_array_to_ndsize(array[pos]);
     }

tests/TestTag.m

@@ -19,6 +19,7 @@
     funcs{end+1} = @test_open_metadata;
     funcs{end+1} = @test_retrieve_data;
     funcs{end+1} = @test_retrieve_feature_data;
+    funcs{end+1} = @test_attrs;
 end
 
 %% Test: Add sources by entity and id
@@ -289,3 +290,31 @@
     % TODO
     disp('Test Tag: retrieve feature ... TODO (proper testfile)');
 end
+
+function [] = test_attrs( varargin )
+%% Test: Access Attributes
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.createBlock('testBlock', 'nixBlock');
+    t1 = b.create_tag('testTag', 'nixTag', [1, 2, 3, 4]);
+
+    assert(~isempty(t1.id));
+    assert(strcmp(t1.name, 'testTag'));
+    assert(strcmp(t1.type, 'nixTag'));
+
+    t1.type = 'nixTagTest';
+    assert(strcmp(t1.type, 'nixTagTest'));
+
+    assert(isempty(t1.definition));
+    t1.definition = 'definition';
+    assert(strcmp(t1.definition, 'definition'));
+
+    t1.definition = '';
+    assert(isempty(t1.definition));
+
+    assert(isempty(t1.units));
+    t1.units = {'ms', 'mV'};
+    assert(isequal(t1.units, {'ms', 'mV'}));
+
+    t1.units = {};
+    assert(isempty(t1.units));
+end