fixDataTypeErrors: refactor string/logical handling

mpsonntag · mpsonntag · commit f142c3c7ddf1 · 2015-12-17T12:54:30.000+01:00
diff --git a/+nix/Block.m b/+nix/Block.m
@@ -54,8 +54,13 @@
         end;
         
         function da = create_data_array(obj, name, nixtype, datatype, shape)
+            errorStruct.identifier = 'Block:unsupportedDataType';
             if(~isa(datatype, 'nix.DataType'))
-                error('Please provide a valid nix.DataType');
+                errorStruct.message = 'Please provide a valid nix.DataType';
+                error(errorStruct);
+            elseif(isequal(datatype, nix.DataType.String))
+                errorStruct.message = 'Writing Strings to DataArrays is not supported as of yet.';
+                error(errorStruct);
             else
                 handle = nix_mx('Block::createDataArray', obj.nix_handle, ...
                     name, nixtype, lower(datatype.char), shape);
@@ -65,17 +70,20 @@
         end
         
         function da = create_data_array_from_data(obj, name, nixtype, data)
-            shape = size(data);
+            errorStruct.identifier = 'Block:unsupportedDataType';
             if(ischar(data))
-                dtype = nix.DataType.String;
+                errorStruct.message = 'Writing Strings to DataArrays is not supported as of yet.';
+                error(errorStruct);
             elseif(islogical(data))
                 dtype = nix.DataType.Bool;
             elseif(isnumeric(data))
                 dtype = nix.DataType.Double;
             else
-                error('Could not determine DataType of data');
+                errorStruct.message = 'DataType of provided data is not supported.';
+                error(errorStruct);
             end;
-            
+
+            shape = size(data);            
             da = obj.create_data_array(name, nixtype, dtype, shape);
             da.write_all(data);
         end
@@ -168,4 +176,4 @@
                 del, 'nix.MultiTag', 'Block::deleteMultiTag', obj.multiTagsCache);
         end;
     end;
-end
+end
diff --git a/+nix/DataArray.m b/+nix/DataArray.m
@@ -89,17 +89,26 @@
         end;
         
         %-- TODO add (optional) offset
+        %-- If a DataArray has been created as boolean or numeric,
+        %-- provide that only values of the proper DataType can be written.
         function write_all(obj, data)
-            %-- Bugifx: if a data array has been created as
-            %-- boolean or char, provide check that only logical or char
-            %-- values can be written, otherwise the
-            %-- error message from nix is too cryptic.
+            errorStruct.identifier = 'DataArray:improperDataType';
             if(islogical(obj.read_all) && ~islogical(data))
-                error(strcat('Trying to write', 32, class(data), ...
-                	' to a logical DataArray. Provide data as logical.'));
-            elseif(ischar(obj.read_all) && ~ischar(data))
-                error(strcat('Trying to write', 32, class(data), ...
-                	' to a char DataArray. Provide data as char.'));
+                errorStruct.message = strcat('Trying to write', ...
+                    32, class(data), ' to a logical DataArray.');
+                error(errorStruct);
+            elseif(isnumeric(obj.read_all) && ~isnumeric(data))
+                errorStruct.message = strcat('Trying to write', ...
+                    32, class(data), ' to a ', 32, class(obj.read_all), ...
+                    ' DataArray.');
+                error(errorStruct);
+            elseif(ischar(data))
+                %-- Should actually not be reachable at the moment, 
+                %-- since writing Strings to DataArrays is not supported,
+                %-- but safety first.
+                errorStruct.identifier = 'DataArray:unsupportedDataType';
+                errorStruct.message = ('Writing char/string DataArrays is not supported as of yet.');
+                error(errorStruct);
             else
                 % data must agree with file & dimensions
                 % see mkarray.cc(42)
diff --git a/+nix/DataType.m b/+nix/DataType.m
@@ -5,6 +5,7 @@
         Bool;
         String;
         Double;
+        %-- remove
         Char;
         Float;
         Int8;
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -56,13 +56,9 @@ namespace nixdataarray {
         nix::NDSize offset(0);
         double *ptr = input.get_raw(2);
         
-        if (dtype == nix::DataType::String)
-        {
-            //da.setData(ptr);
-            throw std::domain_error("Writing strings is not supported as of yet.");
-        }
-        else
-        {
+        if (dtype == nix::DataType::String) {
+            throw std::domain_error("Writing Strings to DataArrays is not supported as of yet.");
+        } else {
             da.setData(dtype, ptr, count, offset);
         }
     }
diff --git a/src/utils/mkarray.cc b/src/utils/mkarray.cc
@@ -22,14 +22,9 @@ mxArray* make_mx_array_from_ds(const nix::DataSet &da) {
     }
 
     mxArray *data;
-    if (dtype.cid == mxCHAR_CLASS)
-    {
-        data = mxCreateCharArray(dims.size(), dims.data());
-//        double *ptr = mxGetPr(data);
-//        da.getData(ptr);
-    }
-    else
-    {
+    if (dtype.cid == mxCHAR_CLASS) {
+        throw std::domain_error("String DataArrays are not supported as of yet.");
+    } else {
         data = mxCreateNumericArray(dims.size(), dims.data(), dtype.cid, dtype.clx);
         double *ptr = mxGetPr(data);
         nix::NDSize offset(size.size(), 0);
diff --git a/tests/TestBlock.m b/tests/TestBlock.m
@@ -53,40 +53,79 @@
     assert(isempty(b.definition));
 end
 
-function [] = test_create_data_array( varargin )
 %% Test: Create Data Array
-    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+function [] = test_create_data_array( varargin )
+    fileName = fullfile(pwd, 'tests', 'testRW.h5');
+    f = nix.File(fileName, nix.FileMode.Overwrite);
     b = f.createBlock('arraytest', 'nixblock');
     
     assert(isempty(b.dataArrays));
     
-    d1 = b.create_data_array('foo', 'bar', nix.DataType.Double, [2 3]);
-
-    assert(strcmp(d1.name, 'foo'));
-    assert(strcmp(d1.type, 'bar'));
-    tmp = d1.read_all();
+    dtype = 'nix.DataArray';
+    doubleName = 'doubleDataArray';
+    da = b.create_data_array(doubleName, dtype, nix.DataType.Double, [2 3]);
+    assert(strcmp(da.name, doubleName));
+    assert(strcmp(da.type, dtype));
+    tmp = da.read_all();
     assert(all(tmp(:) == 0));
+
+    %-- TODO: add tests for all provided data types
+    try
+        stringName = 'stringDataArray';
+        b.create_data_array(stringName, dtype, nix.DataType.String, [1 5]);
+    catch ME
+        assert(strcmp(ME.identifier, 'Block:unsupportedDataType'));
+    end;
     
+    try
+        unsupportedName = 'I will crash and burn';
+        b.create_data_array(unsupportedName, dtype, 'Thou shalt not work!', [1 5]);
+    catch ME
+        assert(strcmp(ME.identifier, 'Block:unsupportedDataType'));
+    end;
+
     assert(~isempty(b.dataArrays));
 end
 
-function [] = test_create_data_array_from_data( varargin )
 %% Test: Create Data Array from data
-    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+%-- TODO add tests for all supported datatypes
+function [] = test_create_data_array_from_data( varargin )
+    fileName = fullfile(pwd, 'tests', 'testRW.h5');
+    daType = 'nix.DataArray';
+    f = nix.File(fileName, nix.FileMode.Overwrite);
     b = f.createBlock('arraytest', 'nixblock');
     
     assert(isempty(b.dataArrays));
     
-    data = [1, 2, 3; 4, 5, 6];
-    d1 = b.create_data_array_from_data('foo', 'bar', data);
-
-    assert(strcmp(d1.name, 'foo'));
-    assert(strcmp(d1.type, 'bar'));
+    numName = 'numDataArray';
+    numData = [1, 2, 3; 4, 5, 6];
+    da = b.create_data_array_from_data(numName, daType, numData);
+    assert(strcmp(da.name, numName));
+    assert(strcmp(da.type, daType));
+    
+    tmp = da.read_all();
+    assert(strcmp(class(tmp), class(numData)));
+    assert(isequal(size(tmp), size(numData)));
+    assert(isequal(tmp, numData));
+    
+    logName = 'logicalDataArray';
+    logData = logical([1 0 1; 0 1 0; 1 0 1]);
+    da = b.create_data_array_from_data(logName, daType, logData);
+    assert(islogical(da.read_all));
+    assert(isequal(size(da.read_all), size(logData)));
+    assert(isequal(da.read_all, logData));
+    
+    try
+        b.create_data_array_from_data('stringDataArray', daType, ['a' 'b']);
+    catch ME
+        assert(strcmp(ME.identifier, 'Block:unsupportedDataType'));
+    end;
     
-    tmp = d1.read_all();
-    assert(strcmp(class(tmp), class(data)));
-    assert(isequal(size(tmp), size(data)));
-    assert(isequal(tmp, data));
+    try
+        b.create_data_array_from_data('I will crash and burn', daType, {1 2 3});
+    catch ME
+        assert(strcmp(ME.identifier, 'Block:unsupportedDataType'));
+    end;
     
     assert(~isempty(b.dataArrays));
 end
diff --git a/tests/TestDataArray.m b/tests/TestDataArray.m
@@ -8,7 +8,7 @@
     funcs{end+1} = @test_set_metadata;
     funcs{end+1} = @test_open_metadata;
     funcs{end+1} = @test_list_sources;
-    funcs{end+1} = @test_set_data;
+    funcs{end+1} = @test_write_data;
     funcs{end+1} = @test_add_source;
     funcs{end+1} = @test_remove_source;
     funcs{end+1} = @test_dimensions;
@@ -97,18 +97,60 @@
     assert(strcmp(d1.sources{1}.name, 'Unit 5'));
 end
 
-%% Test: Set Data
-function [] = test_set_data( varargin )
-    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+%% Test: Write Data
+%-- TODO: add tests for all provided data types
+function [] = test_write_data( varargin )
+    fileName = fullfile(pwd, 'tests', 'testRW.h5');
+    typeDA = 'nix.DataArray';
+    f = nix.File(fileName, nix.FileMode.Overwrite);
     b = f.createBlock('tagtest', 'nixblock');
 
-    d1 = b.create_data_array('foo', 'bar', nix.DataType.Double, [2 3]);
-    tmp = d1.read_all();
-    assert(all(tmp(:) == 0));
+    numData = [1 2 3 4 5];
+    logData = logical([1 0 1 0 1]);
+    charData = ['a' 'b' 'c' 'd' 'e'];
+    cellData = {1 2 3 4 5};
     
-    data = [1, 2, 3; 4, 5, 6];
-    d1.write_all(data);
-    assert(isequal(d1.read_all(), data));
+    da = b.create_data_array('numericArray', typeDA, nix.DataType.Double, [1 5]);
+    tmp = da.read_all();
+    assert(all(tmp(:) == 0));
+
+    da.write_all(numData);
+    assert(isequal(da.read_all(), numData));
+
+    try
+        da.write_all(logData);
+    catch ME
+        assert(strcmp(ME.identifier, 'DataArray:improperDataType'));
+    end;
+    try
+        da.write_all(charData);
+    catch ME
+        assert(strcmp(ME.identifier, 'DataArray:improperDataType'));
+    end;
+    try
+        da.write_all(cellData);
+    catch ME
+        assert(strcmp(ME.identifier, 'DataArray:improperDataType'));
+    end;
+
+    da = b.create_data_array('logicalArray', typeDA, nix.DataType.Bool, [1 5]);
+    da.write_all(logData);
+    assert(isequal(da.read_all, logData));
+    try
+        da.write_all(numData);
+    catch ME
+        assert(strcmp(ME.identifier, 'DataArray:improperDataType'));
+    end;
+    try
+        da.write_all(charData);
+    catch ME
+        assert(strcmp(ME.identifier, 'DataArray:improperDataType'));
+    end;
+
+    clear da b f;
+    f = nix.File(fileName, nix.FileMode.ReadOnly);
+    assert(isequal(f.blocks{1}.dataArrays{1}.read_all, numData));
+    assert(isequal(f.blocks{1}.dataArrays{2}.read_all, logData));
 end
 
 %% Test: Add sources by entity and id
@@ -180,4 +222,4 @@
     
     da.delete_dimension(1);
     assert(isempty(da.dimensions));
-end
+end

-Original file line number
+Diff line change
         Bool;
         String;
         Double;
 +        %-- remove
         Char;
         Float;
         Int8;