Fix read for scalar compound dataset (#761)

* Update parseDataset.m

* Update writeCompound.m

Support creating scalar/singleton dataspace for datasets with scalar size

* Add flag to io.parseCompound for when dataset is scalar/singleton

* Add test case

* Fix failing tests

Author: ehennestad

+io/parseCompound.m

@@ -1,6 +1,7 @@
-function data = parseCompound(datasetId, data)
+function data = parseCompound(datasetId, data, isScalar)
     %did is the dataset_id for the containing dataset
     %data should be a scalar struct with fields as columns
+    if nargin < 3; isScalar = false; end
     if isempty(data)
         return;
     end
@@ -10,6 +11,7 @@
     isReferenceType = false(1, numFields);
     isCharacterType = false(1, numFields);
     isLogicalType = false(1,numFields);
+    isScalarCellStr = false(1,numFields);
     for iField = 1:numFields
         fieldTypeId = H5T.get_member_type(typeId, iField-1);
         subTypeId{iField} = fieldTypeId;
@@ -20,6 +22,7 @@
                 %if not variable len (which would make it a cell array)
                 %then mark for transpose
                 isCharacterType(iField) = ~H5T.is_variable_str(fieldTypeId);
+                isScalarCellStr(iField) = isScalar && ~isCharacterType(iField);
             case H5ML.get_constant_value('H5T_ENUM')
                 isLogicalType(iField) = io.isBool(fieldTypeId);
                 % Note: There is currently no postprocessing applied for
@@ -62,4 +65,11 @@
         name = logicalFieldName{iFieldName};
         data.(name) = io.internal.h5.postprocess.toLogical(data.(name));
     end
-end
+
+    % unpack scalar cellstr
+    scalarCellstrFieldName = fieldName(isScalarCellStr);
+    for iFieldName = 1:length(scalarCellstrFieldName)
+        name = scalarCellstrFieldName{iFieldName};
+        data.(name) = data.(name){1};
+    end
+end

+io/parseDataset.m

@@ -51,6 +51,9 @@
                         name, length(datatype.Type.Member));
                     data = io.internal.h5.postprocess.toEnumCellStr(data, datatype.Type);
                 end
+            case 'H5T_COMPOUND'
+                isScalar = true;
+                data = io.parseCompound(did, data, isScalar);
         end
     else
         sid = H5D.get_space(did);

+io/writeCompound.m

@@ -27,6 +27,10 @@ function writeCompound(fid, fullpath, data, varargin)
 %   Example:
 %     io.writeCompound(fid, '/group/dataset', data);
 
+
+    forceArray = any(strcmp('forceArray', varargin));
+    forceMatrix = any(strcmp('forceMatrix', varargin));
+
     %convert to a struct
     if istable(data)
         data = table2struct(data);
@@ -129,7 +133,11 @@ function writeCompound(fid, fullpath, data, varargin)
     end
 
     try
-        sid = H5S.create_simple(1, numrows, []);
+        if numrows == 1 && ~(forceArray || forceMatrix)
+            sid = H5S.create('H5S_SCALAR');
+        else
+            sid = H5S.create_simple(1, numrows, []);
+        end
         did = H5D.create(fid, fullpath, tid, sid, 'H5P_DEFAULT');
     catch ME
         if contains(ME.message, 'name already exists')

+tests/+unit/+io/ScalarCompoundTest.m

@@ -0,0 +1,57 @@
+classdef ScalarCompoundTest < tests.abstract.NwbTestCase
+% ScalarCompoundTest - Test that a scalar compound dataset is imported correctly
+    
+    methods (TestMethodSetup)
+        function setupMethod(testCase)
+            % Use a fixture to create a temporary working directory
+            testCase.applyFixture(matlab.unittest.fixtures.WorkingFolderFixture);
+        end
+    end
+
+    methods (Test)
+        function testScalarCompoundIO(testCase)
+            
+            % Generate the compound test schema using fixture
+            testCase.applyTestSchemaFixture('rrs');
+            testCase.applyTestSchemaFixture('cs');
+            
+            % Set up file with scalar compound dataset
+            nwb = tests.factory.NWBFile();
+
+            ts = tests.factory.TimeSeriesWithTimestamps();
+            nwb.acquisition.set('timeseries', ts);
+
+            % Create a structure matching the compound type definition.
+            data = struct(...
+                'integer', int32(0), ...
+                'float', 0, ...
+                'text', 'test', ...
+                'boolean', false, ...
+                'reference', types.untyped.ObjectView(ts));
+
+            % Create data type and add to nwb object
+            scalarCompound = types.cs.ScalarCompoundMixedData('data', data);
+            nwb.analysis.set('ScalarCompound', scalarCompound);
+            
+            % Export
+            fileName = testCase.getRandomFilename();
+            nwbExport(nwb, fileName);
+
+            % Read
+            nwbIn = nwbRead(fileName, 'ignorecache');
+            scalarCompoundIn = nwbIn.analysis.get('ScalarCompound');
+            
+            % Verify that dataset was stored as scalar/singleton dataset
+            info = h5info(fileName, '/analysis/ScalarCompound/data');
+            testCase.verifyEqual(info.Dataspace.Type, 'scalar', ...
+                'Expected compound dataset to be saved as scalar/singleton dataset (H5S_SCALAR)')
+
+            % Verify that subtypes were properly postprocessed on read
+            testCase.verifyClass(scalarCompoundIn.data.float, 'double')
+            testCase.verifyClass(scalarCompoundIn.data.text, 'char')
+            testCase.verifyClass(scalarCompoundIn.data.boolean, 'logical')
+            testCase.verifyClass(scalarCompoundIn.data.reference, 'types.untyped.ObjectView')
+            testCase.verifyEqual(scalarCompoundIn.data.text, 'test')
+        end
+    end
+end

+tests/+unit/+io/WriteTest.m

@@ -144,7 +144,7 @@ function testWriteCompoundOverWrite(testCase)
 
             % Initial data to write (e.g., 10x10)
             initialData = struct('a', 1, 'b', true, 'c', 'test');
-            io.writeCompound(fid, fullPath, initialData);  % First write to create the dataset
+            io.writeCompound(fid, fullPath, initialData, 'forceArray');  % First write to create the dataset
 
             % Attempt to write data of a different size (e.g., 5x5)
             newData = cat(1, initialData, struct('a', 2, 'b', false, 'c', 'new test'));

+tests/test-schema/compoundSchema/cs.compoundtypes.yaml

@@ -24,4 +24,30 @@ groups:
         target_type: RefContainer
         reftype: region
     shape:
-    - null
+    - null
+
+- neurodata_type_def: ScalarCompoundMixedData
+  neurodata_type_inc: NWBContainer
+  doc: Data type with scalar compound data type
+  datasets:
+  - name: data
+    shape: 
+    - 1
+    dtype:
+    - name: integer
+      dtype: int
+      doc: An integer value.
+    - name: float
+      dtype: float
+      doc: A float value.
+    - name: text
+      dtype: text
+      doc: A text value.
+    - name: boolean
+      dtype: bool
+      doc: A bolean value.
+    - name: reference
+      doc: Reference to a NWBDataInterface
+      dtype:
+        target_type: NWBDataInterface
+        reftype: object

+types/+untyped/MetaClass.m

@@ -25,7 +25,7 @@
                     refs = obj.data.export(fid, fullpath, refs);
                 elseif istable(obj.data) || isstruct(obj.data) ||...
                         isa(obj.data, 'containers.Map')
-                    io.writeCompound(fid, fullpath, obj.data);
+                    io.writeCompound(fid, fullpath, obj.data, 'forceArray');
                 else
                     io.writeDataset(fid, fullpath, obj.data, 'forceArray');
                 end