1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright 2015 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.cmdline;
import com.google.common.collect.ComparisonChain;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.vfs.Canonicalizer;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.io.Serializable;
import javax.annotation.concurrent.Immutable;
/**
* Uniquely identifies a package, given a repository name and a package's path fragment.
*
* <p>The repository the build is happening in is the <i>default workspace</i>, and is identified
* by the workspace name "". Other repositories can be named in the WORKSPACE file. These
* workspaces are prefixed by {@literal @}.</p>
*/
@Immutable
public final class PackageIdentifier implements Comparable<PackageIdentifier>, Serializable {
private static final Interner<PackageIdentifier> INTERNER = Interners.newWeakInterner();
public static PackageIdentifier create(String repository, PathFragment pkgName)
throws LabelSyntaxException {
return create(RepositoryName.create(repository), pkgName);
}
public static PackageIdentifier create(RepositoryName repository, PathFragment pkgName) {
return INTERNER.intern(new PackageIdentifier(repository, pkgName));
}
public static final String DEFAULT_REPOSITORY = "";
public static final RepositoryName DEFAULT_REPOSITORY_NAME;
public static final RepositoryName MAIN_REPOSITORY_NAME;
static {
try {
DEFAULT_REPOSITORY_NAME = RepositoryName.create(DEFAULT_REPOSITORY);
MAIN_REPOSITORY_NAME = RepositoryName.create("@");
} catch (LabelSyntaxException e) {
throw new IllegalStateException(e);
}
}
public static PackageIdentifier createInMainRepo(String name) {
return createInMainRepo(new PathFragment(name));
}
public static PackageIdentifier createInMainRepo(PathFragment name) {
return create(MAIN_REPOSITORY_NAME, name);
}
/**
* The identifier for this repository. This is either "" or prefixed with an "@",
* e.g., "@myrepo".
*/
private final RepositoryName repository;
/** The name of the package. Canonical (i.e. x.equals(y) <=> x==y). */
private final PathFragment pkgName;
private PackageIdentifier(RepositoryName repository, PathFragment pkgName) {
this.repository = Preconditions.checkNotNull(repository);
this.pkgName = Canonicalizer.fragments().intern(
Preconditions.checkNotNull(pkgName).normalize());
}
public static PackageIdentifier parse(String input) throws LabelSyntaxException {
String repo;
String packageName;
int packageStartPos = input.indexOf("//");
if (input.startsWith("@") && packageStartPos > 0) {
repo = input.substring(0, packageStartPos);
packageName = input.substring(packageStartPos + 2);
} else if (input.startsWith("@")) {
throw new LabelSyntaxException("starts with a '@' but does not contain '//'");
} else if (packageStartPos == 0) {
repo = PackageIdentifier.DEFAULT_REPOSITORY;
packageName = input.substring(2);
} else {
repo = PackageIdentifier.DEFAULT_REPOSITORY;
packageName = input;
}
String error = RepositoryName.validate(repo);
if (error != null) {
throw new LabelSyntaxException(error);
}
error = LabelValidator.validatePackageName(packageName);
if (error != null) {
throw new LabelSyntaxException(error);
}
return create(repo, new PathFragment(packageName));
}
public RepositoryName getRepository() {
return repository;
}
public PathFragment getPackageFragment() {
return pkgName;
}
/**
* Returns a relative path that should be unique across all remote and packages, based on the
* repository and package names.
*/
public PathFragment getPathFragment() {
return repository.getPathFragment().getRelative(pkgName);
}
public PackageIdentifier makeAbsolute() {
if (!repository.isDefault()) {
return this;
}
return create(MAIN_REPOSITORY_NAME, pkgName);
}
/**
* Returns the name of this package.
*
* <p>There are certain places that expect the path fragment as the package name ('foo/bar') as a
* package identifier. This isn't specific enough for packages in other repositories, so their
* stringified version is '@baz//foo/bar'.</p>
*/
@Override
public String toString() {
return (repository.isDefault() || repository.isMain() ? "" : repository + "//") + pkgName;
}
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (!(object instanceof PackageIdentifier)) {
return false;
}
PackageIdentifier that = (PackageIdentifier) object;
return pkgName.equals(that.pkgName) && repository.equals(that.repository);
}
@Override
public int hashCode() {
return 31 * repository.hashCode() + pkgName.hashCode();
}
@Override
public int compareTo(PackageIdentifier that) {
return ComparisonChain.start()
.compare(repository.toString(), that.repository.toString())
.compare(pkgName, that.pkgName)
.result();
}
}
|
