fix and rename alignTo8Bytes early return

Author: terraputix

Swift/OmFileFormat/OmBufferedWriter.swift

@@ -40,9 +40,9 @@ public final class OmBufferedWriter<FileHandle: OmFileWriterBackend> {
     }
 
     /// Add empty space if required to align to 64 bits
-    func alignTo64Bytes() throws {
+    func alignTo8Bytes() throws {
         let bytesToPadd = 8 - totalBytesWritten % 8
-        if bytesToPadd == 0 {
+        if bytesToPadd == 8 {
             return
         }
         try reallocate(minimumCapacity: bytesToPadd)

Swift/OmFileFormat/OmFileReader.swift

@@ -121,7 +121,7 @@ public struct OmFileReader<Backend: OmFileReaderBackend> {
 
     /// Convert to string array reader if the variable is a string array
     public func asStringArray(io_size_max: UInt64 = 65536, io_size_merge: UInt64 = 512) -> OmFileReaderStringArray<Backend>? {
-        guard dataType == .string_array else {
+        guard self.dataType == .string_array else {
             return nil
         }
 
@@ -497,7 +497,7 @@ extension OmFileReaderBackend {
             /// The size to decode a single chunk
             let bufferSize = om_decoder_read_buffer_size(decoder)
 
-            /// Loop over index blocks and read index data
+            // Loop over index blocks and read index data
             while om_decoder_next_index_read(decoder, &indexRead) {
                 //print("Read index \(indexRead)")
                 let indexData = self.getData(offset: Int(indexRead.offset), count: Int(indexRead.count))
@@ -506,7 +506,7 @@ extension OmFileReaderBackend {
                 om_decoder_init_data_read(&dataRead, &indexRead)
 
                 var error: OmError_t = ERROR_OK
-                /// Loop over data blocks and read compressed data chunks
+                // Loop over data blocks and read compressed data chunks
                 while om_decoder_next_data_read(decoder, &dataRead, indexData, indexRead.count, &error) {
                     //print("ENQUEUE chunk index \(dataRead.chunkIndex)")
                     let dataReadOffset = dataRead.offset

Swift/OmFileFormat/OmFileWriter.swift

@@ -35,7 +35,7 @@ public struct OmFileWriter<FileHandle: OmFileWriterBackend> {
             guard name.count <= UInt16.max else { fatalError() }
             guard children.count <= UInt32.max else { fatalError() }
             let type = OmType.dataTypeScalar.toC()
-            try buffer.alignTo64Bytes()
+            try buffer.alignTo8Bytes()
 
             let stringLength: UInt64
             if type == DATA_TYPE_STRING {
@@ -92,7 +92,7 @@ public struct OmFileWriter<FileHandle: OmFileWriterBackend> {
         var name = name
         return try name.withUTF8{ name in
             guard name.count <= UInt16.max else { fatalError() }
-            try buffer.alignTo64Bytes()
+            try buffer.alignTo8Bytes()
             let size = om_variable_write_numeric_array_size(UInt16(name.count), UInt32(children.count), UInt64(array.dimensions.count))
             let offset = UInt64(buffer.totalBytesWritten)
             try buffer.reallocate(minimumCapacity: Int(size))
@@ -106,7 +106,7 @@ public struct OmFileWriter<FileHandle: OmFileWriterBackend> {
 
     public func writeTrailer(rootVariable: OmOffsetSize) throws {
         try writeHeaderIfRequired()
-        try buffer.alignTo64Bytes()
+        try buffer.alignTo8Bytes()
 
         // write length of JSON
         let size = om_trailer_size()
@@ -316,19 +316,24 @@ public final class OmFileWriterStringArray<FileHandle: OmFileWriterBackend> {
 
     public init(dimensions: [UInt64], buffer: OmBufferedWriter<FileHandle>) {
         self.dimensions = dimensions
-        // Allocate space for a lookup table. Needs to be number_of_chunks+1 to store start address and for each chunk then end address
-        self.lookUpTable = .init(repeating: 0, count: Int(dimensions.reduce(1, *) + 1))
+        let numberOfStrings = dimensions.reduce(1, *)
+        // Allocate space for a lookup table.
+        // Needs to be numberOfStrings+1 to store start of first string
+        // as first element and for each string then the end address
+        self.lookUpTable = .init(repeating: 0, count: Int(numberOfStrings + 1))
         self.currentPosition = 0
         self.buffer = buffer
     }
 
+    /// Write all strings at once. The array must match the dimensions
     public func writeData(array: [String]) throws {
         // Verify array size matches dimensions
         let expectedSize = dimensions.reduce(1, *)
         guard array.count == expectedSize && self.currentPosition == 0 else {
             throw OmFileFormatSwiftError.omEncoder(error: "String arrays need to be encoded all at once and must match the dimensions")
         }
 
+        // Store data start address if this is the first time this read is called
         let lutOffset = UInt64(buffer.totalBytesWritten)
         if self.currentPosition == 0 {
             lookUpTable[0] = lutOffset
@@ -352,7 +357,7 @@ public final class OmFileWriterStringArray<FileHandle: OmFileWriterBackend> {
     }
 
     public func finalise() throws -> OmFileWriterArrayFinalised {
-        try buffer.alignTo64Bytes()
+        try buffer.alignTo8Bytes()
         let lutOffset = buffer.totalBytesWritten
 
         // Write uncompressed LUT

Tests/OmFileFormatTests/OmFileFormatTests.swift

@@ -359,7 +359,7 @@ import Foundation
         try fileWriter.writeTrailer(rootVariable: variable)
 
         let readFn = try MmapFile(fn: FileHandle.openFileReading(file: file))
-        #expect(readFn.count == 336)
+        #expect(readFn.count == 328)
         let bytes = Data(bytesNoCopy: UnsafeMutableRawPointer(mutating: readFn.getData(offset: 0, count: readFn.count)), count: readFn.count, deallocator: .none).map{ UInt8($0) }
         #expect(bytes[0..<3] == [79, 77, 3])
         #expect(bytes[3..<3+7] == [115, 116, 114, 105, 110, 103, 49]) // string1
@@ -389,7 +389,7 @@ import Foundation
             94, 0, 0, 0, 0, 0, 0, 0,
             102, 0, 0, 0, 0, 0, 0, 0
         ]) // LUT
-        #expect(bytes[104+14*8..<104+14*8+92] == [ // FIXME: Why +14*8 and not +13*8?
+        #expect(bytes[104+13*8..<104+13*8+92] == [
             22, 4, 4, 0, 0, 0, 0, 0, // data type (1), compression (1), size of name (2), number of children (4)
             104, 0, 0, 0, 0, 0, 0, 0, // size of LUT
             104, 0, 0, 0, 0, 0, 0, 0, // offset of LUT
@@ -403,12 +403,15 @@ import Foundation
             1, 0, 0, 0, 0, 0, 0, 0, // chunk3, should be removed
             100, 97, 116, 97
         ]) // array meta
-        #expect(bytes[336-24..<336] == [79, 77, 3, 0, 0, 0, 0, 0, 216, 0, 0, 0, 0, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0]) // trailer
+        #expect(bytes[328-24..<328] == [79, 77, 3, 0, 0, 0, 0, 0, 208, 0, 0, 0, 0, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0]) // trailer
 
 
         let read = try OmFileReader(fn: readFn).asStringArray()!
-        let a = try read.read(range: [0..<3, 0..<2, 0..<2])
-        #expect(a == data)
+        let complete_array = try read.read()
+        #expect(complete_array == data)
+
+        let partial_array = try read.read(range: [0..<3, 0..<2, 0..<1])
+        #expect(partial_array == ["string1", "string3", "string5", "string7", "", "string11"])
     }
 
     @Test func writev3() throws {