Data

base64EncodedData

base64EncodedData(options?: NSData_Base64EncodingOptions): ArrayBuffer

func base64EncodedData(options: Data.Base64EncodingOptions = []) -> Data

Returns Base-64 encoded data. - parameter options: The options to use for the encoding. Default value is `[]`. - returns: The Base-64 encoded data.

init

static initContentsOfOptions(url: string, options?: NSData_ReadingOptions): ArrayBuffer

init(contentsOf url: URL, options: Data.ReadingOptions = []) throws

Creates data by reading from the specified URL. - parameter url: The `URL` to read. - parameter options: Options for the read operation. Default value is `[]`. - throws: An error in the Cocoa domain, if `url` cannot be read.

resetBytes

resetBytes(range: SDKHandle): void

mutating func resetBytes(in range: Range<Data.Index>)

Sets a region of the data buffer to 0. If `range` exceeds the bounds of the data, then the data is resized to fit. - parameter range: The range in the data to set to `0`.

startIndex

get startIndex(): number

var startIndex: Data.Index { get }

The beginning index into the data.

init

static initBytesNoCopyCountDeallocator(bytes: SDKHandle, count: number, deallocator: Data_Deallocator): ArrayBuffer

init(bytesNoCopy bytes: UnsafeMutableRawPointer, count: Int, deallocator: Data.Deallocator)

Creates a data buffer with memory content without copying the bytes. If the result is mutated and is not a unique reference, then the `Data` will still follow copy-on-write semantics. In this case, the copy will use its own deallocator. Therefore, it is usually best to only use this initializer when you either enforce immutability with `let` or ensure that no other references to the underlying data are formed. - parameter bytes: A pointer to the bytes. - parameter count: The size of the bytes. - parameter deallocator: Specifies the mechanism to free the indicated buffer, or `.none`.

description

get description(): string

var description: String { get }

A human-readable description for the data.

init

static initReferencing(reference: NSData): ArrayBuffer

init(referencing reference: NSData)

Initialize a `Data` by adopting a reference type. You can use this initializer to create a `struct Data` that wraps a `class NSData`. `struct Data` will use the `class NSData` for all operations. Other initializers (including casting using `as Data`) may choose to hold a reference or not, based on a what is the most efficient representation. If the resulting value is mutated, then `Data` will invoke the `mutableCopy()` function on the reference to copy the contents. You may customize the behavior of that function if you wish to return a specialized mutable subclass. - parameter reference: The instance of `NSData` that you wish to wrap. This instance will be copied by `struct Data`.

customMirror

get customMirror(): SDKHandle

var customMirror: Mirror { get }

The custom mirror for this instance. If this type has value semantics, the mirror should be unaffected by subsequent mutations of the instance.

makeIterator

makeIterator(): Data_Iterator

func makeIterator() -> Data.Iterator

Returns an iterator over the contents of the data. The iterator will increment byte-by-byte.

init

static initBase64EncodedOptions(base64Data: ArrayBuffer, options?: NSData_Base64DecodingOptions): (ArrayBuffer) | null

init?(base64Encoded base64Data: Data, options: Data.Base64DecodingOptions = [])

Initialize a `Data` from a Base-64, UTF-8 encoded `Data`. Returns nil when the input is not recognized as valid Base-64. - parameter base64Data: Base-64, UTF-8 encoded input data. - parameter options: Decoding options. Default value is `[]`.

init

static initBase64EncodedOptions89559(base64String: string, options?: NSData_Base64DecodingOptions): (ArrayBuffer) | null

init?(base64Encoded base64String: String, options: Data.Base64DecodingOptions = [])

Initialize a `Data` from a Base-64 encoded String using the given options. Returns nil when the input is not recognized as valid Base-64. - parameter base64String: The string to parse. - parameter options: Encoding options. Default value is `[]`.

enumerateBytes

enumerateBytes(block: ((arg0: Uint8Array, arg1: number, arg2: boolean) => void)): void

func enumerateBytes(_ block: (UnsafeBufferPointer<UInt8>, Data.Index, inout Bool) -> Void)

Enumerates the contents of the data's buffer. In some cases, (for example, a `Data` backed by a `dispatch_data_t`, the bytes may be stored discontinuously. In those cases, this function invokes the closure for each contiguous region of bytes. - parameter block: The closure to invoke for each region of data. You may stop the enumeration by setting the `stop` parameter to `true`.

removeSubrange

removeSubrange(bounds: SDKHandle): void

mutating func removeSubrange(_ bounds: Range<Data.Index>)

Removes the specified subrange of elements from the collection. var bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"] bugs.removeSubrange(1...3) print(bugs) // Prints "["Aphid", "Earwig"]" Calling this method may invalidate any existing indices for use with this collection. - Parameter bounds: The subrange of the collection to remove. The bounds of the range must be valid indices of the collection. - Complexity: O(*n*), where *n* is the length of the collection.

replaceSubrange

replaceSubrangeWithCount(subrange: SDKHandle, bytes: SDKHandle, cnt: number): void

mutating func replaceSubrange(_ subrange: Range<Data.Index>, with bytes: UnsafeRawPointer, count cnt: Int)

Replaces a region of bytes in the data with bytes from memory.

replaceSubrange

replaceSubrangeWith(subrange: SDKHandle, buffer: unknown[]): void

mutating func replaceSubrange<SourceType>(_ subrange: Range<Data.Index>, with buffer: UnsafeBufferPointer<SourceType>)

Replaces a region of bytes in the data with new bytes from a buffer. This will resize the data if required, to fit the entire contents of `buffer`. - precondition: The bounds of `subrange` must be valid indices of the collection. - parameter subrange: The range in the data to replace. - parameter buffer: The replacement bytes.

reserveCapacity

reserveCapacity(minimumCapacity: number): void

mutating func reserveCapacity(_ minimumCapacity: Int)

Prepares the collection to store the specified number of elements, when doing so is appropriate for the underlying type.

withUnsafeBytes

withUnsafeBytes(body: ((arg0: ArrayBuffer) => unknown)): unknown

func withUnsafeBytes<E, ResultType>(_ body: (UnsafeRawBufferPointer) throws(E) -> ResultType) throws(E) -> ResultType where E : Error, ResultType : ~Copyable

Calls the given closure with the contents of underlying storage. - note: Calling `withUnsafeBytes` multiple times does not guarantee that the same buffer pointer will be passed in every time. - warning: The buffer argument to the body should not be stored or used outside of the lifetime of the call to the closure. Clients should prefer the `withBytes` function to this one, because `withBytes` uses the non-escapable type `RawSpan` to ensure that the buffer argument is not stored outside of the closure.

withUnsafeBytes

withUnsafeBytes27405(body: ((arg0: SDKHandle) => unknown)): unknown

func withUnsafeBytes<ResultType, ContentType>(_ body: (UnsafePointer<ContentType>) throws -> ResultType) rethrows -> ResultType

Access the bytes in the data. - warning: The byte pointer argument should not be stored and used outside of the lifetime of the call to the closure.

debugDescription

get debugDescription(): string

var debugDescription: String { get }

A human-readable debug description for the data.

base64EncodedString

base64EncodedString(options?: NSData_Base64EncodingOptions): string

func base64EncodedString(options: Data.Base64EncodingOptions = []) -> String

Returns a Base-64 encoded string. - parameter options: The options to use for the encoding. Default value is `[]`. - returns: The Base-64 encoded string.

withUnsafeMutableBytes

withUnsafeMutableBytes(body: ((arg0: ArrayBuffer) => unknown)): unknown

mutating func withUnsafeMutableBytes<E, ResultType>(_ body: (UnsafeMutableRawBufferPointer) throws(E) -> ResultType) throws(E) -> ResultType where E : Error, ResultType : ~Copyable

withUnsafeMutableBytes

withUnsafeMutableBytes10817(body: ((arg0: SDKHandle) => unknown)): unknown

mutating func withUnsafeMutableBytes<ResultType, ContentType>(_ body: (UnsafeMutablePointer<ContentType>) throws -> ResultType) rethrows -> ResultType

Mutate the bytes in the data. This function assumes that you are mutating the contents. - warning: The byte pointer argument should not be stored and used outside of the lifetime of the call to the closure.

withContiguousStorageIfAvailable

withContiguousStorageIfAvailable(body: ((arg0: Uint8Array) => unknown)): (unknown) | null

func withContiguousStorageIfAvailable<E, ResultType>(_ body: (UnsafeBufferPointer<UInt8>) throws(E) -> ResultType) throws(E) -> ResultType? where E : Error, ResultType : ~Copyable

Executes a closure on the sequence’s contiguous storage. This method calls `body(buffer)`, where `buffer` is a pointer to the collection’s contiguous storage. If the contiguous storage doesn't exist, the collection creates it. If the collection doesn’t support an internal representation in a form of contiguous storage, the method doesn’t call `body` --- it immediately returns `nil`. The optimizer can often eliminate bounds- and uniqueness-checking within an algorithm. When that fails, however, invoking the same algorithm on the `buffer` argument may let you trade safety for speed. Successive calls to this method may provide a different pointer on each call. Don't store `buffer` outside of this method. A `Collection` that provides its own implementation of this method must provide contiguous storage to its elements in the same order as they appear in the collection. This guarantees that it's possible to generate contiguous mutable storage to any of its subsequences by slicing `buffer` with a range formed from the distances to the subsequence's `startIndex` and `endIndex`, respectively. - Parameters: - body: A closure that receives an `UnsafeBufferPointer` to the sequence's contiguous storage. - Returns: The value returned from `body`, unless the sequence doesn't support contiguous storage, in which case the method ignores `body` and returns `nil`.

init

static initBytesCount(bytes: SDKHandle, count: number): ArrayBuffer

init(bytes: UnsafeRawPointer, count: Int)

Creates data with copied memory content. - parameter bytes: A pointer to the memory. It will be copied. - parameter count: The number of bytes to copy.

init

static initBytes(bytes: Array<number>): ArrayBuffer

init(bytes: Array<UInt8>)

init

static initBytes10398(bytes: SDKHandle): ArrayBuffer

init(bytes: ArraySlice<UInt8>)

init

static initBytes81986(elements: Array<number>): ArrayBuffer

init<S>(bytes elements: S) where S : Sequence, S.Element == UInt8

init

static initCount(count: number): ArrayBuffer

init(count: Int)

Creates a new data buffer with the specified count of zeroed bytes. - parameter count: The number of bytes the data initially contains.

count

get count(): number

var count: Int { get set }

The number of bytes in the data.

count

set count(value: number)

var count: Int { get set }

The number of bytes in the data.

index

indexAfter(i: number): number

func index(after i: Data.Index) -> Data.Index

Returns the index that immediately follows the specified index.

index

indexBefore(i: number): number

func index(before i: Data.Index) -> Data.Index

Returns the index that immediately precedes the specified index.

range

range(dataToFind: ArrayBuffer, options?: NSData_SearchOptions, range?: (SDKHandle) | null): (SDKHandle) | null

func range(of dataToFind: Data, options: Data.SearchOptions = [], in range: Range<Data.Index>? = nil) -> Range<Data.Index>?

Find the given `Data` in the content of this `Data`. - parameter dataToFind: The data to be searched for. - parameter options: Options for the search. Default value is `[]`. - parameter range: The range of this data in which to perform the search. Default value is `nil`, which means the entire content of this data. - returns: A `Range` specifying the location of the found data, or nil if a match could not be found. - precondition: `range` must be in the bounds of the Data.

write

write(url: string, options?: NSData_WritingOptions): void

func write(to url: URL, options: Data.WritingOptions = []) throws

Writes the contents of the data buffer to a location. - parameter url: The location to write the data into. - parameter options: Options for writing the data. Default value is `[]`. - throws: An error in the Cocoa domain, if there is an error writing to the `URL`.

append

appendCount(bytes: SDKHandle, count: number): void

mutating func append(_ bytes: UnsafePointer<UInt8>, count: Int)

Appends the specified bytes from memory to the end of the data.

append

append(other: ArrayBuffer): void

mutating func append(_ other: Data)

Appends the specified data to the end of this data.

append

append95897(buffer: unknown[]): void

mutating func append<SourceType>(_ buffer: UnsafeBufferPointer<SourceType>)

Append a buffer of bytes to the data. - parameter buffer: The buffer of bytes to append. The size is calculated from `SourceType` and `buffer.count`.

append

append88050(byte: number): void

mutating func append(_ byte: UInt8)

Adds an element to the end of the collection. If the collection does not have sufficient capacity for another element, additional storage is allocated before appending `newElement`. The following example adds a new number to an array of integers: var numbers = [1, 2, 3, 4, 5] numbers.append(100) print(numbers) // Prints "[1, 2, 3, 4, 5, 100]" - Parameter newElement: The element to append to the collection. - Complexity: O(1) on average, over many calls to `append(_:)` on the same collection.

init

static initBuffer(buffer: unknown[]): ArrayBuffer

init<SourceType>(buffer: UnsafeBufferPointer<SourceType>)

Creates a data buffer with copied memory content using a buffer pointer. - parameter buffer: A buffer pointer to copy. The size is calculated from `SourceType` and `buffer.count`.

init

static initBuffer96513(buffer: unknown[]): ArrayBuffer

init<SourceType>(buffer: UnsafeMutableBufferPointer<SourceType>)

Creates a data buffer with copied memory content using a mutable buffer pointer. - parameter buffer: A buffer pointer to copy. The size is calculated from `SourceType` and `buffer.count`.

insert

insert(newElement: number, i: number): void

mutating func insert(_ newElement: UInt8, at i: Data.Index)

Inserts a new element into the collection at the specified position. The new element is inserted before the element currently at the specified index. If you pass the collection's `endIndex` property as the `index` parameter, the new element is appended to the collection. var numbers = [1, 2, 3, 4, 5] numbers.insert(100, at: 3) numbers.insert(200, at: numbers.endIndex) print(numbers) // Prints "[1, 2, 3, 100, 4, 5, 200]" Calling this method may invalidate any existing indices for use with this collection. - Parameter newElement: The new element to insert into the collection. - Parameter i: The position at which to insert the new element. `index` must be a valid index into the collection. - Complexity: O(*n*), where *n* is the length of the collection. If `i == endIndex`, this method is equivalent to `append(_:)`.

remove

remove(position: number): number

@discardableResult mutating func remove(at position: Data.Index) -> UInt8

Removes and returns the element at the specified position. All the elements following the specified position are moved to close the gap. This example removes the middle element from an array of measurements. var measurements = [1.2, 1.5, 2.9, 1.2, 1.6] let removed = measurements.remove(at: 2) print(measurements) // Prints "[1.2, 1.5, 1.2, 1.6]" Calling this method may invalidate any existing indices for use with this collection. - Parameter i: The position of the element to remove. `index` must be a valid index of the collection that is not equal to the collection's end index. - Returns: The removed element. - Complexity: O(*n*), where *n* is the length of the collection.

indices

get indices(): SDKHandle

var indices: Range<Int> { get }

The indices that are valid for subscripting the collection, in ascending order. A collection's `indices` property can hold a strong reference to the collection itself, causing the collection to be nonuniquely referenced. If you mutate the collection while iterating over its indices, a strong reference can result in an unexpected copy of the collection. To avoid the unexpected copy, use the `index(after:)` method starting with `startIndex` to produce indices instead. var c = MyFancyCollection([10, 20, 30, 40, 50]) var i = c.startIndex while i != c.endIndex { c[i] /= 5 i = c.index(after: i) } // c == MyFancyCollection([2, 4, 6, 8, 10])

regions

get regions(): "count" | SDKHandle

var regions: CollectionOfOne<Data> { get }

A collection of buffers that make up the whole of the type conforming to a data protocol.

subdata

subdata(range: SDKHandle): ArrayBuffer

func subdata(in range: Range<Data.Index>) -> Data

Returns a new copy of the data in a specified range. - parameter range: The range to copy.

advanced

advanced(amount: number): ArrayBuffer

func advanced(by amount: Int) -> Data

Returns a new data buffer created by removing the given number of bytes from the front of the original data.

init

static initCapacity(capacity: number): ArrayBuffer

init(capacity: Int)

Creates an empty data buffer of a specified size. This initializer doesn't necessarily allocate the requested memory right away. `Data` allocates additional memory as needed, so `capacity` simply establishes the initial capacity. When it does allocate the initial memory, though, it allocates the specified amount. This method sets the `count` of the data to 0. If the capacity specified in `capacity` is greater than four memory pages in size, this may round the amount of requested memory up to the nearest full page. - parameter capacity: The size of the data.

endIndex

get endIndex(): number

var endIndex: Data.Index { get }

The end `Index` into the data. This is the "one-past-the-end" position—that is, the position one greater than the last valid subscript argument.

copyBytes

copyBytesToFrom(buffer: unknown[], range?: (SDKHandle) | null): number

func copyBytes<DestinationType>(to buffer: UnsafeMutableBufferPointer<DestinationType>, from range: Range<Data.Index>? = nil) -> Int

Copies the bytes in a range from the data into a buffer. This function copies the bytes in `range` from the data into the buffer. If the count of the `range` is greater than `MemoryLayout<DestinationType>.stride * buffer.count` then the first N bytes will be copied into the buffer. - precondition: The range must be within the bounds of the data. Otherwise `fatalError` is called. - parameter buffer: A buffer to copy the data into. - parameter range: A range in the data to copy into the buffer. If the range is empty, this function will return 0 without copying anything. If the range is nil, as much data as will fit into `buffer` is copied. - returns: Number of bytes copied into the destination buffer.

copyBytes

copyBytesToFrom40782(pointer: SDKHandle, range: SDKHandle): void

func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, from range: Range<Data.Index>)

Copies a subset of the contents of the data to memory. - parameter pointer: A pointer to the buffer you wish to copy the bytes into. - parameter range: The range in the `Data` to copy. - warning: This method does not verify that the contents at pointer have enough space to hold the required number of bytes.

copyBytes

copyBytesToCount(pointer: SDKHandle, count: number): void

func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, count: Int)

Copies the contents of the data to memory. - parameter pointer: A pointer to the buffer you wish to copy the bytes into. - parameter count: The number of bytes to copy. - warning: This method does not verify that the contents at pointer have enough space to hold `count` bytes.

removeAll

removeAll(keepCapacity?: boolean): void

mutating func removeAll(keepingCapacity keepCapacity: Bool = false)

Removes all elements from the collection. Calling this method may invalidate any existing indices for use with this collection. - Parameter keepCapacity: Pass `true` to request that the collection avoid releasing its storage. Retaining the collection's storage can be a useful optimization when you're planning to grow the collection again. The default value is `false`. - Complexity: O(*n*), where *n* is the length of the collection.

init

static initRepeatingCount(repeatedValue: number, count: number): ArrayBuffer

init(repeating repeatedValue: UInt8, count: Int)

Initialize a `Data` with a repeating byte pattern - parameter repeatedValue: A byte to initialize the pattern - parameter count: The number of bytes the data initially contains initialized to the repeatedValue

init

static init(): ArrayBuffer

init()

Creates an empty data buffer.

init

static init77651(data: ArrayBuffer): ArrayBuffer

init(_ data: Data)

subscript

subscript(bounds: SDKHandle): ArrayBuffer

subscript(bounds: Range<Data.Index>) -> Data { get set }

Accesses the bytes at the specified range of indexes.

subscript

subscript19965(rangeExpression: SDKHandle): ArrayBuffer

subscript<R>(rangeExpression: R) -> Data where R : RangeExpression, R.Bound : FixedWidthInteger { get set }

Accesses the bytes at the specified range of indexes.

subscript

subscript89005(index: number): number

subscript(index: Data.Index) -> UInt8 { get set }

Accesses the byte at the specified index.