[c++/m] Add File findSections function

Author: mpsonntag

+nix/File.m

@@ -112,6 +112,30 @@
             filtered = nix.Utils.filter(obj, filter, val, ...
                 'File::sectionsFiltered', @nix.Section);
         end
+        
+        % maxdepth is an index
+        function sec = find_sections(obj, max_depth)
+            sec = obj.find_filtered_sections(max_depth, nix.Filter.accept_all, '');
+        end
+        
+        % maxdepth is an index
+        function sec = find_filtered_sections(obj, max_depth, filter, val)
+            if (~isnumeric(max_depth))
+                error('Provide a valid search depth');
+            end
+
+            valid = nix.Utils.valid_filter(filter, val);
+            if(~isempty(valid))
+                error(valid);
+            end
+
+            ret = nix_mx('File::findSections', obj.nix_handle, ...
+                                            max_depth, uint8(filter), val);
+            sec = cell(length(ret), 1);
+            for i = 1:length(ret)
+                sec{i} = nix.Section(ret{i});
+            end;
+        end
     end
 
 end

nix_mx.cc

@@ -123,6 +123,7 @@ void mexFunction(int            nlhs,
         methods->add("File::openSectionIdx", nixfile::openSectionIdx);
         methods->add("File::sectionsFiltered", nixfile::sectionsFiltered);
         methods->add("File::blocksFiltered", nixfile::blocksFiltered);
+        methods->add("File::findSections", nixfile::findSections);
 
         classdef<nix::Block>("Block", methods)
             .desc(&nixblock::describe)

src/nixfile.cc

@@ -133,4 +133,17 @@ namespace nixfile {
         output.set(0, res);
     }
 
+    void findSections(const extractor &input, infusor &output) {
+        nix::File currObj = input.entity<nix::File>(1);
+        size_t max_depth = (size_t)input.num<double>(2);
+        uint8_t filter_id = input.num<uint8_t>(3);
+
+        std::vector<nix::Section> res = filterNameTypeEntity<nix::Section>(input, filter_id, 4, max_depth, 
+            [currObj](const nix::util::Filter<nix::Section>::type &filter, size_t &md) {
+                return currObj.findSections(filter, md);
+        });
+
+        output.set(0, res);
+    }
+
 } // namespace nixfile

src/nixfile.h

@@ -29,6 +29,8 @@ namespace nixfile {
 
     void blocksFiltered(const extractor &input, infusor &output);
 
+    void findSections(const extractor &input, infusor &output);
+
 } // namespace nixfile
 
 #endif

tests/TestFile.m

@@ -33,6 +33,8 @@
     funcs{end+1} = @test_has_section;
     funcs{end+1} = @test_filter_section;
     funcs{end+1} = @test_filter_block;
+    funcs{end+1} = @test_find_section;
+    funcs{end+1} = @test_find_section_filtered;
 end
 
 %% Test: Open HDF5 file in ReadOnly mode
@@ -411,3 +413,111 @@
     end
 
 end
+
+%% Test: Find sections w/o filter
+function [] = test_find_section
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    sl1 = f.create_section('sectionLvl1', 'nixSection');
+
+    sl21 = sl1.create_section('sectionLvl2_1', 'nixSection');
+    sl22 = sl1.create_section('sectionLvl2_2', 'nixSection');
+
+    sl31 = sl21.create_section('sectionLvl3_1', 'nixSection');
+    sl32 = sl21.create_section('sectionLvl3_2', 'nixSection');
+    sl33 = sl21.create_section('sectionLvl3_3', 'nixSection');
+
+    sl41 = sl31.create_section('sectionLvl4_1', 'nixSection');
+    sl42 = sl31.create_section('sectionLvl4_2', 'nixSection');
+    sl43 = sl31.create_section('sectionLvl4_3', 'nixSection');
+    sl44 = sl31.create_section('sectionLvl4_4', 'nixSection');
+
+    % Check invalid entry
+    err = 'Provide a valid search depth';
+    try
+        f.find_sections('hurra');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+
+    % find all
+    filtered = f.find_sections(4);
+    assert(size(filtered, 1) == 10);
+
+    % find until level 4
+    filtered = f.find_sections(3);
+    assert(size(filtered, 1) == 10);
+
+    % find until level 3
+    filtered = f.find_sections(2);
+    assert(size(filtered, 1) == 6);
+
+    % find until level 2
+    filtered = f.find_sections(1);
+    assert(size(filtered, 1) == 3);
+
+    % find until level 1
+    filtered = f.find_sections(0);
+    assert(size(filtered, 1) == 1);
+end
+
+%% Test: Find sections with filter
+function [] = test_find_section_filtered
+    findSection = 'nixFindSection';
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    sl1 = f.create_section('sectionLvl1', 'nixSection');
+
+    sl21 = sl1.create_section('sectionLvl2_1', 'nixSection');
+    sl22 = sl1.create_section('sectionLvl2_2', findSection);
+
+    sl31 = sl21.create_section('sectionLvl3_1', 'nixSection');
+    sl32 = sl21.create_section('sectionLvl3_2', 'nixSection');
+    sl33 = sl21.create_section('sectionLvl3_3', findSection);
+
+    sl41 = sl31.create_section('sectionLvl4_1', 'nixSection');
+    sl42 = sl31.create_section('sectionLvl4_2', 'nixSection');
+    sl43 = sl31.create_section('sectionLvl4_3', findSection);
+    sl44 = sl31.create_section('sectionLvl4_4', 'nixSection');
+
+    % test find by id
+    filtered = f.find_filtered_sections(0, nix.Filter.id, sl41.id);
+    assert(isempty(filtered));
+    filtered = f.find_filtered_sections(3, nix.Filter.id, sl41.id);
+    assert(size(filtered, 1) == 1);
+    assert(strcmp(filtered{1}.id, sl41.id));
+
+    % test find by ids
+    filterids = {sl1.id, sl41.id};
+    filtered = f.find_filtered_sections(0, nix.Filter.ids, filterids);
+    assert(size(filtered, 1) == 1);
+    filtered = f.find_filtered_sections(3, nix.Filter.ids, filterids);
+    assert(size(filtered, 1) == 2);
+
+    % test find by name
+    filtered = f.find_filtered_sections(0, nix.Filter.name, sl41.name);
+    assert(isempty(filtered));
+    filtered = f.find_filtered_sections(3, nix.Filter.name, sl41.name);
+    assert(size(filtered, 1) == 1);
+    assert(strcmp(filtered{1}.name, sl41.name));
+
+    % test find by type
+    filtered = f.find_filtered_sections(0, nix.Filter.type, findSection);
+    assert(isempty(filtered));
+    filtered = f.find_filtered_sections(3, nix.Filter.type, findSection);
+    assert(size(filtered, 1) == 3);
+    assert(strcmp(filtered{1}.type, findSection));
+
+    % test fail on nix.Filter.metadata
+    err = 'unknown or unsupported filter';
+    try
+        f.find_filtered_sections(1, nix.Filter.metadata, 'metadata');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+
+    % test fail on nix.Filter.source
+    try
+        f.find_filtered_sections(1, nix.Filter.source, 'source');
+    catch ME
+        assert(strcmp(ME.message, err));
+    end
+end