static {
try {
URL url = SpellCheckActivator.bundleContext.getBundle().getResource(RESOURCE_LOC);
InputStream stream = url.openStream();
if (stream == null) throw new IOException();
// strict parsing options
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
// parses configuration xml
/*-
* Warning: Felix is unable to import the com.sun.rowset.internal
* package, meaning this can't use the XmlErrorHandler. This causes
* a warning and a default handler to be attached. Otherwise this
* should have: builder.setErrorHandler(new XmlErrorHandler());
*/
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(stream);
// iterates over nodes, parsing contents
Node root = doc.getChildNodes().item(1);
NodeList categories = root.getChildNodes();
for (int i = 0; i < categories.getLength(); ++i) {
Node node = categories.item(i);
if (node.getNodeName().equals(NODE_DEFAULTS)) {
parseDefaults(node.getChildNodes());
} else if (node.getNodeName().equals(NODE_LOCALES)) {
parseLocales(node.getChildNodes());
} else {
logger.warn("Unrecognized category: " + node.getNodeName());
}
}
} catch (IOException exc) {
logger.error("Unable to load spell checker parameters", exc);
} catch (SAXException exc) {
logger.error("Unable to parse spell checker parameters", exc);
} catch (ParserConfigurationException exc) {
logger.error("Unable to parse spell checker parameters", exc);
}
}
public void setIgnoringComments(boolean ignoreComments) {
fact.setIgnoringComments(ignoreComments);
}
public static MiningResult importFile(InputStream input) throws IOException {
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Document doc;
// NodeList netNodes;
dbf.setValidating(false);
dbf.setIgnoringComments(true);
dbf.setIgnoringElementContentWhitespace(true);
// dbf.setExpandEntityReferences(false);
// dbf.setNamespaceAware(false);
DocumentBuilder db = dbf.newDocumentBuilder();
db.setEntityResolver(
new EntityResolver() {
public InputSource resolveEntity(String publicId, String systemId) {
if (systemId.indexOf("ARIS-Export") != -1) {
return new InputSource("file:" + About.EXTLIBLOCATION() + "ARIS-Export101.dtd");
} else {
return null;
}
}
});
InputSource inpStream = new InputSource(input);
inpStream.setSystemId("file:" + System.getProperty("user.dir", ""));
doc = db.parse(inpStream);
// check if root element is a aml tag
Message.add("parsing done" + doc, Message.DEBUG);
if (!(doc.getDocumentElement().getNodeName().equals("AML"))) {
Message.add("aml tag not found", Message.ERROR);
throw new Exception("aml tag not found");
} else {
Message.add("aml root element found");
}
EPCResult result = new EPCResult(null, (EPC) null);
HashMap ObjDef_LinkId = new HashMap();
HashMap modelid_net = new HashMap();
HashMap ObjDef_Name = new HashMap();
HashMap function_LinkId = new HashMap();
HashMap ModelId_ModelType = new HashMap();
traverseAMLforObjectNames(
ObjDef_Name, doc.getDocumentElement(), ObjDef_LinkId, ModelId_ModelType);
Iterator findLinkToEpc = ObjDef_LinkId.keySet().iterator();
while (findLinkToEpc.hasNext()) {
String currentObjDef = (String) findLinkToEpc.next();
String Links = (String) ObjDef_LinkId.get(currentObjDef);
StringTokenizer linkSet = new StringTokenizer(Links);
String realEpcLink = "";
while (linkSet.hasMoreTokens()) {
String currentLink = linkSet.nextToken();
if (ModelId_ModelType.get(currentLink).equals("MT_EEPC")) {
realEpcLink = currentLink;
break;
}
}
if (realEpcLink.equals(" ")) {
ObjDef_LinkId.remove(currentObjDef);
} else {
ObjDef_LinkId.put(currentObjDef, realEpcLink);
}
}
result =
traverseAML(
result,
doc.getDocumentElement(),
null,
ObjDef_Name,
ObjDef_LinkId,
modelid_net,
function_LinkId);
Iterator hierarchicalFunctions = function_LinkId.keySet().iterator();
while (hierarchicalFunctions.hasNext()) {
EPCSubstFunction f = (EPCSubstFunction) hierarchicalFunctions.next();
f.setSubstitutedEPC((EPC) modelid_net.get(function_LinkId.get(f)));
// Message.add(f.getSubstitutedEPC().getName());
}
return result;
} catch (Throwable x) {
Message.add(x.toString());
throw new IOException(x.getMessage());
}
}
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);
}
}