mahalex/MatFileHandler
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases 9 Wiki Activity

Even better objects #39

Merged
mahalex merged 10 commits from dev/even-better-objects into master 2025-04-14 19:03:42 +00:00
Conversation 0 Commits 10 Files Changed 77 +74 -87
14 changed files with 74 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 306992f969 - Show all commits

8
MatFileHandler/ChecksumCalculatingStream.cs
View File

@ -13,8 +13,8 @@ namespace MatFileHandler
{
private const uint BigPrime = 0xFFF1;
private readonly Stream _stream;
private uint s1 = 1;
private uint s2 = 0;
private uint s1;
private uint s2;
/// <summary>
/// Initializes a new instance of the <see cref="ChecksumCalculatingStream"/> class.
@ -23,6 +23,8 @@ namespace MatFileHandler
public ChecksumCalculatingStream(Stream stream)
{
_stream = stream;
s1 = 1;
s2 = 0;
}
/// <inheritdoc />
@ -89,4 +91,4 @@ namespace MatFileHandler
return (s2 << 16) | s1;
}
}
}
}

9
MatFileHandler/DataBuilder.cs
View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using System.Linq;
using System.Numerics;
#pragma warning disable CA1822
namespace MatFileHandler
{
/// <summary>
@ -52,7 +53,7 @@ namespace MatFileHandler
{
if (data.Length != dimensions.NumberOfElements())
{
throw new ArgumentException("Data size does not match the specified dimensions", "data");
throw new ArgumentException("Data size does not match the specified dimensions", nameof(data));
}
return new MatNumericalArrayOf<T>(GetStandardFlags<T>(), dimensions, string.Empty, data);
}
@ -157,7 +158,7 @@ namespace MatFileHandler
return new MatFile(variables);
}
private ArrayFlags ConstructArrayFlags(ArrayType class_, bool isComplex = false, bool isLogical = false)
private static ArrayFlags ConstructArrayFlags(ArrayType class_, bool isComplex = false, bool isLogical = false)
{
return new ArrayFlags
{
@ -167,7 +168,7 @@ namespace MatFileHandler
};
}
private ArrayFlags GetStandardFlags<T>()
private static ArrayFlags GetStandardFlags<T>()
{
if (typeof(T) == typeof(sbyte))
{
@ -266,4 +267,4 @@ namespace MatFileHandler
};
}
}
}
}

6
MatFileHandler/DataElementConverter.cs
View File

@ -71,9 +71,9 @@ namespace MatFileHandler
{
throw new NotSupportedException("Only 2-dimensional sparse arrays are supported");
}
if (data == null)
if (data is null)
{
throw new ArgumentException("Null data found.", "data");
throw new ArgumentException("Null data found.", nameof(data));
}
var elements =
ConvertDataToSparseProperType<T>(data, flags.ArrayFlags.Variable.HasFlag(Variable.IsLogical));
@ -243,4 +243,4 @@ namespace MatFileHandler
};
}
}
}
}

10
MatFileHandler/DataElementReader.cs
View File

@ -212,7 +212,7 @@ namespace MatFileHandler
}
}
private DataElement ContinueReadingCellArray(
private MatCellArray ContinueReadingCellArray(
BinaryReader reader,
ArrayFlags flags,
int[] dimensions,
@ -258,11 +258,11 @@ namespace MatFileHandler
}
else
{
return new Opaque(name, typeDescription, className, new int[] { }, data, subsystemData);
return new Opaque(name, typeDescription, className, Array.Empty<int>(), data, subsystemData);
}
}
private DataElement ContinueReadingSparseArray(
private MatArray ContinueReadingSparseArray(
BinaryReader reader,
DataElement firstElement,
int[] dimensions,
@ -313,7 +313,7 @@ namespace MatFileHandler
}
}
private DataElement ContinueReadingStructure(
private MatStructureArray ContinueReadingStructure(
BinaryReader reader,
ArrayFlags flags,
int[] dimensions,
@ -526,4 +526,4 @@ namespace MatFileHandler
}
}
}
}
}

12
MatFileHandler/FakeWriter.cs
View File

@ -202,24 +202,24 @@ namespace MatFileHandler
WriteDataElement(buffer);
}
private unsafe int GetLengthOfByteArray<T>(int dataLength)
private static unsafe int GetLengthOfByteArray<T>(int dataLength)
where T : unmanaged
{
return dataLength * sizeof(T);
}
private unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data)
private static unsafe int GetLengthOfPairOfByteArrays<T>(ComplexOf<T>[] data)
where T : unmanaged
{
return data.Length * sizeof(T);
}
private unsafe int GetLengthOfPairOfByteArrays(Complex[] data)
private static unsafe int GetLengthOfPairOfByteArrays(Complex[] data)
{
return data.Length * sizeof(double);
}
private int CalculatePadding(int length)
private static int CalculatePadding(int length)
{
var rem = length % 8;
if (rem == 0)
@ -275,7 +275,7 @@ namespace MatFileHandler
}
}
private (int rowIndexLength, int columnIndexLength, int dataLength, uint nonZero) PrepareSparseArrayData<T>(
private static (int rowIndexLength, int columnIndexLength, int dataLength, uint nonZero) PrepareSparseArrayData<T>(
ISparseArrayOf<T> array)
where T : struct, IEquatable<T>
{
@ -395,4 +395,4 @@ namespace MatFileHandler
fakeWriter => fakeWriter.WriteNumericalArrayContents(numericalArray, name));
}
}
}
}

4
MatFileHandler/ICharArray.cs
View File

@ -10,6 +10,8 @@ namespace MatFileHandler
/// <summary>
/// Gets the contained string.
/// </summary>
#pragma warning disable CA1716, CA1720
string String { get; }
#pragma warning restore CA1716, CA1720
}
}
}

4
MatFileHandler/MatArray.cs
View File

@ -51,7 +51,7 @@ namespace MatFileHandler
/// <returns>Empty array.</returns>
public static MatArray Empty()
{
return new MatArray(new ArrayFlags { Class = ArrayType.MxCell, Variable = 0 }, new int[] { }, string.Empty);
return new MatArray(new ArrayFlags { Class = ArrayType.MxCell, Variable = 0 }, Array.Empty<int>(), string.Empty);
}
/// <inheritdoc />
@ -78,4 +78,4 @@ namespace MatFileHandler
return null;
}
}
}
}

21
MatFileHandler/MatFileHandler.csproj
View File

@ -23,30 +23,21 @@
<EmbedUntrackedSources>true</EmbedUntrackedSources>
<SymbolPackageFormat>snupkg</SymbolPackageFormat>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<AnalysisLevel>latest-Recommended</AnalysisLevel>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
</ItemGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<CodeAnalysisRuleSet>..\MatFileHandler.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<CodeAnalysisRuleSet>..\MatFileHandler.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<AdditionalFiles Include="..\stylecop.json" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.66">
<PrivateAssets>All</PrivateAssets>
</PackageReference>
<PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
</ItemGroup>
<ItemGroup>
<None Include="..\README.md" Pack="true" PackagePath="\"/>
</ItemGroup>
<ItemGroup>
<InternalsVisibleTo Include="MatFileHandler.Tests" />
</ItemGroup>

4
MatFileHandler/MatFileReader.cs
View File

@ -88,7 +88,7 @@ namespace MatFileHandler
return ReadRawVariables(reader, subsystemDataOffset, subsystemData);
}
private static IMatFile Read(BinaryReader reader)
private static MatFile Read(BinaryReader reader)
{
var header = ReadHeader(reader);
var rawVariables = ReadRawVariables(reader, header.SubsystemDataOffset);
@ -120,4 +120,4 @@ namespace MatFileHandler
return SubsystemDataReader.Read(bytes, subsystemData);
}
}
}
}

65
MatFileHandler/MatFileWriter.cs
View File

@ -69,7 +69,7 @@ namespace MatFileHandler
WriteVariable(writer, variable);
break;
default:
throw new ArgumentOutOfRangeException();
throw new NotImplementedException();
}
}
}
@ -98,7 +98,7 @@ namespace MatFileHandler
return (s2 << 16) | s1;
}
private void WriteHeader(BinaryWriter writer, Header header)
private static void WriteHeader(BinaryWriter writer, Header header)
{
writer.Write(Encoding.UTF8.GetBytes(header.Text));
writer.Write(header.SubsystemDataOffset);
@ -106,28 +106,19 @@ namespace MatFileHandler
writer.Write((short)19785); // Magic number, 'IM'.
}
private void WriteTag(BinaryWriter writer, Tag tag)
private static void WriteTag(BinaryWriter writer, Tag tag)
{
writer.Write((int)tag.Type);
writer.Write(tag.Length);
}
private void WriteShortTag(BinaryWriter writer, Tag tag)
private static void WriteShortTag(BinaryWriter writer, Tag tag)
{
writer.Write((short)tag.Type);
writer.Write((short)tag.Length);
}
private void WritePadding(BinaryWriter writer)
{
var positionMod8 = writer.BaseStream.Position % 8;
if (positionMod8 != 0)
{
writer.Write(new byte[8 - positionMod8]);
}
}
private void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
private static void WriteDataElement(BinaryWriter writer, DataType type, byte[] data)
{
if (data.Length > 4)
{
@ -152,13 +143,13 @@ namespace MatFileHandler
}
}
private void WriteDimensions(BinaryWriter writer, int[] dimensions)
private static void WriteDimensions(BinaryWriter writer, int[] dimensions)
{
var buffer = ConvertToByteArray(dimensions);
WriteDataElement(writer, DataType.MiInt32, buffer);
}
private byte[] ConvertToByteArray<T>(T[] data)
private static byte[] ConvertToByteArray<T>(T[] data)
where T : struct
{
int size;
@ -211,26 +202,26 @@ namespace MatFileHandler
return buffer;
}
private (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays<T>(ComplexOf<T>[] data)
private static (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays<T>(ComplexOf<T>[] data)
where T : struct
{
return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
ConvertToByteArray(data.Select(x => x.Imaginary).ToArray()));
}
private (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays(Complex[] data)
private static (byte[] real, byte[] imaginary) ConvertToPairOfByteArrays(Complex[] data)
{
return (ConvertToByteArray(data.Select(x => x.Real).ToArray()),
ConvertToByteArray(data.Select(x => x.Imaginary).ToArray()));
}
private void WriteComplexValues(BinaryWriter writer, DataType type, (byte[] real, byte[] complex) data)
private static void WriteComplexValues(BinaryWriter writer, DataType type, (byte[] real, byte[] complex) data)
{
WriteDataElement(writer, type, data.real);
WriteDataElement(writer, type, data.complex);
}
private void WriteArrayFlags(BinaryWriter writer, ArrayFlags flags)
private static void WriteArrayFlags(BinaryWriter writer, ArrayFlags flags)
{
var flag = (byte)flags.Variable;
WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@ -239,7 +230,7 @@ namespace MatFileHandler
writer.Write(new byte[] { 0, 0, 0, 0, 0, 0 });
}
private void WriteSparseArrayFlags(BinaryWriter writer, SparseArrayFlags flags)
private static void WriteSparseArrayFlags(BinaryWriter writer, SparseArrayFlags flags)
{
var flag = (byte)flags.ArrayFlags.Variable;
WriteTag(writer, new Tag(DataType.MiUInt32, 8));
@ -249,13 +240,13 @@ namespace MatFileHandler
writer.Write(flags.NzMax);
}
private void WriteName(BinaryWriter writer, string name)
private static void WriteName(BinaryWriter writer, string name)
{
var nameBytes = Encoding.ASCII.GetBytes(name);
WriteDataElement(writer, DataType.MiInt8, nameBytes);
}
private void WriteNumericalArrayValues(BinaryWriter writer, IArray value)
private static void WriteNumericalArrayValues(BinaryWriter writer, IArray value)
{
switch (value)
{
@ -330,7 +321,7 @@ namespace MatFileHandler
}
}
private ArrayFlags GetArrayFlags(IArray array, bool isGlobal)
private static ArrayFlags GetArrayFlags(IArray array, bool isGlobal)
{
var variableFlags = isGlobal ? Variable.IsGlobal : 0;
switch (array)
@ -386,7 +377,7 @@ namespace MatFileHandler
}
}
private SparseArrayFlags GetSparseArrayFlags<T>(ISparseArrayOf<T> array, bool isGlobal, uint nonZero)
private static SparseArrayFlags GetSparseArrayFlags<T>(ISparseArrayOf<T> array, bool isGlobal, uint nonZero)
where T : struct
{
var flags = GetArrayFlags(array, isGlobal);
@ -401,12 +392,12 @@ namespace MatFileHandler
};
}
private ArrayFlags GetCharArrayFlags(bool isGlobal)
private static ArrayFlags GetCharArrayFlags(bool isGlobal)
{
return new ArrayFlags(ArrayType.MxChar, isGlobal ? Variable.IsGlobal : 0);
}
private void WriteWrappingContents<T>(
private static void WriteWrappingContents<T>(
BinaryWriter writer,
T array,
Action<FakeWriter> lengthCalculator,
@ -426,7 +417,7 @@ namespace MatFileHandler
writeContents(writer);
}
private void WriteNumericalArrayContents(BinaryWriter writer, IArray array, string name, bool isGlobal)
private static void WriteNumericalArrayContents(BinaryWriter writer, IArray array, string name, bool isGlobal)
{
WriteArrayFlags(writer, GetArrayFlags(array, isGlobal));
WriteDimensions(writer, array.Dimensions);
@ -434,7 +425,7 @@ namespace MatFileHandler
WriteNumericalArrayValues(writer, array);
}
private void WriteNumericalArray(
private static void WriteNumericalArray(
BinaryWriter writer,
IArray numericalArray,
string name = "",
@ -447,7 +438,7 @@ namespace MatFileHandler
contentsWriter => { WriteNumericalArrayContents(contentsWriter, numericalArray, name, isGlobal); });
}
private void WriteCharArrayContents(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
private static void WriteCharArrayContents(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
{
WriteArrayFlags(writer, GetCharArrayFlags(isGlobal));
WriteDimensions(writer, charArray.Dimensions);
@ -456,7 +447,7 @@ namespace MatFileHandler
WriteDataElement(writer, DataType.MiUtf16, ConvertToByteArray(array));
}
private void WriteCharArray(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
private static void WriteCharArray(BinaryWriter writer, ICharArray charArray, string name, bool isGlobal)
{
WriteWrappingContents(
writer,
@ -465,7 +456,7 @@ namespace MatFileHandler
contentsWriter => { WriteCharArrayContents(contentsWriter, charArray, name, isGlobal); });
}
private void WriteSparseArrayValues<T>(
private static void WriteSparseArrayValues<T>(
BinaryWriter writer, int[] rows, int[] columns, T[] data)
where T : struct
{
@ -497,7 +488,7 @@ namespace MatFileHandler
}
}
private (int[] rowIndex, int[] columnIndex, T[] data, uint nonZero) PrepareSparseArrayData<T>(
private static (int[] rowIndex, int[] columnIndex, T[] data, uint nonZero) PrepareSparseArrayData<T>(
ISparseArrayOf<T> array)
where T : struct, IEquatable<T>
{
@ -520,7 +511,7 @@ namespace MatFileHandler
return (rowIndexList.ToArray(), columnIndex, valuesList.ToArray(), (uint)rowIndexList.Count);
}
private void WriteSparseArrayContents<T>(
private static void WriteSparseArrayContents<T>(
BinaryWriter writer,
ISparseArrayOf<T> array,
string name,
@ -534,7 +525,7 @@ namespace MatFileHandler
WriteSparseArrayValues(writer, rows, columns, data);
}
private void WriteSparseArray<T>(BinaryWriter writer, ISparseArrayOf<T> sparseArray, string name, bool isGlobal)
private static void WriteSparseArray<T>(BinaryWriter writer, ISparseArrayOf<T> sparseArray, string name, bool isGlobal)
where T : unmanaged, IEquatable<T>
{
WriteWrappingContents(
@ -544,7 +535,7 @@ namespace MatFileHandler
contentsWriter => { WriteSparseArrayContents(contentsWriter, sparseArray, name, isGlobal); });
}
private void WriteFieldNames(BinaryWriter writer, IEnumerable<string> fieldNames)
private static void WriteFieldNames(BinaryWriter writer, IEnumerable<string> fieldNames)
{
var fieldNamesArray = fieldNames.Select(name => Encoding.ASCII.GetBytes(name)).ToArray();
var maxFieldName = fieldNamesArray.Select(name => name.Length).Max() + 1;
@ -708,4 +699,4 @@ namespace MatFileHandler
}
}
}
}
}

8
MatFileHandler/MatSparseArrayOf.cs
View File

@ -49,7 +49,7 @@ namespace MatFileHandler
get
{
var rowAndColumn = GetRowAndColumn(list);
return DataDictionary.ContainsKey(rowAndColumn) ? DataDictionary[rowAndColumn] : default(T);
return DataDictionary.TryGetValue(rowAndColumn, out var result) ? result : default;
}
set => DataDictionary[GetRowAndColumn(list)] = value;
}
@ -61,7 +61,7 @@ namespace MatFileHandler
public override double[] ConvertToDoubleArray()
{
var data = ((IArrayOf<T>)this).Data;
return data as double[] ?? data.Select(x => Convert.ToDouble(x)).ToArray();
return data as double[] ?? data.Select(x => Convert.ToDouble(x, System.Globalization.CultureInfo.InvariantCulture)).ToArray();
}
/// <inheritdoc />
@ -75,7 +75,7 @@ namespace MatFileHandler
var result = new double[Dimensions[0], Dimensions[1]];
foreach (var pair in Data)
{
result[pair.Key.row, pair.Key.column] = Convert.ToDouble(pair.Value);
result[pair.Key.row, pair.Key.column] = Convert.ToDouble(pair.Value, System.Globalization.CultureInfo.InvariantCulture);
}
return result;
@ -104,4 +104,4 @@ namespace MatFileHandler
}
}
}
}
}

2
MatFileHandler/MatStructureArray.cs
View File

@ -69,7 +69,7 @@ namespace MatFileHandler
"Cannot set structure elements via this[params int[]] indexer. Use this[string, int[]] instead.");
}
private IReadOnlyDictionary<string, IArray> ExtractStructure(int i)
private MatStructureArrayElement ExtractStructure(int i)
{
return new MatStructureArrayElement(this, i);
}

4
MatFileHandler/OpaqueLink.cs
View File

@ -85,7 +85,7 @@ namespace MatFileHandler
return result!;
}
throw new IndexOutOfRangeException();
throw new ArgumentOutOfRangeException(nameof(list));
}
set => throw new NotImplementedException();
}
@ -97,7 +97,7 @@ namespace MatFileHandler
set => throw new NotImplementedException();
}
private IReadOnlyDictionary<string, IArray> ExtractObject(int i)
private OpaqueObjectArrayElement ExtractObject(int i)
{
return new OpaqueObjectArrayElement(this, i);
}

4
MatFileHandler/TableAdapter.cs
View File

@ -89,7 +89,7 @@ namespace MatFileHandler
.FirstOrDefault();
if (!(maybeIndex is int index))
{
throw new IndexOutOfRangeException($"Variable '{variableName}' not found.");
throw new ArgumentOutOfRangeException(nameof(variableName), $"Variable '{variableName}' not found.");
}
var data = matObject["data"] as ICellArray
@ -98,4 +98,4 @@ namespace MatFileHandler
}
}
}
}
}