[c++/m] Add Section propertiesFilter

Closes #122

Author: mpsonntag

+nix/Section.m

@@ -166,6 +166,11 @@
             c = nix_mx('Section::propertyCount', obj.nix_handle);
         end
 
+        function filtered = filter_properties(obj, filter, val)
+            filtered = nix.Utils.filter(obj, filter, val, ...
+                'Section::propertiesFiltered', @nix.Property);
+        end
+
         % ----------------
         % Referring entity methods
         % ----------------

nix_mx.cc

@@ -415,6 +415,7 @@ void mexFunction(int            nlhs,
         methods->add("Section::openPropertyIdx", nixsection::openPropertyIdx);
         methods->add("Section::compare", nixsection::compare);
         methods->add("Section::sectionsFiltered", nixsection::sectionsFiltered);
+        methods->add("Section::propertiesFiltered", nixsection::propertiesFiltered);
 
         classdef<nix::Feature>("Feature", methods)
             .desc(&nixfeature::describe)

src/filters.h

@@ -95,4 +95,28 @@ std::vector<T> filterFeature(const extractor &input, FN ff) {
     return res;
 }
 
+template<typename T, typename FN>
+std::vector<T> filterProperty(const extractor &input, FN ff) {
+    std::vector<T> res;
+
+    switch (input.num<uint8_t>(2)) {
+    case switchFilter::AcceptAll:
+        res = ff(nix::util::AcceptAll<T>());
+        break;
+    case switchFilter::Id:
+        res = ff(nix::util::IdFilter<T>(input.str(3)));
+        break;
+    case switchFilter::Ids:
+        // this will crash matlab, if its not a vector of strings...
+        res = ff(nix::util::IdsFilter<T>(input.vec<std::string>(3)));
+        break;
+    case switchFilter::Name:
+        res = ff(nix::util::NameFilter<T>(input.str(3)));
+        break;
+    default: throw std::invalid_argument("unknown or unsupported filter");
+    }
+
+    return res;
+}
+
 #endif

src/nixsection.cc

@@ -133,4 +133,13 @@ namespace nixsection {
         output.set(0, res);
     }
 
+    void propertiesFiltered(const extractor &input, infusor &output) {
+        nix::Section currObj = input.entity<nix::Section>(1);
+        std::vector<nix::Property> res = filterProperty<nix::Property>(input,
+                                            [currObj](const nix::util::Filter<nix::Property>::type &filter) {
+            return currObj.properties(filter);
+        });
+        output.set(0, res);
+    }
+
 } // namespace nixsection

src/nixsection.h

@@ -37,6 +37,8 @@ namespace nixsection {
 
     void sectionsFiltered(const extractor &input, infusor &output);
 
+    void propertiesFiltered(const extractor &input, infusor &output);
+
 } // namespace nixsection
 
 #endif

tests/TestSection.m

@@ -40,6 +40,7 @@
     funcs{end+1} = @test_referring_blocks;
     funcs{end+1} = @test_compare;
     funcs{end+1} = @test_filter_section;
+    funcs{end+1} = @test_filter_property;
 end
 
 %% Test: Create Section
@@ -677,3 +678,59 @@
         assert(strcmp(ME.message, err));
     end
 end
+
+%% Test: filter properties
+function [] = test_filter_property( varargin )
+    filterName = 'filterMe';
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    ms = f.create_section('testSection', 'nixSection');
+    p = ms.create_property(filterName, nix.DataType.Double);
+    filterID = p.id;
+	s = ms.create_property('testProperty', nix.DataType.Bool);
+    filterIDs = {filterID, s.id};
+    
+    % test empty id filter
+    assert(isempty(f.sections{1}.filter_properties(nix.Filter.id, 'IdoNotExist')));
+
+    % test nix.Filter.accept_all
+    filtered = f.sections{1}.filter_properties(nix.Filter.accept_all, '');
+    assert(size(filtered, 1) == 2);
+    
+    % test nix.Filter.id
+    filtered = f.sections{1}.filter_properties(nix.Filter.id, filterID);
+    assert(size(filtered, 1) == 1);
+    assert(strcmp(filtered{1}.id, filterID));
+
+    % test nix.Filter.ids
+    filtered = f.sections{1}.filter_properties(nix.Filter.ids, filterIDs);
+    assert(size(filtered, 1) == 2);
+    assert(strcmp(filtered{1}.id, filterIDs{1}) || strcmp(filtered{1}.id, filterIDs{2}));
+
+    % test nix.Filter.name
+    filtered  = f.sections{1}.filter_properties(nix.Filter.name, filterName);
+    assert(size(filtered, 1) == 1);
+    assert(strcmp(filtered{1}.name, filterName));
+
+    % test fail on nix.Filter.type
+    err = 'unknown or unsupported filter';
+    try
+        f.sections{1}.filter_properties(nix.Filter.type, 'someType');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+
+    % test fail on nix.Filter.metadata
+    err = 'unknown or unsupported filter';
+    try
+        f.sections{1}.filter_properties(nix.Filter.metadata, 'someMetadata');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+
+    % test fail on nix.Filter.source
+    try
+        f.sections{1}.filter_properties(nix.Filter.source, 'someSource');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+end