|
|||||||||||||||||||
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover | |||||||||||||||||||
Source file | Conditionals | Statements | Methods | TOTAL | |||||||||||||||
Specification.java | 0% | 0% | 0% | 0% |
|
1 |
/*
|
|
2 |
* Copyright (C) The Spice Group. All rights reserved.
|
|
3 |
*
|
|
4 |
* This software is published under the terms of the Spice
|
|
5 |
* Software License version 1.1, a copy of which has been included
|
|
6 |
* with this distribution in the LICENSE.txt file.
|
|
7 |
*/
|
|
8 |
package org.codehaus.spice.extension;
|
|
9 |
import java.text.ParseException;
|
|
10 |
import java.util.ArrayList;
|
|
11 |
import java.util.Arrays;
|
|
12 |
import java.util.Iterator;
|
|
13 |
import java.util.Map;
|
|
14 |
import java.util.jar.Attributes;
|
|
15 |
import java.util.jar.Manifest;
|
|
16 |
/**
|
|
17 |
* <p>Utility class that represents either an available "Optional Package"
|
|
18 |
* (formerly known as "Standard Extension") as described in the manifest
|
|
19 |
* of a JAR file, or the requirement for such an optional package.</p>
|
|
20 |
*
|
|
21 |
* <p>For more information about optional packages, see the document
|
|
22 |
* <em>Optional Package Versioning</em> in the documentation bundle for your
|
|
23 |
* Java2 Standard Edition package, in file
|
|
24 |
* <code>guide/extensions/versioning.html</code>.</p>
|
|
25 |
*
|
|
26 |
* @author <a href="mailto:peter at realityforge.org">Peter Donald</a>
|
|
27 |
* @version $Revision: 1.1 $ $Date: 2003/12/02 07:56:59 $
|
|
28 |
*/
|
|
29 |
public final class Specification |
|
30 |
{ |
|
31 |
/**
|
|
32 |
* Manifest Attribute Name object for SPECIFICATION_TITLE.
|
|
33 |
* @see Attributes.Name#SPECIFICATION_TITLE
|
|
34 |
*/
|
|
35 |
public static final Attributes.Name SPECIFICATION_TITLE = Attributes.Name.SPECIFICATION_TITLE; |
|
36 |
/**
|
|
37 |
* Manifest Attribute Name object for SPECIFICATION_VERSION.
|
|
38 |
* @see Attributes.Name#SPECIFICATION_VERSION
|
|
39 |
*/
|
|
40 |
public static final Attributes.Name SPECIFICATION_VERSION = Attributes.Name.SPECIFICATION_VERSION; |
|
41 |
/**
|
|
42 |
* Manifest Attribute Name object for SPECIFICATION_VENDOR.
|
|
43 |
* @see Attributes.Name#SPECIFICATION_VENDOR
|
|
44 |
*/
|
|
45 |
public static final Attributes.Name SPECIFICATION_VENDOR = Attributes.Name.SPECIFICATION_VENDOR; |
|
46 |
/**
|
|
47 |
* Manifest Attribute Name object for IMPLEMENTATION_TITLE.
|
|
48 |
* @see Attributes.Name#IMPLEMENTATION_TITLE
|
|
49 |
*/
|
|
50 |
public static final Attributes.Name IMPLEMENTATION_TITLE = Attributes.Name.IMPLEMENTATION_TITLE; |
|
51 |
/**
|
|
52 |
* Manifest Attribute Name object for IMPLEMENTATION_VERSION.
|
|
53 |
* @see Attributes.Name#IMPLEMENTATION_VERSION
|
|
54 |
*/
|
|
55 |
public static final Attributes.Name IMPLEMENTATION_VERSION = Attributes.Name.IMPLEMENTATION_VERSION; |
|
56 |
/**
|
|
57 |
* Manifest Attribute Name object for IMPLEMENTATION_VENDOR.
|
|
58 |
* @see Attributes.Name#IMPLEMENTATION_VENDOR
|
|
59 |
*/
|
|
60 |
public static final Attributes.Name IMPLEMENTATION_VENDOR = Attributes.Name.IMPLEMENTATION_VENDOR; |
|
61 |
/**
|
|
62 |
* Enum indicating that extension is compatible with other Package
|
|
63 |
* Specification.
|
|
64 |
*/
|
|
65 |
public static final Compatability COMPATIBLE = |
|
66 |
new Compatability( "COMPATIBLE" ); |
|
67 |
/**
|
|
68 |
* Enum indicating that extension requires an upgrade
|
|
69 |
* of specification to be compatible with other Package Specification.
|
|
70 |
*/
|
|
71 |
public static final Compatability REQUIRE_SPECIFICATION_UPGRADE = |
|
72 |
new Compatability( "REQUIRE_SPECIFICATION_UPGRADE" ); |
|
73 |
/**
|
|
74 |
* Enum indicating that extension requires a vendor
|
|
75 |
* switch to be compatible with other Package Specification.
|
|
76 |
*/
|
|
77 |
public static final Compatability REQUIRE_VENDOR_SWITCH = |
|
78 |
new Compatability( "REQUIRE_VENDOR_SWITCH" ); |
|
79 |
/**
|
|
80 |
* Enum indicating that extension requires an upgrade
|
|
81 |
* of implementation to be compatible with other Package Specification.
|
|
82 |
*/
|
|
83 |
public static final Compatability REQUIRE_IMPLEMENTATION_CHANGE = |
|
84 |
new Compatability( "REQUIRE_IMPLEMENTATION_CHANGE" ); |
|
85 |
/**
|
|
86 |
* Enum indicating that extension is incompatible with
|
|
87 |
* other Package Specification in ways other than other enums
|
|
88 |
* indicate). ie For example the other Package Specification
|
|
89 |
* may have a different ID.
|
|
90 |
*/
|
|
91 |
public static final Compatability INCOMPATIBLE = |
|
92 |
new Compatability( "INCOMPATIBLE" ); |
|
93 |
/**
|
|
94 |
* The name of the Package Specification.
|
|
95 |
*/
|
|
96 |
private String m_specificationTitle;
|
|
97 |
/**
|
|
98 |
* The version number (dotted decimal notation) of the specification
|
|
99 |
* to which this optional package conforms.
|
|
100 |
*/
|
|
101 |
private DeweyDecimal m_specificationVersion;
|
|
102 |
/**
|
|
103 |
* The name of the company or organization that originated the
|
|
104 |
* specification to which this specification conforms.
|
|
105 |
*/
|
|
106 |
private String m_specificationVendor;
|
|
107 |
/**
|
|
108 |
* The title of implementation.
|
|
109 |
*/
|
|
110 |
private String m_implementationTitle;
|
|
111 |
/**
|
|
112 |
* The name of the company or organization that produced this
|
|
113 |
* implementation of this specification.
|
|
114 |
*/
|
|
115 |
private String m_implementationVendor;
|
|
116 |
/**
|
|
117 |
* The version string for implementation. The version string is
|
|
118 |
* opaque.
|
|
119 |
*/
|
|
120 |
private String m_implementationVersion;
|
|
121 |
/**
|
|
122 |
* The sections of jar that the specification applies to.
|
|
123 |
*/
|
|
124 |
private String[] m_sections;
|
|
125 |
/**
|
|
126 |
* Return an array of <code>Package Specification</code> objects.
|
|
127 |
* If there are no such optional packages, a zero-length array is returned.
|
|
128 |
*
|
|
129 |
* @param manifest Manifest to be parsed
|
|
130 |
* @return the Package Specifications extensions in specified manifest
|
|
131 |
*/
|
|
132 | 0 |
public static Specification[] getSpecifications( final Manifest manifest ) |
133 |
throws ParseException
|
|
134 |
{ |
|
135 | 0 |
if( null == manifest ) |
136 |
{ |
|
137 | 0 |
return new Specification[ 0 ]; |
138 |
} |
|
139 | 0 |
final ArrayList results = new ArrayList();
|
140 | 0 |
final Map entries = manifest.getEntries(); |
141 | 0 |
final Iterator keys = entries.keySet().iterator(); |
142 | 0 |
while( keys.hasNext() )
|
143 |
{ |
|
144 | 0 |
final String key = (String)keys.next(); |
145 | 0 |
final Attributes attributes = (Attributes)entries.get( key ); |
146 | 0 |
final Specification specification = getSpecification( key, attributes ); |
147 | 0 |
if( null != specification ) |
148 |
{ |
|
149 | 0 |
results.add( specification ); |
150 |
} |
|
151 |
} |
|
152 | 0 |
final ArrayList trimmedResults = removeDuplicates( results ); |
153 | 0 |
return (Specification[])trimmedResults.toArray( new Specification[ 0 ] ); |
154 |
} |
|
155 |
/**
|
|
156 |
* The constructor to create Package Specification object.
|
|
157 |
* Note that every component is allowed to be specified
|
|
158 |
* but only the specificationTitle is mandatory.
|
|
159 |
*
|
|
160 |
* @param specificationTitle the name of specification.
|
|
161 |
* @param specificationVersion the specification Version.
|
|
162 |
* @param specificationVendor the specification Vendor.
|
|
163 |
* @param implementationTitle the title of implementation.
|
|
164 |
* @param implementationVersion the implementation Version.
|
|
165 |
* @param implementationVendor the implementation Vendor.
|
|
166 |
*/
|
|
167 | 0 |
public Specification( final String specificationTitle,
|
168 |
final String specificationVersion, |
|
169 |
final String specificationVendor, |
|
170 |
final String implementationTitle, |
|
171 |
final String implementationVersion, |
|
172 |
final String implementationVendor ) |
|
173 |
{ |
|
174 | 0 |
this( specificationTitle, specificationVersion, specificationVendor,
|
175 |
implementationTitle, implementationVersion, implementationVendor, |
|
176 |
null );
|
|
177 |
} |
|
178 |
/**
|
|
179 |
* The constructor to create Package Specification object.
|
|
180 |
* Note that every component is allowed to be specified
|
|
181 |
* but only the specificationTitle is mandatory.
|
|
182 |
*
|
|
183 |
* @param specificationTitle the name of specification.
|
|
184 |
* @param specificationVersion the specification Version.
|
|
185 |
* @param specificationVendor the specification Vendor.
|
|
186 |
* @param implementationTitle the title of implementation.
|
|
187 |
* @param implementationVersion the implementation Version.
|
|
188 |
* @param implementationVendor the implementation Vendor.
|
|
189 |
* @param sections the sections/packages that Specification applies to.
|
|
190 |
*/
|
|
191 | 0 |
public Specification( final String specificationTitle,
|
192 |
final String specificationVersion, |
|
193 |
final String specificationVendor, |
|
194 |
final String implementationTitle, |
|
195 |
final String implementationVersion, |
|
196 |
final String implementationVendor, |
|
197 |
final String[] sections ) |
|
198 |
{ |
|
199 | 0 |
if( null == specificationTitle ) |
200 |
{ |
|
201 | 0 |
throw new NullPointerException( "specificationTitle" ); |
202 |
} |
|
203 | 0 |
m_specificationTitle = specificationTitle; |
204 | 0 |
m_specificationVendor = specificationVendor; |
205 | 0 |
if( null != specificationVersion ) |
206 |
{ |
|
207 | 0 |
try
|
208 |
{ |
|
209 | 0 |
m_specificationVersion = new DeweyDecimal( specificationVersion );
|
210 |
} |
|
211 |
catch( final NumberFormatException nfe )
|
|
212 |
{ |
|
213 | 0 |
final String error = "Bad specification version format '" + specificationVersion +
|
214 |
"' in '" + specificationTitle + "'. (Reason: " + nfe + ")"; |
|
215 | 0 |
throw new IllegalArgumentException( error ); |
216 |
} |
|
217 |
} |
|
218 | 0 |
m_implementationTitle = implementationTitle; |
219 | 0 |
m_implementationVendor = implementationVendor; |
220 | 0 |
m_implementationVersion = implementationVersion; |
221 | 0 |
String[] copy = null;
|
222 | 0 |
if( null != sections ) |
223 |
{ |
|
224 | 0 |
copy = new String[ sections.length ];
|
225 | 0 |
System.arraycopy( sections, 0, copy, 0, sections.length ); |
226 |
} |
|
227 | 0 |
m_sections = copy; |
228 |
} |
|
229 |
/**
|
|
230 |
* Get the title of the specification.
|
|
231 |
*
|
|
232 |
* @return the title of speciication
|
|
233 |
*/
|
|
234 | 0 |
public String getSpecificationTitle()
|
235 |
{ |
|
236 | 0 |
return m_specificationTitle;
|
237 |
} |
|
238 |
/**
|
|
239 |
* Get the vendor of the specification.
|
|
240 |
*
|
|
241 |
* @return the vendor of the specification.
|
|
242 |
*/
|
|
243 | 0 |
public String getSpecificationVendor()
|
244 |
{ |
|
245 | 0 |
return m_specificationVendor;
|
246 |
} |
|
247 |
/**
|
|
248 |
* Get the title of the specification.
|
|
249 |
*
|
|
250 |
* @return the title of the specification.
|
|
251 |
*/
|
|
252 | 0 |
public String getImplementationTitle()
|
253 |
{ |
|
254 | 0 |
return m_implementationTitle;
|
255 |
} |
|
256 |
/**
|
|
257 |
* Get the version of the specification.
|
|
258 |
*
|
|
259 |
* @return the version of the specification.
|
|
260 |
*/
|
|
261 | 0 |
public DeweyDecimal getSpecificationVersion()
|
262 |
{ |
|
263 | 0 |
return m_specificationVersion;
|
264 |
} |
|
265 |
/**
|
|
266 |
* Get the vendor of the extensions implementation.
|
|
267 |
*
|
|
268 |
* @return the vendor of the extensions implementation.
|
|
269 |
*/
|
|
270 | 0 |
public String getImplementationVendor()
|
271 |
{ |
|
272 | 0 |
return m_implementationVendor;
|
273 |
} |
|
274 |
/**
|
|
275 |
* Get the version of the implementation.
|
|
276 |
*
|
|
277 |
* @return the version of the implementation.
|
|
278 |
*/
|
|
279 | 0 |
public String getImplementationVersion()
|
280 |
{ |
|
281 | 0 |
return m_implementationVersion;
|
282 |
} |
|
283 |
/**
|
|
284 |
* Return an array containing sections to which specification applies
|
|
285 |
* or null if relevant to no sections.
|
|
286 |
*
|
|
287 |
* @return an array containing sections to which specification applies
|
|
288 |
* or null if relevant to no sections.
|
|
289 |
*/
|
|
290 | 0 |
public String[] getSections()
|
291 |
{ |
|
292 | 0 |
if( null == m_sections ) |
293 |
{ |
|
294 | 0 |
return null; |
295 |
} |
|
296 |
else
|
|
297 |
{ |
|
298 | 0 |
final String[] sections = new String[ m_sections.length ];
|
299 | 0 |
System.arraycopy( m_sections, 0, sections, 0, m_sections.length ); |
300 | 0 |
return sections;
|
301 |
} |
|
302 |
} |
|
303 |
/**
|
|
304 |
* Return a Compatibility enum indicating the relationship of this
|
|
305 |
* <code>Package Specification</code> with the specified <code>Extension</code>.
|
|
306 |
*
|
|
307 |
* @param other the other specification
|
|
308 |
* @return the enum indicating the compatability (or lack thereof)
|
|
309 |
* of specifed Package Specification
|
|
310 |
*/
|
|
311 | 0 |
public Compatability getCompatibilityWith( final Specification other )
|
312 |
{ |
|
313 |
// Specification Name must match
|
|
314 | 0 |
if( !m_specificationTitle.equals( other.getSpecificationTitle() ) )
|
315 |
{ |
|
316 | 0 |
return INCOMPATIBLE;
|
317 |
} |
|
318 |
// Available specification version must be >= required
|
|
319 | 0 |
final DeweyDecimal specificationVersion = other.getSpecificationVersion(); |
320 | 0 |
if( null != specificationVersion ) |
321 |
{ |
|
322 | 0 |
if( null == m_specificationVersion || |
323 |
!isCompatible( m_specificationVersion, specificationVersion ) ) |
|
324 |
{ |
|
325 | 0 |
return REQUIRE_SPECIFICATION_UPGRADE;
|
326 |
} |
|
327 |
} |
|
328 |
// Implementation Vendor ID must match
|
|
329 | 0 |
final String implementationVendor = other.getImplementationVendor(); |
330 | 0 |
if( null != implementationVendor ) |
331 |
{ |
|
332 | 0 |
if( null == m_implementationVendor || |
333 |
!m_implementationVendor.equals( implementationVendor ) ) |
|
334 |
{ |
|
335 | 0 |
return REQUIRE_VENDOR_SWITCH;
|
336 |
} |
|
337 |
} |
|
338 |
// Implementation version must be >= required
|
|
339 | 0 |
final String implementationVersion = other.getImplementationVersion(); |
340 | 0 |
if( null != implementationVersion ) |
341 |
{ |
|
342 | 0 |
if( null == m_implementationVersion || |
343 |
!m_implementationVersion.equals( implementationVersion ) ) |
|
344 |
{ |
|
345 | 0 |
return REQUIRE_IMPLEMENTATION_CHANGE;
|
346 |
} |
|
347 |
} |
|
348 |
// This available optional package satisfies the requirements
|
|
349 | 0 |
return COMPATIBLE;
|
350 |
} |
|
351 |
/**
|
|
352 |
* Return <code>true</code> if the specified <code>package</code>
|
|
353 |
* is satisfied by this <code>Specification</code>. Otherwise, return
|
|
354 |
* <code>false</code>.
|
|
355 |
*
|
|
356 |
* @param other the specification
|
|
357 |
* @return true if the specification is compatible with this specification
|
|
358 |
*/
|
|
359 | 0 |
public boolean isCompatibleWith( final Specification other ) |
360 |
{ |
|
361 | 0 |
return ( COMPATIBLE == getCompatibilityWith( other ) );
|
362 |
} |
|
363 |
/**
|
|
364 |
* Return a String representation of this object.
|
|
365 |
*
|
|
366 |
* @return string representation of object.
|
|
367 |
*/
|
|
368 | 0 |
public String toString()
|
369 |
{ |
|
370 | 0 |
final String lineSeparator = System.getProperty( "line.separator" );
|
371 | 0 |
final String brace = ": ";
|
372 | 0 |
final StringBuffer sb = new StringBuffer( SPECIFICATION_TITLE.toString() );
|
373 | 0 |
sb.append( brace ); |
374 | 0 |
sb.append( m_specificationTitle ); |
375 | 0 |
sb.append( lineSeparator ); |
376 | 0 |
if( null != m_specificationVersion ) |
377 |
{ |
|
378 | 0 |
sb.append( SPECIFICATION_VERSION ); |
379 | 0 |
sb.append( brace ); |
380 | 0 |
sb.append( m_specificationVersion ); |
381 | 0 |
sb.append( lineSeparator ); |
382 |
} |
|
383 | 0 |
if( null != m_specificationVendor ) |
384 |
{ |
|
385 | 0 |
sb.append( SPECIFICATION_VENDOR ); |
386 | 0 |
sb.append( brace ); |
387 | 0 |
sb.append( m_specificationVendor ); |
388 | 0 |
sb.append( lineSeparator ); |
389 |
} |
|
390 | 0 |
if( null != m_implementationTitle ) |
391 |
{ |
|
392 | 0 |
sb.append( IMPLEMENTATION_TITLE ); |
393 | 0 |
sb.append( brace ); |
394 | 0 |
sb.append( m_implementationTitle ); |
395 | 0 |
sb.append( lineSeparator ); |
396 |
} |
|
397 | 0 |
if( null != m_implementationVersion ) |
398 |
{ |
|
399 | 0 |
sb.append( IMPLEMENTATION_VERSION ); |
400 | 0 |
sb.append( brace ); |
401 | 0 |
sb.append( m_implementationVersion ); |
402 | 0 |
sb.append( lineSeparator ); |
403 |
} |
|
404 | 0 |
if( null != m_implementationVendor ) |
405 |
{ |
|
406 | 0 |
sb.append( IMPLEMENTATION_VENDOR ); |
407 | 0 |
sb.append( brace ); |
408 | 0 |
sb.append( m_implementationVendor ); |
409 | 0 |
sb.append( lineSeparator ); |
410 |
} |
|
411 | 0 |
return sb.toString();
|
412 |
} |
|
413 |
/**
|
|
414 |
* Return <code>true</code> if the first version number is greater than
|
|
415 |
* or equal to the second; otherwise return <code>false</code>.
|
|
416 |
*
|
|
417 |
* @param first First version number (dotted decimal)
|
|
418 |
* @param second Second version number (dotted decimal)
|
|
419 |
*/
|
|
420 | 0 |
private boolean isCompatible( final DeweyDecimal first, final DeweyDecimal second ) |
421 |
{ |
|
422 | 0 |
return first.isGreaterThanOrEqual( second );
|
423 |
} |
|
424 |
/**
|
|
425 |
* Combine all specifications objects that are identical except
|
|
426 |
* for the sections.
|
|
427 |
*
|
|
428 |
* <p>Note this is very inefficent and should probably be fixed
|
|
429 |
* in the future.</p>
|
|
430 |
*
|
|
431 |
* @param list the array of results to trim
|
|
432 |
* @return an array list with all duplicates removed
|
|
433 |
*/
|
|
434 | 0 |
private static ArrayList removeDuplicates( final ArrayList list ) |
435 |
{ |
|
436 | 0 |
final ArrayList results = new ArrayList();
|
437 | 0 |
final ArrayList sections = new ArrayList();
|
438 | 0 |
while( list.size() > 0 )
|
439 |
{ |
|
440 | 0 |
final Specification specification = (Specification)list.remove( 0 ); |
441 | 0 |
final Iterator iterator = list.iterator(); |
442 | 0 |
while( iterator.hasNext() )
|
443 |
{ |
|
444 | 0 |
final Specification other = (Specification)iterator.next(); |
445 | 0 |
if( isEqual( specification, other ) )
|
446 |
{ |
|
447 | 0 |
final String[] otherSections = other.getSections(); |
448 | 0 |
if( null != sections ) |
449 |
{ |
|
450 | 0 |
sections.addAll( Arrays.asList( otherSections ) ); |
451 |
} |
|
452 | 0 |
iterator.remove(); |
453 |
} |
|
454 |
} |
|
455 | 0 |
final Specification merged = |
456 |
mergeInSections( specification, sections ); |
|
457 | 0 |
results.add( merged ); |
458 |
//Reset list of sections
|
|
459 | 0 |
sections.clear(); |
460 |
} |
|
461 | 0 |
return results;
|
462 |
} |
|
463 |
/**
|
|
464 |
* Test if two specifications are equal except for their sections.
|
|
465 |
*
|
|
466 |
* @param specification one specificaiton
|
|
467 |
* @param other the ohter specification
|
|
468 |
* @return true if two specifications are equal except for their
|
|
469 |
* sections, else false
|
|
470 |
*/
|
|
471 | 0 |
private static boolean isEqual( final Specification specification, |
472 |
final Specification other ) |
|
473 |
{ |
|
474 | 0 |
return
|
475 |
specification.getSpecificationTitle().equals( other.getSpecificationTitle() ) && |
|
476 |
specification.getSpecificationVersion().isEqual( other.getSpecificationVersion() ) && |
|
477 |
specification.getSpecificationVendor().equals( other.getSpecificationVendor() ) && |
|
478 |
specification.getImplementationTitle().equals( other.getImplementationTitle() ) && |
|
479 |
specification.getImplementationVersion().equals( other.getImplementationVersion() ) && |
|
480 |
specification.getImplementationVendor().equals( other.getImplementationVendor() ); |
|
481 |
} |
|
482 |
/**
|
|
483 |
* Merge the specified sections into specified section and return result.
|
|
484 |
* If no sections to be added then just return original specification.
|
|
485 |
*
|
|
486 |
* @param specification the specification
|
|
487 |
* @param sectionsToAdd the list of sections to merge
|
|
488 |
* @return the merged specification
|
|
489 |
*/
|
|
490 | 0 |
private static Specification mergeInSections( final Specification specification, |
491 |
final ArrayList sectionsToAdd ) |
|
492 |
{ |
|
493 | 0 |
if( 0 == sectionsToAdd.size() )
|
494 |
{ |
|
495 | 0 |
return specification;
|
496 |
} |
|
497 |
else
|
|
498 |
{ |
|
499 | 0 |
sectionsToAdd.addAll( Arrays.asList( specification.getSections() ) ); |
500 | 0 |
final String[] sections = |
501 |
(String[])sectionsToAdd.toArray( new String[ sectionsToAdd.size() ] );
|
|
502 | 0 |
return new Specification( specification.getSpecificationTitle(), |
503 |
specification.getSpecificationVersion().toString(), |
|
504 |
specification.getSpecificationVendor(), |
|
505 |
specification.getImplementationTitle(), |
|
506 |
specification.getImplementationVersion(), |
|
507 |
specification.getImplementationVendor(), |
|
508 |
sections ); |
|
509 |
} |
|
510 |
} |
|
511 |
/**
|
|
512 |
* Trim the supplied string if the string is non-null
|
|
513 |
*
|
|
514 |
* @param value the string to trim or null
|
|
515 |
* @return the trimmed string or null
|
|
516 |
*/
|
|
517 | 0 |
private static String getTrimmedString( final String value ) |
518 |
{ |
|
519 | 0 |
if( null == value ) |
520 |
{ |
|
521 | 0 |
return null; |
522 |
} |
|
523 |
else
|
|
524 |
{ |
|
525 | 0 |
return value.trim();
|
526 |
} |
|
527 |
} |
|
528 |
/**
|
|
529 |
* Extract an Package Specification from Attributes.
|
|
530 |
*
|
|
531 |
* @param attributes Attributes to searched
|
|
532 |
* @return the new Specification object, or null
|
|
533 |
*/
|
|
534 | 0 |
private static Specification getSpecification( final String section, |
535 |
final Attributes attributes ) |
|
536 |
throws ParseException
|
|
537 |
{ |
|
538 |
//WARNING: We trim the values of all the attributes because
|
|
539 |
//Some extension declarations are badly defined (ie have spaces
|
|
540 |
//after version or vendor)
|
|
541 | 0 |
final String name = getTrimmedString( attributes.getValue( SPECIFICATION_TITLE ) ); |
542 | 0 |
if( null == name ) |
543 |
{ |
|
544 | 0 |
return null; |
545 |
} |
|
546 | 0 |
final String specVendor = getTrimmedString( attributes.getValue( SPECIFICATION_VENDOR ) ); |
547 | 0 |
if( null == specVendor ) |
548 |
{ |
|
549 | 0 |
throw new ParseException( "Missing " + SPECIFICATION_VENDOR, 0 ); |
550 |
} |
|
551 | 0 |
final String specVersion = getTrimmedString( attributes.getValue( SPECIFICATION_VERSION ) ); |
552 | 0 |
if( null == specVersion ) |
553 |
{ |
|
554 | 0 |
throw new ParseException( "Missing " + SPECIFICATION_VERSION, 0 ); |
555 |
} |
|
556 | 0 |
final String impTitle = getTrimmedString( attributes.getValue( IMPLEMENTATION_TITLE ) ); |
557 | 0 |
if( null == impTitle ) |
558 |
{ |
|
559 | 0 |
throw new ParseException( "Missing " + IMPLEMENTATION_TITLE, 0 ); |
560 |
} |
|
561 | 0 |
final String impVersion = getTrimmedString( attributes.getValue( IMPLEMENTATION_VERSION ) ); |
562 | 0 |
if( null == impVersion ) |
563 |
{ |
|
564 | 0 |
throw new ParseException( "Missing " + IMPLEMENTATION_VERSION, 0 ); |
565 |
} |
|
566 | 0 |
final String impVendor = getTrimmedString( attributes.getValue( IMPLEMENTATION_VENDOR ) ); |
567 | 0 |
if( null == impVendor ) |
568 |
{ |
|
569 | 0 |
throw new ParseException( "Missing " + IMPLEMENTATION_VENDOR, 0 ); |
570 |
} |
|
571 | 0 |
return new Specification( name, specVersion, specVendor, |
572 |
impTitle, impVersion, impVendor, |
|
573 |
new String[]{section} );
|
|
574 |
} |
|
575 |
} |
|
576 |
|
|