Java tutorial
package com.limegroup.gnutella.xml; import java.io.IOException; import java.io.StringReader; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.limewire.util.StringUtils; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import com.google.inject.Inject; import com.google.inject.Provider; import com.google.inject.Singleton; import com.limegroup.gnutella.licenses.CCConstants; import com.limegroup.gnutella.licenses.LicenseType; @Singleton class LimeXMLDocumentFactoryImpl implements LimeXMLDocumentFactory { private static final Log LOG = LogFactory.getLog(LimeXMLDocumentFactoryImpl.class); private static final String XML_ID_ATTRIBUTE = "identifier__"; private static final String XML_ACTION_ATTRIBUTE = "action__"; // private static final String XML_ACTION_INFO = "addactiondetail__"; static final String XML_INDEX_ATTRIBUTE = "index__"; private static final String XML_VERSION_ATTRIBUTE = GenericXmlDocument.VERSION_STRING + "__"; private final Provider<LimeXMLSchemaRepository> limeXMLSchemaRepository; @Inject public LimeXMLDocumentFactoryImpl(Provider<LimeXMLSchemaRepository> limeXMLSchemaRepository) { this.limeXMLSchemaRepository = limeXMLSchemaRepository; } public LimeXMLDocument createLimeXMLDocument(String xml) throws SAXException, SchemaNotFoundException, IOException { if (xml == null || xml.equals("")) { throw new SAXException("null or empty string"); } InputSource doc = new InputSource(new StringReader(xml)); XMLParsingUtils.ParseResult result = XMLParsingUtils.parse(doc); if (result.isEmpty()) { throw new IOException("No element present"); } if (result.schemaURI == null) { throw new SchemaNotFoundException("no schema"); } Map<String, String> map = result.get(0); DocInfo docInfo = setFields(result.canonicalKeyPrefix, map); LimeXMLSchema schema = limeXMLSchemaRepository.get().getSchema(result.schemaURI); return createDocument(schema, map, docInfo); } public LimeXMLDocument createLimeXMLDocument(Map<String, String> map, String schemaUri, String keyPrefix) throws IOException { if (map.isEmpty()) { throw new IllegalArgumentException("empty map"); } if (schemaUri == null) { throw new IOException("null schemaUri"); } map.remove(keyPrefix + XML_ID_ATTRIBUTE); // remove id. DocInfo docInfo = setFields(keyPrefix, map); LimeXMLSchema schema = limeXMLSchemaRepository.get().getSchema(schemaUri); return createDocument(schema, map, docInfo); } public LimeXMLDocument createLimeXMLDocument(Collection<? extends Entry<String, String>> nameValueList, String schemaURI) { if (nameValueList.isEmpty()) { throw new IllegalArgumentException("empty list"); } if (schemaURI == null) { throw new IllegalArgumentException("null schemaUri not allowed"); } Map<String, String> map = new HashMap<String, String>(nameValueList.size()); //iterate over the passed list of field names & values for (Map.Entry<String, String> next : nameValueList) { String key = next.getKey() == null ? null : next.getKey().trim().intern(); String value = next.getValue() == null ? null : next.getValue().trim().intern(); if (!StringUtils.isEmpty(key) && value != null) { map.put(key, value); } } // scan for action/id/etc.. DocInfo docInfo = scanFields(map); if (docInfo == null) { throw new IllegalArgumentException("invalid nameValueList: " + nameValueList); } LimeXMLSchema schema = limeXMLSchemaRepository.get().getSchema(schemaURI); try { return createDocument(schema, map, docInfo); } catch (IOException iox) { // Rethrow as IllegalArgument, because this should not be happening // from user-supplied NameValue pairs. throw new IllegalArgumentException(iox); } } private LimeXMLDocument createDocument(LimeXMLSchema schema, Map<String, String> map, DocInfo docInfo) throws IOException { if (!isValid(schema, map)) { throw new IOException("invalid doc! " + map + " \nschema: " + (schema != null ? schema.getSchemaURI() : "null schema")); } return new GenericXmlDocument(schema, map, docInfo.version, docInfo.action, docInfo.licenseType); } /** Returns false if no valid document can be constructed with this information. */ private boolean isValid(LimeXMLSchema schema, Map<String, String> map) { if (schema == null) { return false; } List<String> fNames = schema.getCanonicalizedFieldNames(); for (String fieldName : fNames) { if (map.get(fieldName) != null) { // If atleast one field exists, it's valid. return true; } } return false; } /** * Stores whether or not an action or CC license are in this LimeXMLDocument. */ private DocInfo setFields(String prefix, Map<String, String> inputMap) { DocInfo docInfo = new DocInfo(); // store action. docInfo.action = inputMap.get(prefix + XML_ACTION_ATTRIBUTE); // docInfo.actionDetail = inputMap.get(prefix + LimeXMLDocument.XML_ACTION_INFO); // deal with updating license_type based on the license String license = inputMap.get(prefix + GenericXmlDocument.XML_LICENSE_ATTRIBUTE); String type = inputMap.get(prefix + GenericXmlDocument.XML_LICENSE_TYPE_ATTRIBUTE); if (LOG.isDebugEnabled()) LOG.debug("type: " + type); // Do specific stuff on licenseType for various licenses. // CC licenses require that the 'license' field has the CC_URI_PREFIX & CC_URL_INDICATOR // somewhere. Weed licenses require that the 'license type' field has WeedInfo.LINFO, // a content id & a version id. docInfo.licenseType = LicenseType.determineLicenseType(license, type); if (docInfo.licenseType == LicenseType.CC_LICENSE) { inputMap.put(prefix + GenericXmlDocument.XML_LICENSE_TYPE_ATTRIBUTE, CCConstants.CC_URI_PREFIX); } else if (docInfo.licenseType == LicenseType.LIMEWIRE_STORE_PURCHASE) { inputMap.put(prefix + GenericXmlDocument.XML_LICENSE_TYPE_ATTRIBUTE, LicenseType.LIMEWIRE_STORE_PURCHASE.toString()); } // Grab the version, if it exists. String versionString = inputMap.get(prefix + XML_VERSION_ATTRIBUTE); if (versionString != null) { try { docInfo.version = Integer.parseInt(versionString); if (LOG.isDebugEnabled()) { LOG.debug("Set version to: " + docInfo.version); } } catch (NumberFormatException nfe) { LOG.warn("Unable to set version", nfe); docInfo.version = GenericXmlDocument.CURRENT_VERSION; } } else { docInfo.version = GenericXmlDocument.CURRENT_VERSION; } inputMap.remove(prefix + XML_VERSION_ATTRIBUTE); if (LOG.isDebugEnabled()) LOG.debug("Fields after setting: " + inputMap); return docInfo; } /** * Looks in the fields for the ACTION, IDENTIFIER, and INDEX, and a license. * Action is stored, index & identifier are removed. */ private DocInfo scanFields(Map<String, String> inputMap) { String canonicalKey = getCanonicalKey(inputMap.entrySet()); if (canonicalKey == null) { return null; } else { DocInfo docInfo = setFields(canonicalKey, inputMap); inputMap.remove(canonicalKey + XML_INDEX_ATTRIBUTE); inputMap.remove(canonicalKey + XML_ID_ATTRIBUTE); return docInfo; } } /** Derives a canonicalKey from a collection of Map.Entry's. */ private String getCanonicalKey(Collection<? extends Map.Entry<String, String>> entries) { if (entries.isEmpty()) { return null; } Map.Entry<String, String> firstEntry = entries.iterator().next(); String firstKey = firstEntry.getKey(); // The canonicalKey is always going to be x__x__<other stuff here> int idx = firstKey.indexOf(XMLStringUtils.DELIMITER); idx = firstKey.indexOf(XMLStringUtils.DELIMITER, idx + 1); // not two delimiters? can't find the canonicalKey if (idx == -1) { return null; } // 2 == XMLStringUtils.DELIMITER.length() return firstKey.substring(0, idx + 2); } private static class DocInfo { private LicenseType licenseType; private int version; private String action; // private String actionDetail; } }