Быстрое соединение 2D-массива с типом UnsafePointer‹UnsafeMutablePointer‹Double›?›?

проблема здесь заключается в том, что C API требует этих параметров double *const *outputs и double const *const *inputs или, в терминах Swift, [[Double]] типов.

Эта сигнатура функции C импортируется Swift в следующие типы соответственно.

UnsafePointer<UnsafeMutablePointer<Double>?> 
UnsafePointer<UnsafePointer<Double>?>

Хотя легко перейти от [T] к UnsafePointer<T>, не так просто перейти к громоздким UnsafePointer<UnsafePointer<T>> и UnsafePointer<UnsafeMutablePointer<T>>. Также нет никакой документации, связанной с этими преобразованиями, которую я могу найти.

Я нашел отличный пост в блоге об указателях на UInt8 массивов Оле Бегеманна, который дал мне большую часть пути, блог Передача массива строк из Swift в C.

При этом он создает указатель UnsafeMutableBufferPointer на тип [String], а затем повторно связывает память, как показано ниже, а затем продолжает использовать смещения массивов CChar, вы можете прочитать об этом в упомянутой выше статье.

public func withArrayOfCStrings<R>(
   _ args: [String],
   _ body: ([UnsafeMutablePointer<CChar>?]) -> R) -> R {
      let argsCounts = Array(args.map { $0.utf8.count + 1 })
      let argsOffsets = [ 0 ] + scan(argsCounts, 0, +)
      let argsBufferSize = argsOffsets.last!

      var argsBuffer: [UInt8] = []
      argsBuffer.reserveCapacity(argsBufferSize)
      for arg in args {
          argsBuffer.append(contentsOf: arg.utf8)
          argsBuffer.append(0)
      }

     return argsBuffer.withUnsafeMutableBufferPointer { (argsBuffer) in
         let ptr = UnsafeMutableRawPointer(argsBuffer.baseAddress!).bindMemory(
         to: CChar.self, capacity: argsBuffer.count)
         var cStrings: [UnsafeMutablePointer<CChar>?] = argsOffsets.map { ptr + $0 }
         cStrings[cStrings.count - 1] = nil
         return body(cStrings)
     }
}

Поскольку экранирование мостовых указателей является неопределенным поведением в соответствии с документами, необходимо выполнить сопряжение и вызов внутри замыкания, как предлагает Оле Бергманн в своей статье.

Для этого создадим аналогичную функцию:

func indicatorWithArrays<R>(inputs ins:[[Double]],
                            options opts: [Double],
                            outputs out: [[Double]],
                            ti body: ([UnsafePointer<Double>?], 
                                      UnsafePointer<Double>?, 
                                      [UnsafeMutablePointer<Double>?]) -> R) -> R

это общий тип R его возвращаемого типа, как и раньше.

Внутри функции мы соединяем входы и выходы в UnsafeBufferPointer, а затем вызываем map для результирующих буферов, чтобы создать переменную типа [UnsafePointer<Double>], которую затем можно передать в тело замыкания.

return ins.withUnsafeBufferPointer { (inputsBuffer) in
    var inPuts: [UnsafePointer<Double>?] = inputsBuffer.map { UnsafePointer($0) }                                      
    return out.withUnsafeBufferPointer { (outputsBuffer) in
            var outPtrPtr: [UnsafeMutablePointer<Double>?] 
                = outputBuffer.map { UnsafeMutablePointer(mutating: $0) }                 
            return body(inPuts, opts, outPtrPtr)
        }
    }

Передача параметра [UnsafePointer<Double>] замыканию body неявно связывает требуемые параметры UnsafePointer<UnsafePointer<Double>> и UnsafePointer<UnsafeMutablePointer<Double>>, требуемые импортированным API C.

Функция indicatorWithArrays вызывается следующим образом и позволяет нам затем использовать мостовые указатели в импортированной функции C:

return indicatorWithArrays(inputs: input, options: opts, outputs: resArray) { (input, opts, outputs) in
            let sz = inputs?.first?.count ?? 0
            switch TIReturnType(rawValue: tulipInfo.info.pointee.indicator(Int32(sz), input, opts, outputs)) {
            case .ti_okay?:
                for (index, item) in outputs.enumerated() {
                    let buff = UnsafeBufferPointer(start: item, count: resArray[index].count)
                    resArray[index] = Array(buff)
                }
                return resArray
            case nil:
                return nil
            }
        }

где звонок: tulipInfo.info.pointee.indicator(Int32(sz), input, opts, outputs)

Магия заключается в передаче замыканий между функциями и, таким образом, обеспечении того, чтобы мы не ускользнули от мостовых указателей. Решение Оле Бергманна подходит для String типов, но, надеюсь, оно поможет кому-то еще, кто застрял с типом. [[T]]

Предполагая, что у вас есть, как вы указываете в своем комментарии, функция C, которую Swift набрал следующим образом:

public func indicator_abs(_ size: Int32, 
    _ inputs: UnsafePointer<UnsafePointer<Double>?>!, 
    _ options: UnsafePointer<Double>!, 
    _ outputs: UnsafePointer<UnsafeMutablePointer<Double>?>!) -> Int32

... тогда я думаю, вы можете назвать это следующим образом:

    let inputs = [1.0, 2.0]
    let options = [1.0, 1.0]
    var outputs = [0.0, 0.0]

    let result:Int32 = withUnsafePointer(to: inputs) { inputsPtr in
        withUnsafePointer(to: &outputs) { outputsPtr in
            indicator_abs(2,inputsPtr,options,outputsPtr)
        }
    }