//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import CDispatch
public struct DispatchData : RandomAccessCollection {
public typealias Iterator = DispatchDataIterator
public typealias Index = Int
public typealias Indices = DefaultRandomAccessIndices<DispatchData>
public static let empty: DispatchData = DispatchData(data: _swift_dispatch_data_empty())
#if false /* FIXME: dragging in _TMBO (Objective-C) */
public enum Deallocator {
/// Use `free`
case free
/// Use `munmap`
case unmap
/// A custom deallocator
case custom(DispatchQueue?, @convention(block) () -> Void)
private var _deallocator: (DispatchQueue?, @convention(block) () -> Void) {
switch self {
case .free: return (nil, _dispatch_data_destructor_free())
case .unmap: return (nil, _dispatch_data_destructor_munmap())
case .custom(let q, let b): return (q, b)
}
}
}
#endif
internal var __wrapped: dispatch_data_t
/// Initialize a `Data` with copied memory content.
///
/// - parameter bytes: A pointer to the memory. It will be copied.
/// - parameter count: The number of bytes to copy.
public init(bytes buffer: UnsafeBufferPointer<UInt8>) {
__wrapped = dispatch_data_create(
buffer.baseAddress!, buffer.count, nil, _dispatch_data_destructor_default())
}
#if false /* FIXME: dragging in _TMBO (Objective-C) */
/// Initialize a `Data` without copying the bytes.
///
/// - parameter bytes: A pointer to the bytes.
/// - parameter count: The size of the bytes.
/// - parameter deallocator: Specifies the mechanism to free the indicated buffer.
public init(bytesNoCopy bytes: UnsafeBufferPointer<UInt8>, deallocator: Deallocator = .free) {
let (q, b) = deallocator._deallocator
__wrapped = dispatch_data_create(bytes.baseAddress!, bytes.count, q?.__wrapped, b)
}
#endif
internal init(data: dispatch_data_t) {
__wrapped = data
}
public var count: Int {
return CDispatch.dispatch_data_get_size(__wrapped)
}
public func withUnsafeBytes<Result, ContentType>(
body: @noescape (UnsafePointer<ContentType>) throws -> Result) rethrows -> Result
{
var ptr: UnsafePointer<Void>? = nil
var size = 0;
let data = CDispatch.dispatch_data_create_map(__wrapped, &ptr, &size)
defer { _fixLifetime(data) }
return try body(UnsafePointer<ContentType>(ptr!))
}
public func enumerateBytes(
block: @noescape (buffer: UnsafeBufferPointer<UInt8>, byteIndex: Int, stop: inout Bool) -> Void)
{
_swift_dispatch_data_apply(__wrapped) { (data: dispatch_data_t, offset: Int, ptr: UnsafePointer<Void>, size: Int) in
let bp = UnsafeBufferPointer(start: UnsafePointer<UInt8>(ptr), count: size)
var stop = false
block(buffer: bp, byteIndex: offset, stop: &stop)
return !stop
}
}
/// Append bytes to the data.
///
/// - parameter bytes: A pointer to the bytes to copy in to the data.
/// - parameter count: The number of bytes to copy.
public mutating func append(_ bytes: UnsafePointer<UInt8>, count: Int) {
let data = dispatch_data_create(bytes, count, nil, _dispatch_data_destructor_default())
self.append(DispatchData(data: data))
}
/// Append data to the data.
///
/// - parameter data: The data to append to this data.
public mutating func append(_ other: DispatchData) {
let data = CDispatch.dispatch_data_create_concat(__wrapped, other.__wrapped)
__wrapped = data
}
/// 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`.
public mutating func append<SourceType>(_ buffer : UnsafeBufferPointer<SourceType>) {
self.append(UnsafePointer(buffer.baseAddress!), count: buffer.count * sizeof(SourceType.self))
}
private func _copyBytesHelper(to pointer: UnsafeMutablePointer<UInt8>, from range: CountableRange<Index>) {
var copiedCount = 0
_ = CDispatch.dispatch_data_apply(__wrapped) { (data: dispatch_data_t, offset: Int, ptr: UnsafePointer<Void>, size: Int) in
let limit = Swift.min((range.endIndex - range.startIndex) - copiedCount, size)
memcpy(pointer + copiedCount, ptr, limit)
copiedCount += limit
return copiedCount < (range.endIndex - range.startIndex)
}
}
/// Copy the contents of the data to a pointer.
///
/// - 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.
public func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, count: Int) {
_copyBytesHelper(to: pointer, from: 0..<count)
}
/// Copy a subset of the contents of the data to a pointer.
///
/// - 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.
public func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, from range: CountableRange<Index>) {
_copyBytesHelper(to: pointer, from: range)
}
/// Copy the contents of 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 `sizeof(DestinationType) * 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.
public func copyBytes<DestinationType>(to buffer: UnsafeMutableBufferPointer<DestinationType>, from range: CountableRange<Index>? = nil) -> Int {
let cnt = count
guard cnt > 0 else { return 0 }
let copyRange : CountableRange<Index>
if let r = range {
guard !r.isEmpty else { return 0 }
precondition(r.startIndex >= 0)
precondition(r.startIndex < cnt, "The range is outside the bounds of the data")
precondition(r.endIndex >= 0)
precondition(r.endIndex <= cnt, "The range is outside the bounds of the data")
copyRange = r.startIndex..<(r.startIndex + Swift.min(buffer.count * sizeof(DestinationType.self), r.count))
} else {
copyRange = 0..<Swift.min(buffer.count * sizeof(DestinationType.self), cnt)
}
guard !copyRange.isEmpty else { return 0 }
let pointer : UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8>(buffer.baseAddress!)
_copyBytesHelper(to: pointer, from: copyRange)
return copyRange.count
}
/// Sets or returns the byte at the specified index.
public subscript(index: Index) -> UInt8 {
var offset = 0
let subdata = CDispatch.dispatch_data_copy_region(__wrapped, index, &offset)
var ptr: UnsafePointer<Void>? = nil
var size = 0
let map = CDispatch.dispatch_data_create_map(subdata, &ptr, &size)
defer { _fixLifetime(map) }
let pptr = UnsafePointer<UInt8>(ptr!)
return pptr[index - offset]
}
public subscript(bounds: Range<Int>) -> RandomAccessSlice<DispatchData> {
return RandomAccessSlice(base: self, bounds: bounds)
}
/// Return a new copy of the data in a specified range.
///
/// - parameter range: The range to copy.
public func subdata(in range: CountableRange<Index>) -> DispatchData {
let subrange = CDispatch.dispatch_data_create_subrange(
__wrapped, range.startIndex, range.endIndex - range.startIndex)
return DispatchData(data: subrange)
}
public func region(location: Int) -> (data: DispatchData, offset: Int) {
var offset: Int = 0
let data = CDispatch.dispatch_data_copy_region(__wrapped, location, &offset)
return (DispatchData(data: data), offset)
}
public var startIndex: Index {
return 0
}
public var endIndex: Index {
return count
}
public func index(before i: Index) -> Index {
return i - 1
}
public func index(after i: Index) -> Index {
return i + 1
}
/// An iterator over the contents of the data.
///
/// The iterator will increment byte-by-byte.
public func makeIterator() -> DispatchData.Iterator {
return DispatchDataIterator(_data: self)
}
}
public struct DispatchDataIterator : IteratorProtocol, Sequence {
/// Create an iterator over the given DisaptchData
public init(_data: DispatchData) {
var ptr: UnsafePointer<Void>?
self._count = 0
self._data = CDispatch.dispatch_data_create_map(_data.__wrapped, &ptr, &self._count)
self._ptr = UnsafePointer(ptr!)
self._position = _data.startIndex
}
/// Advance to the next element and return it, or `nil` if no next
/// element exists.
///
/// - Precondition: No preceding call to `self.next()` has returned `nil`.
public mutating func next() -> DispatchData._Element? {
if _position == _count { return nil }
let element = _ptr[_position];
_position = _position + 1
return element
}
internal let _data: dispatch_data_t
internal var _ptr: UnsafePointer<UInt8>
internal var _count: Int
internal var _position: DispatchData.Index
}
typealias _swift_data_applier = @convention(block) @noescape (dispatch_data_t, Int, UnsafePointer<Void>, Int) -> Bool
@_silgen_name("_swift_dispatch_data_apply")
internal func _swift_dispatch_data_apply(_ data: dispatch_data_t, _ block: _swift_data_applier)
@_silgen_name("_swift_dispatch_data_empty")
internal func _swift_dispatch_data_empty() -> dispatch_data_t
@_silgen_name("_swift_dispatch_data_destructor_free")
internal func _dispatch_data_destructor_free() -> _DispatchBlock
@_silgen_name("_swift_dispatch_data_destructor_munmap")
internal func _dispatch_data_destructor_munmap() -> _DispatchBlock
@_silgen_name("_swift_dispatch_data_destructor_default")
internal func _dispatch_data_destructor_default() -> _DispatchBlock