swift-mirror/stdlib/core/UnsafeBufferPointer.swift.gyb

//===--- UnsafeBufferPointer.swift.gyb ------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 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
//
//===----------------------------------------------------------------------===//

/// Wrapper for a contiguous array of T.  UnsafeBufferPointer is both a
/// CollectionType (which is multi-pass if you use indices or call
/// generate() on it) and a GeneratorType, which can only be assumed to be
/// single-pass.  It's not clear how well this combination will work
/// out, or whether all Collections should also be Streams; consider
/// this an experiment.

public struct UnsafeBufferPointerGenerator<T>: GeneratorType, SequenceType {
  public mutating func next() -> T? {
    return position == end ? nil : (position++).memory
  }

  public func generate() -> UnsafeBufferPointerGenerator {
    return self
  }
  
  var position, end: UnsafePointer<T>
}

%for Mutable in ('Mutable', ''):
public struct Unsafe${Mutable}BufferPointer<T> : ${Mutable}CollectionType {

  public var startIndex: Int {
    return 0
  }

  public var endIndex: Int {
    return _end - _position
  }

  public subscript(i: Int) -> T {
    get {
      _debugPrecondition(i >= 0)
      _debugPrecondition(i < endIndex)
      return _position[i]
    }
%if Mutable:
    set {
      _debugPrecondition(i >= 0)
      _debugPrecondition(i < endIndex)
      _position[i] = newValue
    }
%end    
  }
  
  public init(start: Unsafe${Mutable}Pointer<T>, length: Int) {
    _precondition(
      length >= 0, "Unsafe${Mutable}BufferPointer with negative length")
    _position = start
    _end = start + length
  }

  public func generate() -> UnsafeBufferPointerGenerator<T> {
    return UnsafeBufferPointerGenerator(position: _position, end: _end)
  }

  public var baseAddress: Unsafe${Mutable}Pointer<T> {
    return _position
  }
  
  var _position, _end: Unsafe${Mutable}Pointer<T>
}

extension Unsafe${Mutable}BufferPointer : DebugPrintable {
  public var debugDescription: String {
    return "Unsafe${Mutable}BufferPointer"
    + "(start: \(_position), length: \(_end - _position))"
  }
}
%end

// ${'Local Variables'}:
// eval: (read-only-mode 1)
// End: