FixedArray.swift

//===--- FixedArray.swift -------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// A helper struct to provide fixed-sized array like functionality
//
//===----------------------------------------------------------------------===//

internalstruct_FixedArray16<T>{
 // ABI TODO: This makes assumptions about tuple layout in the ABI, namely that
 // they are laid out contiguously and individually addressable (i.e. strided).
 //
internalvarstorage:(
 // A 16-wide tuple of type T
T,T,T,T,T,T,T,T,
T,T,T,T,T,T,T,T
)

var_count:Int8
}

extension_FixedArray16{
internalstaticvarcapacity:Int{
@inline(__always)get{return16}
}

internalvarcapacity:Int{
@inline(__always)get{return16}
}

internalvarcount:Int{
@inline(__always)get{returnInt(truncatingIfNeeded: _count)}
@inline(__always)set{ _count =Int8(newValue)}
}
}

extension_FixedArray16:RandomAccessCollection,MutableCollection{
internaltypealiasIndex=Int

internalvarstartIndex:Index{
return0
}

internalvarendIndex:Index{
return count
}

internal subscript(i:Index)->T{
@inline(__always)
get{
letcount=self.count // for exclusive access
_internalInvariant(i >=0 && i < count)
letres:T=withUnsafeBytes(of: storage){
(rawPtr:UnsafeRawBufferPointer)->Tin
letstride= MemoryLayout<T>.stride
_internalInvariant(rawPtr.count ==16*stride,"layout mismatch?")
letbufPtr=UnsafeBufferPointer(
 start: rawPtr.baseAddress!.assumingMemoryBound(to:T.self),
 count: count)
returnbufPtr[_unchecked: i]
}
return res
}
@inline(__always)
set{
_internalInvariant(i >=0 && i < count)
self.withUnsafeMutableBufferPointer{ buffer in
buffer[_unchecked: i]= newValue
}
}
}

@inline(__always)
internalfunc index(after i:Index)->Index{
return i+1
}

@inline(__always)
internalfunc index(before i:Index)->Index{
return i-1
}
}

extension_FixedArray16{
internalmutatingfunc append(_ newElement:T){
_internalInvariant(count < capacity)
 _count +=1
self[count-1]= newElement
}
}

extension_FixedArray16where T:ExpressibleByIntegerLiteral{
@inline(__always)
internalinit(count:Int){
_internalInvariant(count >=0 && count <= _FixedArray16.capacity)
self.storage =(
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0
)
self._count =Int8(truncatingIfNeeded: count)
}

@inline(__always)
internalinit(){
self.init(count:0)
}

@inline(__always)
internalinit(allZeros:()){
self.init(count:16)
}
}

extension_FixedArray16{
internalmutatingfunc withUnsafeMutableBufferPointer<R>(
 _ body:(UnsafeMutableBufferPointer<Element>)throws->R
)rethrows->R{
letcount=self.count // for exclusive access
returntrywithUnsafeMutableBytes(of:&storage){ rawBuffer in
_internalInvariant(rawBuffer.count ==16*MemoryLayout<T>.stride,
"layout mismatch?")
letbuffer=UnsafeMutableBufferPointer<Element>(
 start: rawBuffer.baseAddress._unsafelyUnwrappedUnchecked
.assumingMemoryBound(to:Element.self),
 count: count)
returntrybody(buffer)
}
}

internalmutatingfunc withUnsafeBufferPointer<R>(
 _ body:(UnsafeBufferPointer<Element>)throws->R
)rethrows->R{
letcount=self.count // for exclusive access
returntrywithUnsafeBytes(of:&storage){ rawBuffer in
_internalInvariant(rawBuffer.count ==16*MemoryLayout<T>.stride,
"layout mismatch?")
letbuffer=UnsafeBufferPointer<Element>(
 start: rawBuffer.baseAddress._unsafelyUnwrappedUnchecked
.assumingMemoryBound(to:Element.self),
 count: count)
returntrybody(buffer)
}
}
}