ManagedDependencies
A collection of managed dependencies.
final class ManagedDependenciesA collection of managed dependencies.
final class ManagedDependenciesimport Workspaceclass WorkspaceA workspace represents the state of a working project directory.
convenience init(fileSystem: FileSystem? = .none, environment: Environment = .current, forRootPackage packagePath: AbsolutePath, authorizationProvider: AuthorizationProvider? = .none, registryAuthorizationProvider: AuthorizationProvider? = .none, configuration: WorkspaceConfiguration? = .none, cancellator: Cancellator? = .none, initializationWarningHandler: ((String) -> Void)? = .none, customHostToolchain: UserToolchain? = .none, customManifestLoader: ManifestLoaderProtocol? = .none, customPackageContainerProvider: PackageContainerProvider? = .none, customRepositoryProvider: RepositoryProvider? = .none, delegate: Delegate? = .none) throws A convenience method for creating a workspace for the given root package path.
convenience init(fileSystem: any FileSystem, environment: Environment = .current, location: Location, authorizationProvider: (any AuthorizationProvider)? = .none, registryAuthorizationProvider: (any AuthorizationProvider)? = .none, configuration: WorkspaceConfiguration? = .none, cancellator: Cancellator? = .none, initializationWarningHandler: ((String) -> Void)? = .none, customHostToolchain: UserToolchain? = .none, customManifestLoader: (any ManifestLoaderProtocol)? = .none, customPackageContainerProvider: (any PackageContainerProvider)? = .none, customRepositoryProvider: (any RepositoryProvider)? = .none, delegate: Delegate? = .none) throws Create a new package workspace.
convenience init(fileSystem: FileSystem? = .none, forRootPackage packagePath: AbsolutePath, authorizationProvider: AuthorizationProvider? = .none, registryAuthorizationProvider: AuthorizationProvider? = .none, configuration: WorkspaceConfiguration? = .none, cancellator: Cancellator? = .none, initializationWarningHandler: ((String) -> Void)? = .none, customHostToolchain: UserToolchain, customPackageContainerProvider: PackageContainerProvider? = .none, customRepositoryProvider: RepositoryProvider? = .none, delegate: Delegate? = .none) throws A convenience method for creating a workspace for the given root package path.
static func _init(fileSystem: FileSystem, environment: Environment, location: Location, authorizationProvider: AuthorizationProvider? = .none, registryAuthorizationProvider: AuthorizationProvider? = .none, configuration: WorkspaceConfiguration? = .none, cancellator: Cancellator? = .none, initializationWarningHandler: ((String) -> Void)? = .none, customRegistriesConfiguration: RegistryConfiguration? = .none, customFingerprints: PackageFingerprintStorage? = .none, customSigningEntities: PackageSigningEntityStorage? = .none, skipSignatureValidation: Bool = false, customMirrors: DependencyMirrors? = .none, customToolsVersion: ToolsVersion? = .none, customHostToolchain: UserToolchain? = .none, customManifestLoader: ManifestLoaderProtocol? = .none, customPackageContainerProvider: PackageContainerProvider? = .none, customRepositoryManager: RepositoryManager? = .none, customRepositoryProvider: RepositoryProvider? = .none, customRegistryClient: RegistryClient? = .none, customBinaryArtifactsManager: CustomBinaryArtifactsManager? = .none, customIdentityResolver: IdentityResolver? = .none, customDependencyMapper: DependencyMapper? = .none, customChecksumAlgorithm: HashAlgorithm? = .none, delegate: Delegate? = .none) throws -> Workspace Initializer for testing purposes only. Use non underscored initializers instead.
static func format(workspaceResolveReason reason: WorkspaceResolveReason) -> String static func migrateMirrorsConfiguration(from legacyPath: AbsolutePath, to newPath: AbsolutePath, observabilityScope: ObservabilityScope) throws -> AbsolutePath let fileSystem: any FileSystemThe file system on which the workspace will operate.
let location: LocationThe workspace location.
let pinsStore: LoadableResult<PinsStore>The Pins store. The pins file will be created when first pin is added to pins store.
let state: WorkspaceStateThe current persisted state of the workspace.
func acceptIdentityChange(package: PackageIdentity, version: Version, signingEntity: SigningEntity, origin: SigningEntity.Origin, observabilityScope: ObservabilityScope, callbackQueue: DispatchQueue, completion: @escaping (Result<Void, Error>) -> Void) func cancelActiveResolverOperation() Cancel the active dependency resolution operation.
func clean(observabilityScope: ObservabilityScope) Cleans the build artifacts from workspace data.
func edit(packageName: String, path: AbsolutePath? = nil, revision: Revision? = nil, checkoutBranch: String? = nil, observabilityScope: ObservabilityScope) Puts a dependency in edit mode creating a checkout in editables directory.
func getContainer(for package: PackageReference, updateStrategy: ContainerUpdateStrategy, observabilityScope: ObservabilityScope, on queue: DispatchQueue, completion: @escaping (Result<any PackageContainer, any Swift.Error>) -> Void) func interpreterFlags(for packagePath: AbsolutePath) -> [String] Returns manifest interpreter flags for a package.
func loadDependencyManifests(root: PackageGraphRoot, automaticallyAddManagedDependencies: Bool = false, observabilityScope: ObservabilityScope) throws -> DependencyManifests Load the manifests for the current dependency tree.
func loadPackage(with identity: PackageIdentity, packageGraph: ModulesGraph, observabilityScope: ObservabilityScope) async throws -> Package func loadPackage(with identity: PackageIdentity, packageGraph: ModulesGraph, observabilityScope: ObservabilityScope, completion: @escaping (Result<Package, Error>) -> Void) Loads a single package in the context of a previously loaded graph. This can be useful for incremental loading in a longer-lived program, like an IDE.
@discardableResult func loadPackageGraph(rootInput root: PackageGraphRootInput, explicitProduct: String? = nil, forceResolvedVersions: Bool = false, customXCTestMinimumDeploymentTargets: [PackageModel.Platform : PlatformVersion]? = .none, testEntryPointPath: AbsolutePath? = nil, expectedSigningEntities: [PackageIdentity : RegistryReleaseMetadata.SigningEntity] = [:], observabilityScope: ObservabilityScope) throws -> ModulesGraph @discardableResult func loadPackageGraph(rootPath: AbsolutePath, explicitProduct: String? = nil, observabilityScope: ObservabilityScope) throws -> ModulesGraph func loadPluginImports(packageGraph: ModulesGraph) async throws -> [PackageIdentity : [String : [String]]] func loadRootManifest(at path: AbsolutePath, observabilityScope: ObservabilityScope) async throws -> Manifest Loads and returns manifest at the given path.
func loadRootManifest(at path: AbsolutePath, observabilityScope: ObservabilityScope, completion: @escaping (Result<Manifest, Error>) -> Void) Loads and returns manifest at the given path.
func loadRootManifests(packages: [AbsolutePath], observabilityScope: ObservabilityScope) async throws -> [AbsolutePath : Manifest] Loads and returns manifests at the given paths.
func loadRootManifests(packages: [AbsolutePath], observabilityScope: ObservabilityScope, completion: @escaping (Result<[AbsolutePath : Manifest], Error>) -> Void) Loads and returns manifests at the given paths.
func loadRootPackage(at path: AbsolutePath, observabilityScope: ObservabilityScope) async throws -> Package Loads root package
func loadRootPackage(at path: AbsolutePath, observabilityScope: ObservabilityScope, completion: @escaping (Result<Package, Error>) -> Void) Loads root package
func path(to dependency: Workspace.ManagedDependency) -> AbsolutePath Returns the location of the dependency.
func precomputeResolution(root: PackageGraphRoot, dependencyManifests: DependencyManifests, pinsStore: PinsStore, constraints: [PackageContainerConstraint], observabilityScope: ObservabilityScope) throws -> ResolutionPrecomputationResult Computes if dependency resolution is required based on input constraints and pins.
func purgeCache(observabilityScope: ObservabilityScope) Cleans the build artifacts from workspace data.
func reset(observabilityScope: ObservabilityScope) Resets the entire workspace by removing the data directory.
func resetState() throws func resolve(packageName: String, root: PackageGraphRootInput, version: Version? = nil, branch: String? = nil, revision: String? = nil, observabilityScope: ObservabilityScope) throws Resolve a package at the given state.
func resolve(root: PackageGraphRootInput, explicitProduct: String? = .none, forceResolution: Bool = false, forceResolvedVersions: Bool = false, observabilityScope: ObservabilityScope) throws Perform dependency resolution if needed.
func resolveBasedOnResolvedVersionsFile(root: PackageGraphRootInput, observabilityScope: ObservabilityScope) throws Resolves the dependencies according to the entries present in the Package.resolved file.
func unedit(packageName: String, forceRemove: Bool, root: PackageGraphRootInput, observabilityScope: ObservabilityScope) throws Ends the edit mode of an edited dependency.
@discardableResult func updateDependencies(root: PackageGraphRootInput, packages: [String] = [], dryRun: Bool = false, observabilityScope: ObservabilityScope) throws -> [(PackageReference, Workspace.PackageStateChange)]? Updates the current dependencies.
func watchResolvedFile() throws Watch the Package.resolved for changes.
struct BinaryArtifactsManagerfinal class ConfigurationManages a package workspace’s configuration.
struct CustomBinaryArtifactsManagerstruct DefaultLocationsWorkspace default locations utilities
struct DependencyManifestsA struct representing all the current manifests (root + external) in a package graph.
struct LocationWorkspace location configuration
struct ManagedArtifactA downloaded artifact managed by the workspace.
final class ManagedArtifactsA collection of managed artifacts which have been downloaded.
struct ManagedDependencyAn individual managed dependency.
enum PackageStateChangeThis enum represents state of an external package.
enum ResolutionPrecomputationResultenum SigningErrortypealias Delegate = WorkspaceDelegateprotocol Collection<Element> : SequenceA sequence whose elements can be traversed multiple times, nondestructively, and accessed by an indexed subscript.
protocol CopyableA type whose values can be implicitly or explicitly copied.
protocol CustomStringConvertibleA type with a customized textual representation.
protocol Escapableprotocol Sequence<Element>A type that provides sequential, iterated access to its elements.
var description: String { get }var endIndex: Index { get }var startIndex: Index { get }subscript(index: Index) -> Element { get } subscript(identity: PackageIdentity) -> ManagedDependency? { get } subscript(comparingLocation package: PackageReference) -> ManagedDependency? { get } func add(_ dependency: ManagedDependency) func index(after index: Index) -> Index func remove(_ identity: PackageIdentity) typealias Element = Workspace.ManagedDependencytypealias Index = Dictionary<PackageIdentity, Workspace.ManagedDependency>.Indexvar count: Int { get }The number of elements in the collection.
var first: Self.Element? { get }The first element of the collection.
var indices: DefaultIndices<Self> { get }The indices that are valid for subscripting the collection, in ascending order.
var isEmpty: Bool { get }A Boolean value indicating whether the collection is empty.
var lazy: LazySequence<Self> { get }A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.
var underestimatedCount: Int { get }A value less than or equal to the number of elements in the collection.
subscript<R>(r: R) -> Self.SubSequence where R : RangeExpression, Self.Index == R.Bound { get } Accesses the contiguous subrange of the collection’s elements specified by a range expression.
subscript(x: (UnboundedRange_) -> ()) -> Self.SubSequence { get } subscript(subranges: RangeSet<Self.Index>) -> DiscontiguousSlice<Self> { get } Accesses a view of this collection with the elements at the given indices.
subscript(bounds: Range<Self.Index>) -> Slice<Self> { get } Accesses a contiguous subrange of the collection’s elements.
func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
func compactMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.
func compare<Comparator>(_ lhs: Comparator.Compared, _ rhs: Comparator.Compared) -> ComparisonResult where Comparator : SortComparator, Comparator == Self.Element If lhs is ordered before rhs in the ordering described by the given sequence of SortComparators
func contains(_ element: Self.Element) -> Bool Returns a Boolean value indicating whether the sequence contains the given element.
func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
func count<E>(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error Returns the number of elements in the sequence that satisfy the given predicate.
func distance(from start: Self.Index, to end: Self.Index) -> Int Returns the distance between two indices.
func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence by skipping elements while predicate returns true and returning the remaining elements.
func dropFirst(_ k: Int = 1) -> Self.SubSequence Returns a subsequence containing all but the given number of initial elements.
func dropLast(_ k: Int = 1) -> Self.SubSequence Returns a subsequence containing all but the specified number of final elements.
func elementsEqual<OtherSequence>(_ other: OtherSequence) -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.
func elementsEqual<OtherSequence>(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.
func enumerated() -> EnumeratedSequence<Self> Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.
func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element] Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
func filter(_ predicate: Predicate<Self.Element>) throws -> [Self.Element] func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the first element of the sequence that satisfies the given predicate.
func firstIndex(of element: Self.Element) -> Self.Index? Returns the first index where the specified value appears in the collection.
func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index? Returns the first index in which an element of the collection satisfies the given predicate.
func firstRange<C>(of other: C) -> Range<Self.Index>? where C : Collection, Self.Element == C.Element Finds and returns the range of the first occurrence of a given collection within this collection.
func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.
func forEach(_ body: (Self.Element) throws -> Void) rethrows Calls the given closure on each element in the sequence in the same order as a for-in loop.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int) Offsets the given index by the specified distance.
func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool Offsets the given index by the specified distance, or so that it equals the given limiting index.
func formIndex(after i: inout Self.Index) Replaces the given index with its successor.
func formatted<S>(_ style: S) -> S.FormatOutput where Self == S.FormatInput, S : FormatStyle func index(_ i: Self.Index, offsetBy distance: Int) -> Self.Index Returns an index that is the specified distance from the given index.
func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index? Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.
func indices(of element: Self.Element) -> RangeSet<Self.Index> Returns the indices of all the elements that are equal to the given element.
func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet<Self.Index> Returns the indices of all the elements that match the given predicate.
func lexicographicallyPrecedes<OtherSequence>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.
func makeIterator() -> IndexingIterator<Self> Returns an iterator over the elements of the collection.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error Returns an array containing the results of mapping the given closure over the sequence’s elements.
func map<T, E>(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error Returns an array containing the results of mapping the given closure over the sequence’s elements.
@warn_unqualified_access func max(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the maximum element in the sequence, using the given predicate as the comparison between elements.
@warn_unqualified_access func min(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Self.Element? Returns the minimum element in the sequence, using the given predicate as the comparison between elements.
func prefix(_ maxLength: Int) -> Self.SubSequence Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.
func prefix(through position: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection through the specified position.
func prefix(upTo end: Self.Index) -> Self.SubSequence Returns a subsequence from the start of the collection up to, but not including, the specified position.
func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence Returns a subsequence containing the initial elements until predicate returns false and skipping the remaining elements.
func randomElement() -> Self.Element? Returns a random element of the collection.
func randomElement<T>(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator Returns a random element of the collection, using the given generator as a source for randomness.
func ranges<C>(of other: C) -> [Range<Self.Index>] where C : Collection, Self.Element == C.Element Finds and returns the ranges of the all occurrences of a given sequence within the collection.
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func reduce<Result>(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result Returns the result of combining the elements of the sequence using the given closure.
func removingSubranges(_ subranges: RangeSet<Self.Index>) -> DiscontiguousSlice<Self> Returns a collection of the elements in this collection that are not represented by the given range set.
func reversed() -> [Self.Element] Returns an array containing the elements of this sequence in reverse order.
func shuffled() -> [Self.Element] Returns the elements of the sequence, shuffled.
func shuffled<T>(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator Returns the elements of the sequence, shuffled using the given generator as a source for randomness.
func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element] Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.
func sorted<Comparator>(using comparator: Comparator) -> [Self.Element] where Comparator : SortComparator, Self.Element == Comparator.Compared Returns the elements of the sequence, sorted using the given comparator to compare elements.
func sorted<S, Comparator>(using comparators: S) -> [Self.Element] where S : Sequence, Comparator : SortComparator, Comparator == S.Element, Self.Element == Comparator.Compared Returns the elements of the sequence, sorted using the given array of SortComparators to compare elements.
func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence] Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.
func split(separator: Self.Element, maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true) -> [Self.SubSequence] Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, Self.Element == PossiblePrefix.Element Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.
func suffix(_ maxLength: Int) -> Self.SubSequence Returns a subsequence, up to the given maximum length, containing the final elements of the collection.
func suffix(from start: Self.Index) -> Self.SubSequence Returns a subsequence from the specified position to the end of the collection.
func trimmingPrefix<Prefix>(_ prefix: Prefix) -> Self.SubSequence where Prefix : Sequence, Self.Element == Prefix.Element Returns a new collection of the same type by removing prefix from the start of the collection.
func trimmingPrefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R? func flatMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] func index(of element: Self.Element) -> Self.Index? Returns the first index where the specified value appears in the collection.