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
|
/*******************************************************************************
* Copyright (c) 2007, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.equinox.internal.p2.metadata;
import java.util.ArrayList;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.Assert;
import org.eclipse.equinox.p2.metadata.IArtifactKey;
import org.eclipse.equinox.p2.metadata.Version;
import org.eclipse.equinox.p2.metadata.expression.IMemberProvider;
/**
* The concrete type for representing IArtifactKey's.
* <p>
* See {link IArtifact for a description of the lifecycle of artifact keys)
*/
public class ArtifactKey implements IArtifactKey, IMemberProvider {
private static final String SEPARATOR = ","; //$NON-NLS-1$
public static final String MEMBER_ID = "id"; //$NON-NLS-1$
public static final String MEMBER_CLASSIFIER = "classifier"; //$NON-NLS-1$
public static final String MEMBER_VERSION = "version"; //$NON-NLS-1$
private final String id;
private final String classifier;
private final Version version;
private static String[] getArrayFromList(String stringList, String separator) {
if (stringList == null || stringList.trim().length() == 0)
return new String[0];
ArrayList<String> list = new ArrayList<String>();
boolean separatorSeen = true;
StringTokenizer tokens = new StringTokenizer(stringList, separator, true);
while (tokens.hasMoreTokens()) {
String token = tokens.nextToken().trim();
if (token.equals(separator)) {
if (separatorSeen)
list.add(""); //$NON-NLS-1$
separatorSeen = true;
} else {
separatorSeen = false;
if (token.length() != 0)
list.add(token);
}
}
if (separatorSeen)
list.add(""); //$NON-NLS-1$
return list.toArray(new String[list.size()]);
}
public static IArtifactKey parse(String specification) {
String[] parts = getArrayFromList(specification, SEPARATOR);
if (parts.length < 2 || parts.length > 3)
throw new IllegalArgumentException("Unexpected number of parts in artifact key: " + specification); //$NON-NLS-1$
Version version = Version.emptyVersion;
if (parts.length == 3 && parts[2].trim().length() > 0)
version = Version.parseVersion(parts[2]);
try {
return new ArtifactKey(parts[0], parts[1], version);
} catch (IllegalArgumentException e) {
throw (IllegalArgumentException) new IllegalArgumentException("Wrong version syntax in artifact key: " + specification).initCause(e); //$NON-NLS-1$
}
}
public ArtifactKey(String classifier, String id, Version version) {
super();
Assert.isNotNull(classifier);
Assert.isNotNull(id);
Assert.isNotNull(version);
if (classifier.indexOf(SEPARATOR) != -1)
throw new IllegalArgumentException("comma not allowed in classifier"); //$NON-NLS-1$
if (id.indexOf(SEPARATOR) != -1)
throw new IllegalArgumentException("comma not allowed in id"); //$NON-NLS-1$
this.classifier = classifier;
this.id = id;
this.version = version;
}
public ArtifactKey(IArtifactKey artifactKey) {
this.classifier = artifactKey.getClassifier();
this.id = artifactKey.getId();
this.version = artifactKey.getVersion();
}
public String getClassifier() {
return classifier;
}
public Version getVersion() {
return version;
}
public int hashCode() {
int hash = id.hashCode();
hash = 17 * hash + getVersion().hashCode();
hash = 17 * hash + classifier.hashCode();
return hash;
}
public String toString() {
return classifier + SEPARATOR + id + SEPARATOR + getVersion();
}
public boolean equals(Object obj) {
if (!(obj instanceof IArtifactKey))
return false;
IArtifactKey ak = (IArtifactKey) obj;
return ak.getId().equals(id) && ak.getVersion().equals(getVersion()) && ak.getClassifier().equals(classifier);
}
public String getId() {
return id;
}
public String toExternalForm() {
StringBuffer data = new StringBuffer(classifier).append(SEPARATOR);
data.append(id).append(SEPARATOR);
data.append(version.toString());
return data.toString();
}
public Object getMember(String memberName) {
// It is OK to use identity comparisons here since
// a) All constant valued strings are always interned
// b) The Member constructor always interns the name
//
if (MEMBER_ID == memberName)
return id;
if (MEMBER_VERSION == memberName)
return version;
if (MEMBER_CLASSIFIER == memberName)
return classifier;
throw new IllegalArgumentException("No such member: " + memberName); //$NON-NLS-1$
}
}
|
