swift-mirror/stdlib/public/core/CollectionOfOne.swift

//===--- CollectionOfOne.swift - A Collection with one element ------------===//
//
// 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 https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

/// An iterator that produces one or fewer instances of `Element`.
public struct IteratorOverOne<Element> : IteratorProtocol, Sequence {
  /// Construct an instance that generates `_element!`, or an empty
  /// sequence if `_element == nil`.
  public // @testable
  init(_elements: Element?) {
    self._elements = _elements
  }

  /// Advances to the next element and returns it, or `nil` if no next element
  /// exists.
  ///
  /// Once `nil` has been returned, all subsequent calls return `nil`.
  ///
  /// - Precondition: `next()` has not been applied to a copy of `self`
  ///   since the copy was made.
  public mutating func next() -> Element? {
    let result = _elements
    _elements = nil
    return result
  }

  internal var _elements: Element?
}

/// A collection containing a single element of type `Element`.
public struct CollectionOfOne<Element>
  : MutableCollection, RandomAccessCollection {

  /// Creates an instance containing just `element`.
  public init(_ element: Element) {
    self._element = element
  }

  public typealias Index = Int

  /// The position of the first element.
  public var startIndex: Int {
    return 0
  }

  /// The "past the end" position---that is, the position one greater than the
  /// last valid subscript argument.
  ///
  /// In a `CollectionOfOne` instance, `endIndex` is always identical to
  /// `index(after: startIndex)`.
  public var endIndex: Int {
    return 1
  }
  
  /// Always returns `endIndex`.
  public func index(after i: Int) -> Int {
    _precondition(i == startIndex)
    return endIndex
  }

  /// Always returns `startIndex`.
  public func index(before i: Int) -> Int {
    _precondition(i == endIndex)
    return startIndex
  }

  public typealias Indices = CountableRange<Int>

  /// Returns an iterator over the elements of this sequence.
  ///
  /// - Complexity: O(1).
  public func makeIterator() -> IteratorOverOne<Element> {
    return IteratorOverOne(_elements: _element)
  }

  /// Accesses the element at `position`.
  ///
  /// - Precondition: `position == 0`.
  public subscript(position: Int) -> Element {
    get {
      _precondition(position == 0, "Index out of range")
      return _element
    }
    set {
      _precondition(position == 0, "Index out of range")
      _element = newValue
    }
  }

  public subscript(bounds: Range<Int>)
    -> MutableRandomAccessSlice<CollectionOfOne<Element>> {
    get {
      _failEarlyRangeCheck(bounds, bounds: startIndex..<endIndex)
      return MutableRandomAccessSlice(base: self, bounds: bounds)
    }
    set {
      _failEarlyRangeCheck(bounds, bounds: startIndex..<endIndex)
      _precondition(bounds.count == newValue.count,
        "CollectionOfOne can't be resized")
      if let newElement = newValue.first {
        _element = newElement
      }
    }
  }

  /// The number of elements (always one).
  public var count: Int {
    return 1
  }

  internal var _element: Element
}

extension CollectionOfOne : CustomDebugStringConvertible {
  /// A textual representation of `self`, suitable for debugging.
  public var debugDescription: String {
    return "CollectionOfOne(\(String(reflecting: _element)))"
  }
}

extension CollectionOfOne : CustomReflectable {
  public var customMirror: Mirror {
    return Mirror(self, children: ["element": _element])
  }
}

@available(*, unavailable, renamed: "IteratorOverOne")
public struct GeneratorOfOne<Element> {}

extension IteratorOverOne {
  @available(*, unavailable, renamed: "makeIterator()")
  public func generate() -> IteratorOverOne<Element> {
    Builtin.unreachable()
  }
}