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

%# -*- mode: 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.  UnsafeArray is both a
/// Collection (which is multi-pass if you use indices or call
/// generate() on it) and a Generator, 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 UnsafeArrayGenerator<T>: Generator, Sequence {
  @public mutating func next() -> T? {
    return position == end ? nil : (position++).memory
  }

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

%for Mutable in ('Mutable', ''):
@public struct Unsafe${Mutable}Array<T> : ${Mutable}Collection {

  @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: UnsafePointer<T>, length: Int) {
    _position = start
    _end = start + length
  }

  @public func generate() -> UnsafeArrayGenerator<T> {
    return UnsafeArrayGenerator(position: _position, end: _end)
  }
  
  var _position, _end: UnsafePointer<T>
}
%end