Merge pull request #137 from mpsonntag/createMulti

gicmo · web-flow · commit 1741ba77f12f · 2017-06-27T10:15:04.000+02:00
Add multiple entities

LGTM
diff --git a/+nix/Group.m b/+nix/Group.m
@@ -49,6 +49,11 @@
                 'nix.DataArray', 'Group::addDataArray');
         end;
 
+        function [] = add_data_arrays(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.DataArray', strcat(obj.alias, '::addDataArrays'));
+        end
+
         function delCheck = remove_data_array(obj, del)
             delCheck = nix.Utils.delete_entity(obj, del, ...
                 'nix.DataArray', 'Group::removeDataArray');
@@ -63,6 +68,11 @@
                 'nix.Tag', 'Group::addTag');
         end;
 
+        function [] = add_tags(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.Tag', strcat(obj.alias, '::addTags'));
+        end
+
         function hasTag = has_tag(obj, id_or_name)
             hasTag = nix_mx('Group::hasTag', obj.nix_handle, id_or_name);
         end;
@@ -90,6 +100,11 @@
                 'nix.MultiTag', 'Group::addMultiTag');
         end;
 
+        function [] = add_multi_tags(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.MultiTag', strcat(obj.alias, '::addMultiTags'));
+        end
+
         function hasMTag = has_multi_tag(obj, id_or_name)
             hasMTag = nix_mx('Group::hasMultiTag', ...
                 obj.nix_handle, id_or_name);
diff --git a/+nix/MultiTag.m b/+nix/MultiTag.m
@@ -37,6 +37,11 @@
                 'nix.DataArray', 'MultiTag::addReference');
         end;
 
+        function [] = add_references(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.DataArray', strcat(obj.alias, '::addReferences'));
+        end
+
         function hasRef = has_reference(obj, id_or_name)
             hasRef = nix_mx('MultiTag::hasReference', ...
                 obj.nix_handle, id_or_name);
diff --git a/+nix/SourcesMixIn.m b/+nix/SourcesMixIn.m
@@ -38,6 +38,11 @@
                 'nix.Source', strcat(obj.alias, '::addSource'));
         end
 
+        function [] = add_sources(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.Source', strcat(obj.alias, '::addSources'));
+        end
+
         function delCheck = remove_source(obj, del)
             delCheck = nix.Utils.delete_entity(obj, del, ...
                 'nix.Source', strcat(obj.alias, '::removeSource'));
@@ -48,6 +53,7 @@
                 strcat(obj.alias, '::openSource'), id_or_name, ...
                 @nix.Source);
         end
+
     end
 
 end
diff --git a/+nix/Tag.m b/+nix/Tag.m
@@ -39,6 +39,11 @@
                 'nix.DataArray', 'Tag::addReference');
         end;
 
+        function [] = add_references(obj, add_cell_array)
+            nix.Utils.add_entity_array(obj, add_cell_array, ...
+                'nix.DataArray', strcat(obj.alias, '::addReferences'));
+        end
+
         function hasRef = has_reference(obj, id_or_name)
             hasRef = nix_mx('Tag::hasReference', obj.nix_handle, id_or_name);
         end;
diff --git a/+nix/Utils.m b/+nix/Utils.m
@@ -35,6 +35,20 @@
             nix_mx(mxMethod, obj.nix_handle, addID);
         end;
 
+        function [] = add_entity_array(obj, add_cell_array, nixEntity, mxMethod)
+            if(~iscell(add_cell_array))
+                error('Expected cell array');
+            end
+            handle_array = cell(1, length(add_cell_array));
+            for i = 1:length(add_cell_array)
+                if (~strcmpi(class(add_cell_array{i}), nixEntity))
+                    error(sprintf('Element #%s is not a %s.', num2str(i), nixEntity));
+                end
+                handle_array{i} = add_cell_array{i}.nix_handle;
+            end
+            nix_mx(mxMethod, obj.nix_handle, handle_array);
+        end
+
         % Function can be used for both nix delete and remove methods.
         % The first actually removes the entity, the latter
         % removes only the reference to the entity.
diff --git a/nix_mx.cc b/nix_mx.cc
@@ -188,9 +188,13 @@ void mexFunction(int            nlhs,
             .reg("tagCount", GETTER(nix::ndsize_t, nix::Group, tagCount))
             .reg("multiTagCount", GETTER(nix::ndsize_t, nix::Group, multiTagCount));
         methods->add("Group::addDataArray", nixgroup::addDataArray);
+        methods->add("Group::addDataArrays", nixgroup::addDataArrays);
         methods->add("Group::addSource", nixgroup::addSource);
+        methods->add("Group::addSources", nixgroup::addSources);
         methods->add("Group::addTag", nixgroup::addTag);
+        methods->add("Group::addTags", nixgroup::addTags);
         methods->add("Group::addMultiTag", nixgroup::addMultiTag);
+        methods->add("Group::addMultiTags", nixgroup::addMultiTags);
 
         classdef<nix::DataArray>("DataArray", methods)
             .desc(&nixdataarray::describe)
@@ -218,6 +222,7 @@ void mexFunction(int            nlhs,
         methods->add("DataArray::readAll", nixdataarray::readAll);
         methods->add("DataArray::writeAll", nixdataarray::writeAll);
         methods->add("DataArray::addSource", nixdataarray::addSource);
+        methods->add("DataArray::addSources", nixdataarray::addSources);
         // REMOVER for DataArray.removeSource leads to an error, therefore use method->add for now
         methods->add("DataArray::removeSource", nixdataarray::removeSource);
         methods->add("DataArray::openSource", nixdataarray::getSource);
@@ -271,7 +276,9 @@ void mexFunction(int            nlhs,
         methods->add("Tag::retrieveData", nixtag::retrieveData);
         methods->add("Tag::featureRetrieveData", nixtag::retrieveFeatureData);
         methods->add("Tag::addReference", nixtag::addReference);
+        methods->add("Tag::addReferences", nixtag::addReferences);
         methods->add("Tag::addSource", nixtag::addSource);
+        methods->add("Tag::addSources", nixtag::addSources);
         methods->add("Tag::createFeature", nixtag::createFeature);
 
         classdef<nix::MultiTag>("MultiTag", methods)
@@ -307,7 +314,9 @@ void mexFunction(int            nlhs,
         methods->add("MultiTag::retrieveData", nixmultitag::retrieveData);
         methods->add("MultiTag::featureRetrieveData", nixmultitag::retrieveFeatureData);
         methods->add("MultiTag::addReference", nixmultitag::addReference);
+        methods->add("MultiTag::addReferences", nixmultitag::addReferences);
         methods->add("MultiTag::addSource", nixmultitag::addSource);
+        methods->add("MultiTag::addSources", nixmultitag::addSources);
         methods->add("MultiTag::createFeature", nixmultitag::createFeature);
         methods->add("MultiTag::addPositions", nixmultitag::addPositions);
 
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -40,6 +40,12 @@ namespace nixdataarray {
         currObj.addSource(input.str(2));
     }
 
+    void addSources(const extractor &input, infusor &output) {
+        nix::DataArray currObj = input.entity<nix::DataArray>(1);
+        std::vector<nix::Source> sv = input.entity_vec<nix::Source>(2);
+        currObj.sources(sv);
+    }
+
     void removeSource(const extractor &input, infusor &output) {
         nix::DataArray currObj = input.entity<nix::DataArray>(1);
         output.set(0, currObj.removeSource(input.str(2)));
diff --git a/src/nixdataarray.h b/src/nixdataarray.h
@@ -17,6 +17,8 @@ namespace nixdataarray {
 
     void addSource(const extractor &input, infusor &output);
 
+    void addSources(const extractor &input, infusor &output);
+
     void removeSource(const extractor &input, infusor &output);
 
     void hasSource(const extractor &input, infusor &output);
diff --git a/src/nixgroup.cc b/src/nixgroup.cc
@@ -34,19 +34,43 @@ namespace nixgroup {
         currObj.addDataArray(input.str(2));
     }
 
+    void addDataArrays(const extractor &input, infusor &output) {
+        nix::Group currObj = input.entity<nix::Group>(1);
+        std::vector<nix::DataArray> curr = input.entity_vec<nix::DataArray>(2);
+        currObj.dataArrays(curr);
+    }
+
     void addSource(const extractor &input, infusor & output) {
         nix::Group currObj = input.entity<nix::Group>(1);
         currObj.addSource(input.str(2));
     }
 
+    void addSources(const extractor &input, infusor &output) {
+        nix::Group currObj = input.entity<nix::Group>(1);
+        std::vector<nix::Source> curr = input.entity_vec<nix::Source>(2);
+        currObj.sources(curr);
+    }
+
     void addTag(const extractor &input, infusor &output) {
         nix::Group currObj = input.entity<nix::Group>(1);
         currObj.addTag(input.str(2));
     }
 
+    void addTags(const extractor &input, infusor &output) {
+        nix::Group currObj = input.entity<nix::Group>(1);
+        std::vector<nix::Tag> curr = input.entity_vec<nix::Tag>(2);
+        currObj.tags(curr);
+    }
+
     void addMultiTag(const extractor &input, infusor &output) {
         nix::Group currObj = input.entity<nix::Group>(1);
         currObj.addMultiTag(input.str(2));
     }
 
+    void addMultiTags(const extractor &input, infusor &output) {
+        nix::Group currObj = input.entity<nix::Group>(1);
+        std::vector<nix::MultiTag> curr = input.entity_vec<nix::MultiTag>(2);
+        currObj.multiTags(curr);
+    }
+
 } // namespace nixgroup
diff --git a/src/nixgroup.h b/src/nixgroup.h
@@ -17,12 +17,20 @@ namespace nixgroup {
 
     void addDataArray(const extractor &input, infusor &output);
 
+    void addDataArrays(const extractor &input, infusor &output);
+
     void addSource(const extractor &input, infusor & output);
 
+    void addSources(const extractor &input, infusor & output);
+
     void addTag(const extractor &input, infusor &output);
 
+    void addTags(const extractor &input, infusor &output);
+
     void addMultiTag(const extractor &input, infusor &output);
 
+    void addMultiTags(const extractor &input, infusor &output);
+
 } // namespace nixgroup
 
 #endif
diff --git a/src/nixmultitag.cc b/src/nixmultitag.cc
@@ -36,11 +36,23 @@ namespace nixmultitag {
         currObj.addReference(input.str(2));
     }
 
+    void addReferences(const extractor &input, infusor &output) {
+        nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
+        std::vector<nix::DataArray> curr = input.entity_vec<nix::DataArray>(2);
+        currObj.references(curr);
+    }
+
     void addSource(const extractor &input, infusor &output) {
         nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
         currObj.addSource(input.str(2));
     }
 
+    void addSources(const extractor &input, infusor &output) {
+        nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
+        std::vector<nix::Source> curr = input.entity_vec<nix::Source>(2);
+        currObj.sources(curr);
+    }
+
     void createFeature(const extractor &input, infusor &output) {
         nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
 
diff --git a/src/nixmultitag.h b/src/nixmultitag.h
@@ -17,8 +17,12 @@ namespace nixmultitag {
 
     void addReference(const extractor &input, infusor &output);
 
+    void addReferences(const extractor &input, infusor &output);
+
     void addSource(const extractor &input, infusor &output);
 
+    void addSources(const extractor &input, infusor &output);
+
     void createFeature(const extractor &input, infusor &output);
 
     void retrieveData(const extractor &input, infusor &output);
diff --git a/src/nixtag.cc b/src/nixtag.cc
@@ -38,11 +38,23 @@ namespace nixtag {
         currObj.addReference(input.str(2));
     }
 
+    void addReferences(const extractor &input, infusor &output) {
+        nix::Tag currObj = input.entity<nix::Tag>(1);
+        std::vector<nix::DataArray> curr = input.entity_vec<nix::DataArray>(2);
+        currObj.references(curr);
+    }
+
     void addSource(const extractor &input, infusor &output) {
         nix::Tag currObj = input.entity<nix::Tag>(1);
         currObj.addSource(input.str(2));
     }
 
+    void addSources(const extractor &input, infusor &output) {
+        nix::Tag currObj = input.entity<nix::Tag>(1);
+        std::vector<nix::Source> curr = input.entity_vec<nix::Source>(2);
+        currObj.sources(curr);
+    }
+
     void createFeature(const extractor &input, infusor &output) {
         nix::Tag currObj = input.entity<nix::Tag>(1);
 
diff --git a/src/nixtag.h b/src/nixtag.h
@@ -17,8 +17,12 @@ namespace nixtag {
 
     void addReference(const extractor &input, infusor &output);
 
+    void addReferences(const extractor &input, infusor &output);
+
     void addSource(const extractor &input, infusor &output);
 
+    void addSources(const extractor &input, infusor &output);
+
     void createFeature(const extractor &input, infusor &output);
 
     void retrieveData(const extractor &input, infusor &output);
diff --git a/src/utils/arguments.h b/src/utils/arguments.h
@@ -103,6 +103,40 @@ class extractor : public argument_helper < const mxArray > {
         return hdl(pos).get<T>();
     }
 
+    template<typename T>
+    std::vector<T> entity_vec(size_t pos) const {
+
+        const mxArray *arr = array[pos];
+        std::vector<T> entities;
+        const mxArray *cell_element_ptr;
+
+        if (mxGetClassID(arr) == mxCELL_CLASS) {
+            mwSize size = mxGetNumberOfElements(arr);
+
+            for (mwIndex index = 0; index < size; index++)  {
+                cell_element_ptr = mxGetCell(arr, index);
+                check_arg_type(cell_element_ptr, nix::to_data_type<uint64_t>::value);
+
+                if (mxGetNumberOfElements(cell_element_ptr) < 1) {
+                    throw std::runtime_error("array empty");
+                }
+
+                // fetch entity handle via address
+                const void *data = mxGetData(cell_element_ptr);
+                uint64_t res;
+                memcpy(&res, data, sizeof(uint64_t));
+                handle h = handle(res);
+
+                // add entity via handle to vector
+                entities.push_back(h.get<T>());
+            }
+        } else {
+            throw std::invalid_argument("Expected cell array");
+        }
+
+        return entities;
+    }
+
     handle hdl(size_t pos) const {
         handle h = handle(num<uint64_t>(pos));
         return h;
diff --git a/tests/TestDataArray.m b/tests/TestDataArray.m
@@ -21,6 +21,7 @@
     funcs{end+1} = @test_write_data_float;
     funcs{end+1} = @test_write_data_integer;
     funcs{end+1} = @test_add_source;
+    funcs{end+1} = @test_add_sources;
     funcs{end+1} = @test_open_source;
     funcs{end+1} = @test_remove_source;
     funcs{end+1} = @test_has_source;
@@ -295,6 +296,40 @@
     assert(size(getDataArray.sources, 1) == 2);
 end
 
+%% Test: Add sources by entity cell array
+function [] = test_add_sources ( varargin )
+    testFile = fullfile(pwd, 'tests', 'testRW.h5');
+    f = nix.File(testFile, nix.FileMode.Overwrite);
+    b = f.create_block('testBlock', 'nixBlock');
+    d = b.create_data_array('testDataArray', 'nixDataArray', nix.DataType.Double, [1 2]);
+    tmp = b.create_source('testSource1', 'nixSource');
+    tmp = b.create_source('testSource2', 'nixSource');
+    tmp = b.create_source('testSource3', 'nixSource');
+
+    assert(isempty(d.sources));
+
+    try
+        d.add_sources('hurra');
+    catch ME
+        assert(strcmp(ME.message, 'Expected cell array'));
+    end;
+    assert(isempty(d.sources));
+
+    try
+        d.add_sources({12, 13});
+    catch ME
+        assert(~isempty(strfind(ME.message, 'not a nix.Source')));
+    end;
+    assert(isempty(d.sources));
+
+    d.add_sources(b.sources());
+    assert(size(d.sources, 1) == 3);
+
+    clear d tmp b f;
+    f = nix.File(testFile, nix.FileMode.ReadOnly);
+    assert(size(f.blocks{1}.dataArrays{1}.sources, 1) == 3);
+end
+
 %% Test: Open source by ID or name
 function [] = test_open_source( varargin )
     test_file = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
diff --git a/tests/TestGroup.m b/tests/TestGroup.m
diff --git a/tests/TestMultiTag.m b/tests/TestMultiTag.m
diff --git a/tests/TestTag.m b/tests/TestTag.m
