ManagedBufferPointer

struct ManagedBufferPointer<Header, Element>

Contains a buffer object, and provides access to an instance of Header and contiguous storage for an arbitrary number of Element instances stored in that buffer.

For most purposes, the ManagedBuffer class works fine for this purpose, and can simply be used on its own. However, in cases where objects of various different classes must serve as storage, ManagedBufferPointer is needed.

A valid buffer class is non-@objc, with no declared stored properties. Its deinit must destroy its stored Header and any constructed Elements.

Example Buffer Class

 class MyBuffer<Element> { // non-@objc
   typealias Manager = ManagedBufferPointer<(Int, String), Element>
   deinit {
     Manager(unsafeBufferObject: self).withUnsafeMutablePointers {
       (pointerToHeader, pointerToElements) -> Void in
       pointerToElements.deinitialize(count: self.count)
       pointerToHeader.deinitialize()
     }
   }

   // All properties are *computed* based on members of the Header
   var count: Int {
     return Manager(unsafeBufferObject: self).header.0
   }
   var name: String {
     return Manager(unsafeBufferObject: self).header.1
   }
 }
Inheritance Equatable View Protocol Hierarchy →
Import import Swift

Initializers

init(bufferClass:minimumCapacity:makingHeaderWith:)

Create with new storage containing an initial Header and space for at least minimumCapacity elements.

bufferClass: The class of the object used for storage.

minimumCapacity: The minimum number of Elements that must be able to be stored in the new buffer.

factory: A function that produces the initial Header instance stored in the buffer, given the buffer object and a function that can be called on it to get the actual number of allocated elements.

Precondition: minimumCapacity >= 0, and the type indicated by bufferClass is a non-@objc class with no declared stored properties. The deinit of bufferClass must destroy its stored Header and any constructed Elements.

Declaration

init(bufferClass: Swift.AnyClass, minimumCapacity: Int, makingHeaderWith factory: (AnyObject, (AnyObject) -> Int) throws -> Header)
init(unsafeBufferObject:)

Manage the given buffer.

Precondition: buffer is an instance of a non-@objc class whose deinit destroys its stored Header and any constructed Elements.

Declaration

init(unsafeBufferObject buffer: AnyObject)

Instance Variables

var buffer: AnyObject

Returns the object instance being used for storage.

Declaration

var buffer: AnyObject { get }
var capacity: Int

The actual number of elements that can be stored in this object.

This value may be nontrivial to compute; it is usually a good idea to store this information in the "header" area when an instance is created.

Declaration

var capacity: Int { get }
var header: Header

The stored Header instance.

Declaration

var header: Header { get set }

Instance Methods

mutating func isUniqueReference()

Returns true iff self holds the only strong reference to its buffer.

See isUniquelyReferenced for details.

Declaration

mutating func isUniqueReference() -> Bool
func withUnsafeMutablePointerToElements(_:)

Call body with an UnsafeMutablePointer to the Element storage.

Note: This pointer is only valid for the duration of the call to body.

Declaration

func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
func withUnsafeMutablePointerToHeader(_:)

Call body with an UnsafeMutablePointer to the stored Header.

Note: This pointer is only valid for the duration of the call to body.

Declaration

func withUnsafeMutablePointerToHeader<R>(_ body: (UnsafeMutablePointer<Header>) throws -> R) rethrows -> R
func withUnsafeMutablePointers(_:)

Call body with UnsafeMutablePointers to the stored Header and raw Element storage.

Note: These pointers are only valid for the duration of the call to body.

Declaration

func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Header>, UnsafeMutablePointer<Element>) throws -> R) rethrows -> R