Java UnsupportedArchiveException类代码示例

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static Character getFirstChar(String x) throws UnsupportedArchiveException {
	if (x == null || x.length() == 0) {
		return null;
	}
	if (x.length() == 1) {
		return x.charAt(0);
	}
	if (x.equalsIgnoreCase("\\t")) {
		return '\t';
	}
	if (x.equalsIgnoreCase("\\n")) {
		return '\n';
	}
	if (x.equalsIgnoreCase("\\r")) {
		return '\r';
	}
	if (x.length() > 1) {
		throw new UnsupportedArchiveException(
				"Only darwin core archives with a single quotation character are supported, but found >>>" + x + "<<<");
	}
	return ' ';
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private ArchiveFile buildArchiveFile(Attributes attr) throws UnsupportedArchiveException {
	ArchiveFile dwcFile = new ArchiveFile();

	// extract the File attributes
	if (getAttr(attr, "encoding") != null) {
		dwcFile.setEncoding(getAttr(attr, "encoding"));
	}
	if (getAttr(attr, "fieldsTerminatedBy") != null) {
		dwcFile.setFieldsTerminatedBy(unescapeBackslash(getAttr(attr, "fieldsTerminatedBy")));
	}
	if (getAttr(attr, "fieldsEnclosedBy") != null) {
		dwcFile.setFieldsEnclosedBy(getFirstChar(getAttr(attr, "fieldsEnclosedBy")));
	}
	if (getAttr(attr, "linesTerminatedBy") != null) {
		dwcFile.setLinesTerminatedBy(unescapeBackslash(getAttr(attr, "linesTerminatedBy")));
	}
	if (getAttr(attr, "rowType") != null) {
		dwcFile.setRowType(getAttr(attr, "rowType"));
	}
	String ignoreHeaderLines = getAttr(attr, "ignoreHeaderLines");
	try {
		dwcFile.setIgnoreHeaderLines(Integer.parseInt(ignoreHeaderLines));
	} catch (NumberFormatException ignored) { // swallow null or bad value
	}
	return dwcFile;
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
/**
 * Build an ArchiveField object based on xml attributes.
 */
private ArchiveField buildField(Attributes attributes) {
	// build field
	Term term = TermFactory.findTerm(getAttr(attributes, "term"));
	String defaultValue = getAttr(attributes, "default");
	DataType type = DataType.findByXmlSchemaType(getAttr(attributes, "type"));
	if (type == null) {
		type = DataType.string;
	}
	String indexAsString = getAttr(attributes, "index");
	Integer index = null;
	if (indexAsString != null) {
		// let bad errors be thrown up
		try {
			index = Integer.parseInt(indexAsString);
		} catch (NumberFormatException e) {
			throw new UnsupportedArchiveException(e);
		}
	}
	return new ArchiveField(index, term, defaultValue, type);
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
/**
 * Opens an archive from a URL, downloading and decompressing it.
 *
 * @param archiveUrl the location of a compressed archive or single data file
 * @param workingDir writable directory to download to and decompress archive
 */
public static Archive openArchive(URL archiveUrl, File workingDir) throws IOException, UnsupportedArchiveException {
	File downloadTo = new File(workingDir, "dwca-download");
	File dwca = new File(workingDir, "dwca");
	DownloadUtil.download(archiveUrl, downloadTo);
	return openArchive(downloadTo, dwca);
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static ArchiveFile readFileHeaders(File dataFile) throws UnsupportedArchiveException, IOException {
	ArchiveFile dwcFile = new ArchiveFile();
	dwcFile.addLocation(null);
	dwcFile.setIgnoreHeaderLines(1);

	CSVReader reader = CSVReaderFactory.build(dataFile);

	// copy found delimiters & encoding
	dwcFile.setEncoding(reader.encoding);
	dwcFile.setFieldsTerminatedBy(reader.delimiter);
	dwcFile.setFieldsEnclosedBy(reader.quoteChar);

	// detect dwc terms as good as we can based on header row
	String[] headers = reader.header;
	int index = 0;
	for (String head : headers) {
		// there are never any quotes in term names - remove them just in case the csvreader didnt recognize them
		if (head != null && head.length() > 1) {
			Term dt = TERM_FACTORY.findTerm(head);
			if (dt != null) {
				ArchiveField field = new ArchiveField(index, dt, null, DataType.string);
				if (dwcFile.getId() == null &&
						(dt.equals(DwcTerm.occurrenceID) || dt.equals(DwcTerm.taxonID) || dt.equals(DcTerm.identifier))) {
					dwcFile.setId(field);
				} else {
					dwcFile.addField(field);
				}
			}
		}
		index++;
	}

	return dwcFile;
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static void readMetaDescriptor(Archive archive, InputStream metaDescriptor, boolean normaliseTerms)
		throws UnsupportedArchiveException {

	try {
		SAXParser p = SAX_FACTORY.newSAXParser();
		MetaHandler mh = new MetaHandler(archive);
		LOG.debug("Reading archive metadata file");
		//    p.parse(metaDescriptor, mh);
		p.parse(new BomSafeInputStreamWrapper(metaDescriptor), mh);
	} catch (Exception e1) {
		LOG.warn("Exception caught", e1);
		throw new UnsupportedArchiveException(e1);
	}
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static void validateCoreFile(ArchiveFile f, boolean hasExtensions) throws UnsupportedArchiveException {
	if (hasExtensions) {
		if (f.getId() == null) {
			LOG.warn(
					"DwC-A core data file " + f.getTitle() + " is lacking an id column. No extensions allowed in this case");
		}
	}
	validateFile(f);
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static void validateExtensionFile(ArchiveFile f) throws UnsupportedArchiveException {
	if (f.getId() == null) {
		throw new UnsupportedArchiveException(
				"DwC-A data file " + f.getTitle() + " requires an id or foreign key to the core id");
	}
	validateFile(f);
}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static void validateFile(ArchiveFile f) throws UnsupportedArchiveException {
	if (f == null) {
		throw new UnsupportedArchiveException("DwC-A data file is NULL");
	}
	if (f.getLocationFile() == null) {
		throw new UnsupportedArchiveException("DwC-A data file " + f.getTitle() + " requires a location");
	}
	if (f.getEncoding() == null) {
		throw new UnsupportedArchiveException("DwC-A data file " + f.getTitle() + " requires a character encoding");
	}

}
 

import org.gbif.dwc.text.UnsupportedArchiveException; //导入依赖的package包/类
private static void validateArchive(Archive archive) throws UnsupportedArchiveException {
	validateCoreFile(archive.getCore(), !archive.getExtensions().isEmpty());
	for (ArchiveFile af : archive.getExtensions()) {
		validateExtensionFile(af);
	}
}