addGroupEntity: add missing group functions

mpsonntag · mpsonntag · commit c73d158e4a55 · 2015-12-09T20:03:18.000+01:00
diff --git a/+nix/Block.m b/+nix/Block.m
@@ -23,28 +23,17 @@
         % Group methods
         % -----------------
         
-        % TODO -- seems to work remove me later
         function g = create_group(obj, name, nixtype)
             handle = nix_mx('Block::createGroup', obj.nix_handle, ...
                 name, nixtype);
             g = nix.Group(handle);
             obj.groupsCache.lastUpdate = 0;
         end;
         
-        % TODO - check if this actually works...
-        % TODO - find better solution to deal with non-entity entries.
-        function hasGroup = has_group(obj, group)
-            % TODO not available from the c++ side at the moment
-            %{
-            if(strcmp(class(group), 'nix.Group'))
-                hasGroup = nix_mx('Block::hasGroup', group);
-            else
-                error('Please provide a proper group.');
-            end;
-            %}
+        function hasGroup = has_group(obj, id_or_name)
+            hasGroup = nix_mx('Block::hasGroup', obj.nix_handle, id_or_name);
         end;
         
-        % TODO -- seems to work remove me later
         function delCheck = delete_group(obj, del)
             [delCheck, obj.groupsCache] = nix.Utils.delete_entity(obj, ...
                 del, 'nix.Group', 'Block::deleteGroup');
diff --git a/nix_mx.cc b/nix_mx.cc
@@ -116,8 +116,7 @@ void mexFunction(int            nlhs,
             .reg("groups", &nix::Block::groups)
             .reg("hasTag", GETBYSTR(bool, nix::Block, hasTag))
             .reg("hasMultiTag", GETBYSTR(bool, nix::Block, hasMultiTag))
-            // method is only available as get by entity, not as get by id or name on the c++ side
-            //.reg("hasGroup", GETBYSTR(bool, nix::Block, hasGroup))
+            .reg("hasGroup", GETBYSTR(bool, nix::Block, hasGroup))
             .reg("openDataArray", GETBYSTR(nix::DataArray, nix::Block, getDataArray))
             .reg("openSource", GETBYSTR(nix::Source, nix::Block, getSource))
             .reg("openTag", GETBYSTR(nix::Tag, nix::Block, getTag))
@@ -139,29 +138,17 @@ void mexFunction(int            nlhs,
 
         classdef<nix::Group>("Group", methods)
             .desc(&nixgroup::describe)
-            // does not work
-            //.reg("dataArrays", &nix::Group::dataArrays)
-            // does not work
-            //.reg("tags", &nix::Group::tags)
-            // does not work
-            //.reg("multiTags", &nix::Group::multiTags)
-            // compiles, should work
+            .reg("dataArrays", FILTER(std::vector<nix::DataArray>, nix::Group, , dataArrays))
+            .reg("tags", FILTER(std::vector<nix::Tag>, nix::Group, , tags))
+            .reg("multiTags", FILTER(std::vector<nix::MultiTag>, nix::Group, , multiTags))
             .reg("hasDataArray", GETBYSTR(bool, nix::Group, hasDataArray))
-            // compiles, should work
             .reg("hasTag", GETBYSTR(bool, nix::Group, hasTag))
-            // compiles, should work
             .reg("hasMultiTag", GETBYSTR(bool, nix::Group, hasMultiTag))
-            // compiles, should work
             .reg("getDataArray", GETBYSTR(nix::DataArray, nix::Group, getDataArray))
-            // compiles, should work
             .reg("getTag", GETBYSTR(nix::Tag, nix::Group, getTag))
-            // compiles, should work
             .reg("getMultiTag", GETBYSTR(nix::MultiTag, nix::Group, getMultiTag))
-            // compiles, should work
             .reg("removeDataArray", REMOVER(nix::DataArray, nix::Group, removeDataArray))
-            // compiles, should work, deleteTag in Block
             .reg("removeTag", REMOVER(nix::Tag, nix::Group, removeTag))
-            // should work, deleteMultiTag in Block
             .reg("removeMultiTag", REMOVER(nix::MultiTag, nix::Group, removeMultiTag))
             .reg("set_type", SETTER(const std::string&, nix::Group, type))
             .reg("set_definition", SETTER(const std::string&, nix::Group, definition))
diff --git a/tests/TestBlock.m b/tests/TestBlock.m
@@ -420,17 +420,18 @@
     assert(isempty(f.blocks{1}.groups));
 end
 
-%% Test: Block has Group by entity
+%% Test: Block has Group by name or id
 function [] = test_has_group( varargin )
-%{
-    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5', nix.FileMode.Overwrite));
+    groupName = 'testGroup';
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
     b = f.createBlock('grouptest', 'nixBlock');
 
-    g = b.create_group('testGroup', 'nixGroup');
-    assert(b.has_group(b.groups{1}));
+    assert(~b.has_group('I do not exist'));
+    
+    g = b.create_group(groupName, 'nixGroup');
+    assert(b.has_group(b.groups{1}.id));
+    assert(b.has_group(groupName));
 
     b.delete_group(b.groups{1});
-    assert(~b.has_group(g));
-%}
-    disp('Test Block.has_group ... TODO (function not working at the moment)');
-end
+    assert(~b.has_group(g.id));
+end
diff --git a/tests/TestGroup.m b/tests/TestGroup.m
@@ -62,15 +62,14 @@
     da = b.create_data_array(daName, daType, 'double', [2 3]);
     g = b.create_group('testGroup', 'nixGroup');
 
-    disp('Test Group.add_data_array ... TODO dataArrays check is not working');
-    %assert(isempty(g.dataArrays));
+    assert(isempty(g.dataArrays));
     g.add_data_array(da);
-    %assert(size(g.dataArrays,1) == 1);
-    %assert(strcmp(b.groups{1}.dataArrays{1}.name, daName));
+    assert(size(g.dataArrays, 1) == 1);
+    assert(strcmp(b.groups{1}.dataArrays{1}.name, daName));
 
     clear g da b f;
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
-    %assert(strcmp(f.blocks{1}.groups{1}.dataArrays{1}.name, daName));
+    assert(strcmp(f.blocks{1}.groups{1}.dataArrays{1}.name, daName));
 end
 
 %% Test: Get nix.DataArray by id or name
@@ -184,17 +183,16 @@
     t2 = b.create_tag(tagName2, 'nixTag', [1.0 1.2 1.3 15.9]);
     tID = t2.id;
     g = b.create_group('testGroup', 'nixGroup');
-    disp('test_add_tag: TODO comment in check once method is implemented in c++');
-    %assert(isempty(g.tags));
+    assert(isempty(g.tags));
     g.add_tag(t1);
-    %assert(strcmp(g.tags{1}.name, tagName1));
+    assert(strcmp(g.tags{1}.name, tagName1));
     g.add_tag(tID);
-    %assert(strcmp(g.tags{2}.name, tagName2));
+    assert(strcmp(g.tags{2}.name, tagName2));
 
     clear t1 t2 g b f;
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
-    %assert(strcmp(f.blocks{1}.groups{1}.tags{1}.name, tagName1));
-    %assert(strcmp(f.blocks{1}.groups{1}.tags{2}.name, tagName2));
+    assert(strcmp(f.blocks{1}.groups{1}.tags{1}.name, tagName1));
+    assert(strcmp(f.blocks{1}.groups{1}.tags{2}.name, tagName2));
 end
 
 %% Test: has nix.Tag by id or name
@@ -253,17 +251,21 @@
 
     assert(~g.remove_tag('I do not exist'));
 
-    disp('TODO: comment asserts in when tags function works');
+    disp('Fix caching issue before commenting in inactive asserts.');
     assert(size(f.blocks{1}.tags, 1) == 3);
-    %assert(size(f.blocks{1}.groups{1}.tags, 1) == 3);
+    assert(size(g.tags, 1) == 3);
+    assert(size(f.blocks{1}.groups{1}.tags, 1) == 3);
     assert(g.remove_tag(t1.id));
     assert(size(f.blocks{1}.tags, 1) == 3);
+    assert(size(g.tags, 1) == 2);
     %assert(size(f.blocks{1}.groups{1}.tags, 1) == 2);
     assert(g.remove_tag(t2));
     assert(size(f.blocks{1}.tags, 1) == 3);
+    assert(size(g.tags, 1) == 1);
     %assert(size(f.blocks{1}.groups{1}.tags, 1) == 1);
     assert(~g.remove_tag(t2));
     assert(size(f.blocks{1}.tags, 1) == 3);
+    assert(size(g.tags, 1) == 1);
     %assert(size(f.blocks{1}.groups{1}.tags, 1) == 1);
 
     clear t1 t2 t3 g b f;
@@ -286,18 +288,17 @@
     tmp = b.create_multi_tag(tagName2, tagType, b.dataArrays{2});
     g = b.create_group('testGroup', 'nixGroup');
 
-    disp('test_add_multi_tag: comment in once c++ method works');
-    %assert(isempty(g.multiTags));
+    assert(isempty(g.multiTags));
     g.add_multi_tag(b.multiTags{1});
-    %assert(size(g.multiTags, 1) == 1);
+    assert(size(g.multiTags, 1) == 1);
 
     g.add_multi_tag(b.multiTags{2}.id);
-    %assert(size(g.multiTags, 1) == 2);
+    assert(size(g.multiTags, 1) == 2);
 
     clear tmp g b f;
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
-    %assert(strcmp(f.blocks{1}.groups{1}.tags{1}.name, tagName1));
-    %assert(strcmp(f.blocks{1}.groups{1}.tags{2}.name, tagName2));
+    assert(strcmp(f.blocks{1}.groups{1}.multiTags{1}.name, tagName1));
+    assert(strcmp(f.blocks{1}.groups{1}.multiTags{2}.name, tagName2));
 end
 
 %% Test: has nix.MultiTag by id or name
@@ -368,24 +369,27 @@
 
     assert(~g.remove_multi_tag('I do not exist'));
 
-    disp('TODO: comment asserts in when multitags function works');
+    disp('Fix caching issue before commenting in inactive asserts.');
     assert(size(f.blocks{1}.multiTags, 1) == 3);
-    %assert(size(f.blocks{1}.groups{1}.multiTags, 1) == 3);
+    assert(size(f.blocks{1}.groups{1}.multiTags, 1) == 3);
     assert(g.remove_multi_tag(t1.id));
     assert(size(f.blocks{1}.multiTags, 1) == 3);
+    assert(size(g.multiTags, 1) == 2);
     %assert(size(f.blocks{1}.groups{1}.multiTags, 1) == 2);
     assert(~g.has_multi_tag(tagName1));
 
     assert(g.remove_multi_tag(t2));
     assert(size(f.blocks{1}.multiTags, 1) == 3);
+    assert(size(g.multiTags, 1) == 1);
     %assert(size(f.blocks{1}.groups{1}.multiTags, 1) == 1);
     assert(~g.has_multi_tag(tagName2));
 
     assert(~g.remove_multi_tag(t2));
     assert(size(f.blocks{1}.multiTags, 1) == 3);
+    assert(size(g.multiTags, 1) == 1);
     %assert(size(f.blocks{1}.groups{1}.multiTags, 1) == 1);
 
     clear t1 t2 t3 da g b f;
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
     assert(f.blocks{1}.groups{1}.has_multi_tag(tagName3));
-end
+end
