Files
swift-mirror/stdlib/core/EmptyCollection.swift
Arnold Schwaighofer da6d9152b6 Differentiate between user assertion and preconditions and the like
assert() and fatalError()
These functions are meant to be used in user code. They are enabled in debug
mode and disabled in release or fast mode.

_precondition() and _preconditionFailure()
These functions are meant to be used in library code to check preconditions at
the api boundry. They are enabled in debug mode (with a verbose message) and
release mode (trap). In fast mode they are disabled.

_debugPrecondition() and _debugPreconditionFailure()
These functions are meant to be used in library code to check preconditions that
are not neccesarily comprehensive for safety (UnsafePointer can be null or an
invalid pointer but we can't check both). They are enabled only in debug mode.

_sanityCheck() and _fatalError()
These are meant to be used for internal consistency checks. They are only
enabled when the library is build with -DSWIFT_STDLIB_INTERNAL_CHECKS=ON.

I modified the code in the standard library to the best of my judgement.

rdar://16477198

Swift SVN r18212
2014-05-16 20:49:54 +00:00

54 lines
1.5 KiB
Swift

//===--- EmptyCollection.swift - A collection with no elements ------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Sometimes an operation is best expressed in terms of some other,
// larger operation where one of the parameters is an empty
// collection. For example, we can erase elements from an Array by
// replacing a subrange with the empty collection.
//
//===----------------------------------------------------------------------===//
struct EmptyGenerator<T> : Generator, Sequence {
func generate() -> EmptyGenerator {
return self
}
mutating func next() -> T? {
return nil
}
}
struct EmptyCollection<T> : Collection {
typealias IndexType = Int
var startIndex: IndexType {
return 0
}
var endIndex: IndexType {
return 0
}
func generate() -> EmptyGenerator<T> {
return EmptyGenerator()
}
subscript(i: IndexType) -> T {
_preconditionFailure("Index out of range")
}
}
// Specialization of countElements for EmptyCollection<T>
func ~> <T>(x:EmptyCollection<T>, _:(_CountElements, ())) -> Int {
return 0
}