Merge pull request #146 from mpsonntag/compare

jgrewe · web-flow · commit ec039d3add93 · 2017-07-17T17:39:36.000+02:00
Add 'compare(NamedEntity)' function
diff --git a/+nix/NamedEntity.m b/+nix/NamedEntity.m
@@ -20,6 +20,16 @@
             nix.Dynamic.add_dyn_attr(obj, 'type', 'rw');
             nix.Dynamic.add_dyn_attr(obj, 'definition', 'rw');
         end
+
+        function res = compare(obj, entity)
+        % Compares first name and second id, return > 0 if the entity 
+        % is larger than the other, 0 if both are equal, and < 0 otherwise.
+            if(~strcmp(class(obj), class(entity)))
+                error('Only entities of the same class can be compared.');
+            end;
+            res = nix_mx(strcat(obj.alias, '::compare'), ...
+                obj.nix_handle, entity.nix_handle);
+        end;
     end
     
 end
diff --git a/nix_mx.cc b/nix_mx.cc
@@ -165,6 +165,7 @@ void mexFunction(int            nlhs,
         methods->add("Block::openTagIdx", nixblock::openTagIdx);
         methods->add("Block::openMultiTagIdx", nixblock::openMultiTagIdx);
         methods->add("Block::openSourceIdx", nixblock::openSourceIdx);
+        methods->add("Block::compare", nixblock::compare);
 
         classdef<nix::Group>("Group", methods)
             .desc(&nixgroup::describe)
@@ -206,6 +207,7 @@ void mexFunction(int            nlhs,
         methods->add("Group::openTagIdx", nixgroup::openTagIdx);
         methods->add("Group::openMultiTagIdx", nixgroup::openMultiTagIdx);
         methods->add("Group::openSourceIdx", nixgroup::openSourceIdx);
+        methods->add("Group::compare", nixgroup::compare);
 
         classdef<nix::DataArray>("DataArray", methods)
             .desc(&nixdataarray::describe)
@@ -248,6 +250,7 @@ void mexFunction(int            nlhs,
         methods->add("DataArray::setDataExtent", nixdataarray::setDataExtent);
         methods->add("DataArray::openSourceIdx", nixdataarray::openSourceIdx);
         methods->add("DataArray::openDimensionIdx", nixdataarray::openDimensionIdx);
+        methods->add("DataArray::compare", nixdataarray::compare);
 
         classdef<nix::Source>("Source", methods)
             .desc(&nixsource::describe)
@@ -268,6 +271,7 @@ void mexFunction(int            nlhs,
             .reg("referringTags", GETTER(std::vector<nix::Tag>, nix::Source, referringTags))
             .reg("referringMultiTags", GETTER(std::vector<nix::MultiTag>, nix::Source, referringMultiTags));
         methods->add("Source::openSourceIdx", nixsource::openSourceIdx);
+        methods->add("Source::compare", nixsource::compare);
 
         classdef<nix::Tag>("Tag", methods)
             .desc(&nixtag::describe)
@@ -307,6 +311,7 @@ void mexFunction(int            nlhs,
         methods->add("Tag::openReferenceIdx", nixtag::openReferenceIdx);
         methods->add("Tag::openFeatureIdx", nixtag::openFeatureIdx);
         methods->add("Tag::openSourceIdx", nixtag::openSourceIdx);
+        methods->add("Tag::compare", nixtag::compare);
 
         classdef<nix::MultiTag>("MultiTag", methods)
             .desc(&nixmultitag::describe)
@@ -349,6 +354,7 @@ void mexFunction(int            nlhs,
         methods->add("MultiTag::openReferenceIdx", nixmultitag::openReferenceIdx);
         methods->add("MultiTag::openFeatureIdx", nixmultitag::openFeatureIdx);
         methods->add("MultiTag::openSourceIdx", nixmultitag::openSourceIdx);
+        methods->add("MultiTag::compare", nixmultitag::compare);
 
         classdef<nix::Section>("Section", methods)
             .desc(&nixsection::describe)
@@ -388,6 +394,7 @@ void mexFunction(int            nlhs,
         methods->add("Section::referringBlockDataArrays", nixsection::referringBlockDataArrays);
         methods->add("Section::openSectionIdx", nixsection::openSectionIdx);
         methods->add("Section::openPropertyIdx", nixsection::openPropertyIdx);
+        methods->add("Section::compare", nixsection::compare);
 
         classdef<nix::Feature>("Feature", methods)
             .desc(&nixfeature::describe)
diff --git a/src/nixblock.cc b/src/nixblock.cc
@@ -90,4 +90,10 @@ namespace nixblock {
         output.set(0, currObj.getSource(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::Block currObj = input.entity<nix::Block>(1);
+        nix::Block other = input.entity<nix::Block>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixblock
diff --git a/src/nixblock.h b/src/nixblock.h
@@ -31,6 +31,8 @@ namespace nixblock {
 
     void openSourceIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixblock
 
 #endif
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -170,4 +170,10 @@ namespace nixdataarray {
         output.set(0, sb.array());
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::DataArray currObj = input.entity<nix::DataArray>(1);
+        nix::DataArray other = input.entity<nix::DataArray>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixdataarray
diff --git a/src/nixdataarray.h b/src/nixdataarray.h
@@ -45,6 +45,8 @@ namespace nixdataarray {
 
     void openDimensionIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixdataarray
 
 #endif
diff --git a/src/nixgroup.cc b/src/nixgroup.cc
@@ -97,4 +97,10 @@ namespace nixgroup {
         output.set(0, currObj.getSource(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::Group currObj = input.entity<nix::Group>(1);
+        nix::Group other = input.entity<nix::Group>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixgroup
diff --git a/src/nixgroup.h b/src/nixgroup.h
@@ -39,6 +39,8 @@ namespace nixgroup {
 
     void openSourceIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixgroup
 
 #endif
diff --git a/src/nixmultitag.cc b/src/nixmultitag.cc
@@ -101,4 +101,10 @@ namespace nixmultitag {
         output.set(0, currObj.getSource(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
+        nix::MultiTag other = input.entity<nix::MultiTag>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixmultitag
diff --git a/src/nixmultitag.h b/src/nixmultitag.h
@@ -37,6 +37,8 @@ namespace nixmultitag {
 
     void openSourceIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixmultitag
 
 #endif
diff --git a/src/nixsection.cc b/src/nixsection.cc
@@ -117,4 +117,10 @@ namespace nixsection {
         output.set(0, currObj.getProperty(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::Section currObj = input.entity<nix::Section>(1);
+        nix::Section other = input.entity<nix::Section>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixsection
diff --git a/src/nixsection.h b/src/nixsection.h
@@ -32,6 +32,9 @@ namespace nixsection {
     void openSectionIdx(const extractor &input, infusor &output);
 
     void openPropertyIdx(const extractor &input, infusor &output);
+
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixsection
 
 #endif
diff --git a/src/nixsource.cc b/src/nixsource.cc
@@ -33,4 +33,10 @@ namespace nixsource {
         output.set(0, currObj.getSource(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::Source currObj = input.entity<nix::Source>(1);
+        nix::Source other = input.entity<nix::Source>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixsource
diff --git a/src/nixsource.h b/src/nixsource.h
@@ -17,6 +17,8 @@ namespace nixsource {
 
     void openSourceIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixsource
 
 #endif
diff --git a/src/nixtag.cc b/src/nixtag.cc
@@ -96,4 +96,10 @@ namespace nixtag {
         output.set(0, currObj.getSource(idx));
     }
 
+    void compare(const extractor &input, infusor &output) {
+        nix::Tag currObj = input.entity<nix::Tag>(1);
+        nix::Tag other = input.entity<nix::Tag>(2);
+        output.set(0, currObj.compare(other));
+    }
+
 } // namespace nixtag
diff --git a/src/nixtag.h b/src/nixtag.h
@@ -35,6 +35,8 @@ namespace nixtag {
 
     void openSourceIdx(const extractor &input, infusor &output);
 
+    void compare(const extractor &input, infusor &output);
+
 } // namespace nixtag
 
 #endif
diff --git a/tests/TestBlock.m b/tests/TestBlock.m
@@ -49,6 +49,7 @@
     funcs{end+1} = @test_tag_count;
     funcs{end+1} = @test_multi_tag_count;
     funcs{end+1} = @test_source_count;
+    funcs{end+1} = @test_compare;
 end
 
 function [] = test_attrs( varargin )
@@ -741,3 +742,14 @@
     f = nix.File(testFile, nix.FileMode.ReadOnly);
     assert(f.blocks{1}.source_count() == 2);
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare block entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+
+    assert(b1.compare(b2) < 0);
+    assert(b1.compare(b1) == 0);
+    assert(b2.compare(b1) > 0);
+end
diff --git a/tests/TestDataArray.m b/tests/TestDataArray.m
@@ -32,6 +32,7 @@
     funcs{end+1} = @test_dimension_count;
     funcs{end+1} = @test_datatype;
     funcs{end+1} = @test_set_data_extent;
+    funcs{end+1} = @test_compare;
 end
 
 function [] = test_attrs( varargin )
@@ -580,3 +581,18 @@
     da.set_data_extent(extent);
     assert(da.dataExtent(1) == extent(1) && size(da.read_all, 2) == extent(2));
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare DataArray entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+    d1 = b1.create_data_array('testDataArray1', 'nixDataArray', nix.DataType.Bool, [2 9]);
+    d2 = b1.create_data_array('testDataArray2', 'nixDataArray', nix.DataType.Bool, [2 9]);
+    d3 = b2.create_data_array('testDataArray1', 'nixDataArray', nix.DataType.Bool, [2 9]);
+
+    assert(d1.compare(d2) < 0);
+    assert(d1.compare(d1) == 0);
+    assert(d2.compare(d1) > 0);
+    assert(d1.compare(d3) ~= 0);
+end
diff --git a/tests/TestGroup.m b/tests/TestGroup.m
@@ -41,6 +41,7 @@
     funcs{end+1} = @test_open_tag_idx;
     funcs{end+1} = @test_open_multi_tag_idx;
     funcs{end+1} = @test_open_source_idx;
+    funcs{end+1} = @test_compare;
 end
 
 %% Test: Access nix.Group attributes
@@ -853,3 +854,18 @@
     assert(strcmp(f.blocks{1}.groups{1}.open_source_idx(1).name, s2.name));
     assert(strcmp(f.blocks{1}.groups{1}.open_source_idx(2).name, s3.name));
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare group entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+    g1 = b1.create_group('testGroup1', 'nixGroup');
+    g2 = b1.create_group('testGroup2', 'nixGroup');
+    g3 = b2.create_group('testGroup1', 'nixGroup');
+
+    assert(g1.compare(g2) < 0);
+    assert(g1.compare(g1) == 0);
+    assert(g2.compare(g1) > 0);
+    assert(g1.compare(g3) ~= 0);
+end
diff --git a/tests/TestMultiTag.m b/tests/TestMultiTag.m
@@ -44,6 +44,7 @@
     funcs{end+1} = @test_retrieve_feature_data;
     funcs{end+1} = @test_set_units;
     funcs{end+1} = @test_attrs;
+    funcs{end+1} = @test_compare;
 end
 
 %% Test: Add sources by entity and id
@@ -761,3 +762,20 @@
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
     assert(isequal(f.blocks{1}.multiTags{1}.type, testType));
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare MultiTag entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+    d = b1.create_data_array('testDataArray', 'nixDataArray', nix.DataType.Double, [2 2]);
+    t1 = b1.create_multi_tag('testMultiTag1', 'nixMultiTag', d);
+    t2 = b1.create_multi_tag('testMultiTag2', 'nixMultiTag', d);
+    d = b2.create_data_array('testDataArray', 'nixDataArray', nix.DataType.Double, [2 2]);
+    t3 = b2.create_multi_tag('testMultiTag1', 'nixMultiTag', d);
+
+    assert(t1.compare(t2) < 0);
+    assert(t1.compare(t1) == 0);
+    assert(t2.compare(t1) > 0);
+    assert(t1.compare(t3) ~= 0);
+end
diff --git a/tests/TestSection.m b/tests/TestSection.m
@@ -38,6 +38,7 @@
     funcs{end+1} = @test_referring_sources;
     funcs{end+1} = @test_referring_block_sources;
     funcs{end+1} = @test_referring_blocks;
+    funcs{end+1} = @test_compare;
 end
 
 %% Test: Create Section
@@ -608,3 +609,14 @@
     b2.set_metadata('')
     assert(size(s.referring_blocks, 1) == 1);
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare group entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    s1 = f.create_section('testSection1', 'nixSection');
+    s2 = f.create_section('testSection2', 'nixSection');
+
+    assert(s1.compare(s2) < 0);
+    assert(s1.compare(s1) == 0);
+    assert(s2.compare(s1) > 0);
+end
diff --git a/tests/TestSource.m b/tests/TestSource.m
@@ -25,6 +25,7 @@
     funcs{end+1} = @test_referring_data_arrays;
     funcs{end+1} = @test_referring_tags;
     funcs{end+1} = @test_referring_multi_tags;
+    funcs{end+1} = @test_compare;
 end
 
 %% Test: fetch sources
@@ -282,3 +283,18 @@
     t2.add_source(s);
     assert(size(s.referring_multi_tags, 1) == 2);
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare Source entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+    s1 = b1.create_source('testSource1', 'nixSource');
+    s2 = b1.create_source('testSource2', 'nixSource');
+    s3 = b2.create_source('testSource1', 'nixSource');
+
+    assert(s1.compare(s2) < 0);
+    assert(s1.compare(s1) == 0);
+    assert(s2.compare(s1) > 0);
+    assert(s1.compare(s3) ~= 0);
+end
diff --git a/tests/TestTag.m b/tests/TestTag.m
@@ -39,6 +39,7 @@
     funcs{end+1} = @test_attrs;
     funcs{end+1} = @test_has_feature;
     funcs{end+1} = @test_has_reference;
+    funcs{end+1} = @test_compare;
 end
 
 %% Test: Add sources by entity and id
@@ -636,3 +637,18 @@
     f = nix.File(fullfile(pwd, 'tests', fileName), nix.FileMode.ReadOnly);
     assert(f.blocks{1}.tags{1}.has_reference(daName));
 end
+
+function [] = test_compare( varargin )
+%% Test: Compare Tag entities
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b1 = f.create_block('testBlock1', 'nixBlock');
+    b2 = f.create_block('testBlock2', 'nixBlock');
+    t1 = b1.create_tag('testTag1', 'nixTag', [1 2 3]);
+    t2 = b1.create_tag('testTag2', 'nixTag', [1 2 3]);
+    t3 = b2.create_tag('testTag1', 'nixTag', [1 2 3]);
+
+    assert(t1.compare(t2) < 0);
+    assert(t1.compare(t1) == 0);
+    assert(t2.compare(t1) > 0);
+    assert(t1.compare(t3) ~= 0);
+end
