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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*******************************************************************************
* Copyright (c) 2008-2009 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
* EclipseSource - ongoing development
*******************************************************************************/
package org.eclipse.equinox.p2.tests;
import java.lang.ref.SoftReference;
import java.util.*;
import org.eclipse.equinox.internal.p2.metadata.InstallableUnit;
import org.eclipse.equinox.internal.provisional.p2.metadata.*;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.*;
import org.eclipse.equinox.p2.metadata.*;
import org.eclipse.equinox.p2.metadata.query.*;
public class IUPropertyUtils {
IQueryable queryable;
/**
*
*/
public IUPropertyUtils(IQueryable queryable) {
this.queryable = queryable;
}
// TODO: these constants should come from API, eg. IInstallableUnit or ???
final Locale DEFAULT_LOCALE = new Locale("df", "LT"); //$NON-NLS-1$//$NON-NLS-2$
final String NAMESPACE_IU_LOCALIZATION = "org.eclipse.equinox.p2.localization"; //$NON-NLS-1$
// Cache the IU fragments that provide localizations for a given locale.
// map: locale => soft reference to a QueryResult
private Map LocaleCollectorCache = new HashMap(2);
// Get the license in the default locale.
public ILicense[] getLicense(IInstallableUnit iu) {
return getLicenses(iu, getCurrentLocale());
}
// Get the copyright in the default locale.
public ICopyright getCopyright(IInstallableUnit iu) {
return getCopyright(iu, getCurrentLocale());
}
// Get a property in the default locale
public String getIUProperty(IInstallableUnit iu, String propertyKey) {
return getIUProperty(iu, propertyKey, getCurrentLocale());
}
public ILicense getLicense(IInstallableUnit iu, ILicense license, Locale locale) {
String body = (license != null ? license.getBody() : null);
if (body == null || body.length() <= 1 || body.charAt(0) != '%')
return license;
final String actualKey = body.substring(1); // Strip off the %
body = getLocalizedIUProperty(iu, actualKey, locale);
return MetadataFactory.createLicense(license.getLocation(), body);
}
public ILicense[] getLicenses(IInstallableUnit iu, Locale locale) {
ILicense[] licenses = iu.getLicenses();
ILicense[] translatedLicenses = new ILicense[licenses.length];
for (int i = 0; i < licenses.length; i++) {
translatedLicenses[i] = getLicense(iu, licenses[i], locale);
}
return translatedLicenses;
}
public ICopyright getCopyright(IInstallableUnit iu, Locale locale) {
ICopyright copyright = iu.getCopyright();
String body = (copyright != null ? copyright.getBody() : null);
if (body == null || body.length() <= 1 || body.charAt(0) != '%')
return copyright;
final String actualKey = body.substring(1); // Strip off the %
body = getLocalizedIUProperty(iu, actualKey, locale);
return MetadataFactory.createCopyright(copyright.getLocation(), body);
}
public String getIUProperty(IInstallableUnit iu, String propertyKey, Locale locale) {
String value = iu.getProperty(propertyKey);
if (value == null || value.length() <= 1 || value.charAt(0) != '%')
return value;
// else have a localizable property
final String actualKey = value.substring(1); // Strip off the %
return getLocalizedIUProperty(iu, actualKey, locale);
}
private String getLocalizedIUProperty(IInstallableUnit iu, String actualKey, Locale locale) {
String localizedKey = makeLocalizedKey(actualKey, locale.toString());
String localizedValue = null;
//first check for a cached localized value
if (iu instanceof InstallableUnit)
localizedValue = ((InstallableUnit) iu).getLocalizedProperty(localizedKey);
//next check if the localized value is stored in the same IU (common case)
if (localizedValue == null)
localizedValue = iu.getProperty(localizedKey);
if (localizedValue != null)
return localizedValue;
final List locales = buildLocaleVariants(locale);
final IInstallableUnit theUnit = iu;
IQueryResult localizationFragments = getLocalizationFragments(locale, locales);
MatchQuery hostLocalizationQuery = new MatchQuery() {
public boolean isMatch(Object object) {
boolean haveHost = false;
if (object instanceof IInstallableUnitFragment) {
IInstallableUnitFragment fragment = (IInstallableUnitFragment) object;
IRequirement[] hosts = fragment.getHost();
for (int i = 0; i < hosts.length; i++) {
if (theUnit.satisfies(hosts[i])) {
haveHost = true;
break;
}
}
}
return haveHost;
}
};
IQuery iuQuery = new PipedQuery(new IQuery[] {new FragmentQuery(), hostLocalizationQuery});
Collector collected = iuQuery.perform(localizationFragments.iterator(), new Collector());
if (!collected.isEmpty()) {
String translation = null;
for (Iterator iter = collected.iterator(); iter.hasNext() && translation == null;) {
IInstallableUnit localizationIU = (IInstallableUnit) iter.next();
for (Iterator jter = locales.iterator(); jter.hasNext();) {
String localeKey = makeLocalizedKey(actualKey, (String) jter.next());
translation = localizationIU.getProperty(localeKey);
if (translation != null)
return cacheResult(iu, localizedKey, translation);
}
}
}
for (Iterator iter = locales.iterator(); iter.hasNext();) {
String nextLocale = (String) iter.next();
String localeKey = makeLocalizedKey(actualKey, nextLocale);
String nextValue = iu.getProperty(localeKey);
if (nextValue != null)
return cacheResult(iu, localizedKey, nextValue);
}
return cacheResult(iu, localizedKey, actualKey);
}
/**
* Cache the translated property value to optimize future retrieval of the same value.
* Currently we just cache on the installable unit object in memory. In future
* we should push support for localized property retrieval into IInstallableUnit
* so we aren't required to reach around the API here.
*/
private String cacheResult(IInstallableUnit iu, String localizedKey, String localizedValue) {
if (iu instanceof InstallableUnit)
((InstallableUnit) iu).setLocalizedProperty(localizedKey, localizedValue);
return localizedValue;
}
/**
* Collects the installable unit fragments that contain locale data for the given locales.
*/
private synchronized IQueryResult getLocalizationFragments(Locale locale, List localeVariants) {
SoftReference queryResultRef = (SoftReference) LocaleCollectorCache.get(locale);
if (queryResultRef != null) {
Collector cached = (Collector) queryResultRef.get();
if (cached != null)
return cached;
}
final List locales = localeVariants;
MatchQuery localeFragmentQuery = new MatchQuery() {
public boolean isMatch(Object object) {
boolean haveLocale = false;
if (object instanceof IInstallableUnitFragment) {
IInstallableUnitFragment fragment = (IInstallableUnitFragment) object;
IProvidedCapability[] provides = fragment.getProvidedCapabilities();
for (int j = 0; j < provides.length && !haveLocale; j++) {
IProvidedCapability nextProvide = provides[j];
if (NAMESPACE_IU_LOCALIZATION.equals(nextProvide.getNamespace())) {
String providedLocale = nextProvide.getName();
if (providedLocale != null) {
for (Iterator iter = locales.iterator(); iter.hasNext();) {
if (providedLocale.equals(iter.next())) {
haveLocale = true;
break;
}
}
}
}
}
}
return haveLocale;
}
};
IQuery iuQuery = new PipedQuery(new IQuery[] {new FragmentQuery(), localeFragmentQuery});
IQueryResult collected = queryable.query(iuQuery, null);
LocaleCollectorCache.put(locale, new SoftReference(collected));
return collected;
}
/**
*/
private List buildLocaleVariants(Locale locale) {
String nl = locale.toString();
ArrayList result = new ArrayList(4);
int lastSeparator;
while (true) {
result.add(nl);
lastSeparator = nl.lastIndexOf('_');
if (lastSeparator == -1)
break;
nl = nl.substring(0, lastSeparator);
}
// Add the default locale (most general)
result.add(DEFAULT_LOCALE.toString());
return result;
}
private String makeLocalizedKey(String actualKey, String localeImage) {
return localeImage + '.' + actualKey;
}
private Locale getCurrentLocale() {
return Locale.getDefault();
}
}
|
