/**
* Create from factory a DocumentBuilder and let it create a org.w3c.dom.Document. This method
* takes InputSource. After successful finish the document tree is returned.
*
* @param input a parser input (for URL users use: <code>new InputSource(url.toExternalForm())
* </code>
* @param validate if true validating parser is used
* @param namespaceAware if true DOM is created by namespace aware parser
* @param errorHandler a error handler to notify about exception or <code>null</code>
* @param entityResolver SAX entity resolver or <code>null</code>; see class Javadoc for hints
* @throws IOException if an I/O problem during parsing occurs
* @throws SAXException is thrown if a parser error occurs
* @throws FactoryConfigurationError Application developers should never need to directly catch
* errors of this type.
* @return document representing given input, or null if a parsing error occurs
*/
public static Document parse(
InputSource input,
boolean validate,
boolean namespaceAware,
ErrorHandler errorHandler,
EntityResolver entityResolver)
throws IOException, SAXException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validate);
factory.setNamespaceAware(namespaceAware);
DocumentBuilder builder = null;
try {
builder = factory.newDocumentBuilder();
} catch (ParserConfigurationException ex) {
throw new SAXException(
"Cannot create parser satisfying configuration parameters", ex); // NOI18N
}
if (errorHandler != null) {
builder.setErrorHandler(errorHandler);
}
if (entityResolver != null) {
builder.setEntityResolver(entityResolver);
}
return builder.parse(input);
}
public static final Skeleton loadSkeleton(File file) {
try {
FileInputStream input_stream = new FileInputStream(file);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(new GeometryErrorHandler());
Document document = builder.parse(input_stream);
Element root = document.getDocumentElement();
return parseSkeleton(root);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected Object exec(Object[] args, Context context) {
int nargs = args.length;
Object schema = null;
Map properties = null;
Object errorHandler;
Object input;
switch (nargs) {
case 4:
schema = args[3];
case 3:
properties = (Map) args[2];
case 2:
errorHandler = args[1];
break;
case 1:
errorHandler = Util.getDefaultErrorHandler(context);
break;
default:
undefined(args, context);
return null;
}
input = args[0];
if (properties == null) {
properties = new LinkedHashMap();
}
if (schema != null) {
properties.put(Util.KEY_SCHEMA, schema);
}
DocumentBuilder builder = Util.getDocumentBuilder(properties, context);
if (errorHandler != null) {
builder.setErrorHandler((ErrorHandler) Util.contentHandler(errorHandler, context));
}
try {
return builder.parse(Util.inputSource(input, context));
} catch (IOException e1) {
throw new PnutsException(e1, context);
} catch (SAXException e2) {
throw new PnutsException(e2, context);
}
}
protected Document parse(InputStream inputStream) throws LibraryException {
Map<Integer, SongBean> songMap = new HashMap<Integer, SongBean>();
Map<Integer, AlbumBean> albumMap = new HashMap<Integer, AlbumBean>();
Map<Integer, AlbumBean> secondaryAlbumMap = new HashMap<Integer, AlbumBean>();
warningList.clear();
try {
// Create a builder factory
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setNamespaceAware(true);
factory.setIgnoringElementContentWhitespace(true);
factory.setIgnoringComments(true);
// Create the builder and parse the file
DocumentBuilder builder = factory.newDocumentBuilder();
// Set an error listener and parse the document
builder.setErrorHandler(new iTradeTunesLibraryErrorHandler());
builder.setEntityResolver(new iTradeTunesLibraryResolver());
Document document = builder.parse(inputStream);
synchronized (libraryList) {
// Query the library document and build the library list
XPath xPath = XPathFactory.newInstance().newXPath();
XPathExpression xPathExpression = xPath.compile(XPATH_LIBRARY_LIST);
NodeList nodelist = (NodeList) xPathExpression.evaluate(document, XPathConstants.NODESET);
// Process the elements in the nodelist
SongBean song = null;
for (int i = 0; i < nodelist.getLength(); i++) {
boolean isTrackID = false;
// Get element and child nodes
Element elem = (Element) nodelist.item(i);
NodeList list = elem.getChildNodes();
// Get node value
Node childKey = list.item(0);
String key = childKey.getNodeValue();
// Check if we have to create a new bean
if (SongBean.NAME_TRACK_ID.equals(key)) {
isTrackID = true;
SongBean previousSong = song;
song = new SongBean();
if (previousSong != null
&& !("AAC audio file".equals(previousSong.getKind())
|| "MPEG audio file".equals(previousSong.getKind()))) {
songMap.remove(previousSong.getTrack_ID());
} else {
// Add an album bean
addOrUpdateAlbum(albumMap, previousSong, false);
}
}
// The first parameter is the key
String prop = childKey.getNodeValue().replace(' ', '_');
// The second parameter is the value
i++;
// Get element and child nodes
elem = (Element) nodelist.item(i);
// Check for boolean properties
Object value = null;
// Get node value
list = elem.getChildNodes();
childKey = list.item(0);
value = (childKey == null) ? elem.getNodeName() : childKey.getNodeValue();
if (isTrackID) {
isTrackID = false;
}
// Set the property of the song bean
Statement stmt = new Statement(song, "set" + prop, new Object[] {value});
try {
stmt.execute();
} catch (Exception e) {
// Ignore that field, we do not have it in our bean
}
// If the property is the track ID, add the song to the hash
// map
if (SongBean.NAME_TRACK_ID.equals(key)) {
int trackID = Integer.valueOf((String) value);
songMap.put(trackID, song);
}
}
// Update album for last song
addOrUpdateAlbum(albumMap, song, false);
// Check the album map for inconsistencies
Iterator<AlbumBean> albums = albumMap.values().iterator();
while (albums.hasNext()) {
AlbumBean album = albums.next();
if (album.checkConsistency()) {
libraryList.add(album);
album.setHashCode();
} else {
// Add an inconsistent album only using the album title
SongBean[] songs = album.getSongs();
for (int i = 0; i < songs.length; i++) {
addOrUpdateAlbum(secondaryAlbumMap, songs[i], true);
}
}
}
// Check secondary album map for consistency
albums = secondaryAlbumMap.values().iterator();
while (albums.hasNext()) {
AlbumBean album = albums.next();
if (album.checkConsistency()) {
libraryList.add(album);
album.setHashCode();
} else {
// This album cannot be matched
// TODO: Add to warning message
}
}
setChanged();
}
return document;
} catch (IOException ioe) {
// Log an expected connect exception
throw new LibraryException(ioe);
} catch (SAXException se) {
// Catch all other exceptions
throw new LibraryException(se);
} catch (ParserConfigurationException pce) {
// Catch all other exceptions
Utils.logSevere(pce);
throw new LibraryException(pce);
} catch (XPathExpressionException xpe) {
// Catch all other exceptions
Utils.logSevere(xpe);
throw new LibraryException(xpe);
} catch (NumberFormatException nfe) {
// Catch all other exceptions
throw new LibraryException(nfe);
}
}
@Override
protected DocumentBuilder getDocBuilder() throws ParserConfigurationException {
DocumentBuilder builder = super.getDocBuilder();
builder.setErrorHandler(getErrorHandler());
return builder;
}