ManagedBufferPointer

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(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

Instance Variables

var buffer: AnyObject

Returns the object instance being used for storage.

Declaration

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