rdfwriter.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 531 行 · 第 1/2 页

			} else {
				xml.startElement(RDFVocabularyAdapter.RDF, "Description");
				if (SwoopResourceImpl.isAnonymous(element)) {
					xml.addAttribute(RDFVocabularyAdapter.RDF, "nodeID", (String)bnodes.get(element));
				} else {		
					xml.addAttribute(RDFVocabularyAdapter.RDF, "about", new URI(element.getURI()));
				}
				xml.endElement();
			}
		}
		
		return true;
	}
	
	protected boolean propertyLiteral(RDFNode value) throws ModelException, IOException, URISyntaxException {
		if (value instanceof Literal) {
			Literal valueLit = (Literal) value;
			String datatype = valueLit.getDatatype();
			String language = valueLit.getLanguage();
			if (datatype != null) {
				xml.addAttribute(RDFVocabularyAdapter.RDF, "datatype", new URI(datatype));
			} else if (language != null) {
				xml.addAttribute(null, "xml:lang", language);
			}
			xml.writeData(valueLit.getLabel());
			return true;
		}
		return false;
	}
	
	protected boolean propertyNested(RDFNode value) throws IOException, OWLException {
		if (!(value instanceof Resource) || !shouldNest(value)) { 
			return false;
		}
		serializeSubject((Resource) value);
		return true;
	}
	
	protected boolean propertyReference(RDFNode value) throws URISyntaxException, ModelException, IOException {
		if ((value instanceof Resource) && !SwoopResourceImpl.isAnonymous(value)) {
			URI valueURI = new URI(((Resource)value).getURI());
			xml.addAttribute(RDFVocabularyAdapter.RDF, "resource", valueURI);
			return true;
		}
		return false;
	}
	
	protected boolean propertyXMLLiteral(RDFNode value) {
		return false;
	}
	
	private void reset() {
		bnodes = new HashMap();
		bnodeCount = new HashMap();
		namespaces = new HashSet();
		rendered = new HashSet();
		level = 0;
	}
	
	public void serializeAll() throws IOException, OWLException {
		serializeAll(null);
	}

	public void serializeAll(String comment)  throws IOException, OWLException {
		boolean started = false;
		for (Iterator subjectIter = subjects.keySet().iterator(); subjectIter.hasNext();) {
			Resource subject = (Resource) subjectIter.next();
			if (!started && !rendered.contains(subject)) {
				if (comment != null) {
					xml.writeComment(comment);
				}
				started = true;
			}
			serializeSubject(subject);
		}
	}
	
	
	protected void serializeProperty(Resource property, RDFNode value) throws URISyntaxException, ModelException, IOException, OWLException {
		URI propertyURI = new URI(property.getURI());
		startElement(propertyURI);
		
		if (!propertyList(value)
				&& !propertyNested(value)
				&& !propertyBNode(value)
				&& !propertyReference(value)
				&& !propertyXMLLiteral(value)
				&& !propertyLiteral(value)) {
			throw new OWLException("Could not serialize property "+property+" with value "+value);
		}
		
		xml.endElement();
	}
	
	public void serializeSubject(Resource subject) throws IOException, OWLException {

		if (rendered.contains(subject) || (subjects.get(subject) == null)) {
			return;
		}
		try {
			level++;
			rendered.add(subject);
			Map propertyMap = (Map) subjects.get(subject);
			
			Collection types = (Collection) propertyMap.get(genResource(rdf
					.getInstanceOf()));
			if (types == null) {
				types = Collections.EMPTY_SET;
			}
			boolean started = false;
			for (Iterator typeIter = types.iterator(); typeIter.hasNext();) {
				RDFNode typeNode = (RDFNode) typeIter.next();
				if (typeNode instanceof Resource
						&& !SwoopResourceImpl.isAnonymous(typeNode)) {
					started = true;
					types.remove(typeNode);
					startElement(new URI(((Resource) typeNode).getURI()));
					break;
				}
			}
			if (!started) {
				xml.startElement(RDFVocabularyAdapter.RDF, "Description");
			}
			
			/* Add identifier */
			if (SwoopResourceImpl.isAnonymous(subject)) {
				String nodeid = (String) bnodes.get(subject);
				Integer count = (Integer) bnodeCount.get(subject);
				if ((nodeid != null) && (count != null)) {
					if ((count.intValue() > 1) || ((count.intValue() == 1) && (level == 1))) {
						xml.addAttribute(RDFVocabularyAdapter.RDF, "nodeID", nodeid);
					}
				}
			} else {
				xml.addAttribute(RDFVocabularyAdapter.RDF, "about", new URI(subject.getURI()));
			}
			
			/* Write short literal properties */
			for (Iterator propIter = propertyMap.keySet().iterator(); propIter.hasNext();) {
				Resource property = (Resource) propIter.next();
				URI propertyURI = new URI(property.getURI());
				Collection values = (Collection) propertyMap.get(property);
				if (values.size() > 1) {
					continue;
				}
				for (Iterator valueIter = values.iterator(); valueIter.hasNext();) {
					RDFNode value = (RDFNode) valueIter.next();
					if (value instanceof Literal) {
						Literal valueLit = (Literal) value;
						if (valueLit.getDatatype()==null 
								&& valueLit.getLanguage()==null 
								&& valueLit.toString().length() < 40) {
							
							xml.addAttribute(qnames.findPrefixURI(propertyURI), 
									qnames.findLocal(propertyURI), valueLit.toString());
							values.remove(valueLit);
							break;
						}
					}
				}
			}
			
			/* Write all properties */
			for (Iterator propIter = propertyMap.keySet().iterator(); propIter.hasNext();) {
				Resource property = (Resource) propIter.next();
				Collection values = (Collection) propertyMap.get(property);
				for (Iterator valueIter = values.iterator(); valueIter.hasNext();) {
					RDFNode value = (RDFNode) valueIter.next();
					serializeProperty(property, value);
				}
			}
			
			xml.endElement();
		} catch (URISyntaxException e) {
			throw new OWLException(e);
		} catch (ModelException e) {
			throw new OWLException(e);
		} finally {
			level--;
		}
	}
	
	public void serializeSubjects(Collection subjects) throws IOException, OWLException {
		serializeSubjects(subjects, null);
	}
	
	public void serializeSubjects(Collection subjects, String comment) throws IOException, OWLException {
		boolean started = false;
		for (Iterator subjectIter = subjects.iterator(); subjectIter.hasNext();) {
			Resource subject = (Resource) subjectIter.next();
			if (!started && !rendered.contains(subject)) {
				if (comment != null) {
					xml.writeComment(comment);
				}
				started = true;
			}
			serializeSubject(subject);
		}
	}
	
	public void setMaxLevel(int level) {
		maxLevel = level;
	}
	
	private boolean shouldNest(RDFNode node) {
		if (node instanceof Resource)
			return shouldNest((Resource) node);
		return false;
	}
	
	private boolean shouldNest(Resource resource) {
		if (rendered.contains(resource) || (subjects.get(resource) == null)) {
			return false;
		}
		
		if (SwoopResourceImpl.isAnonymous(resource)) {
			return true;
		}
		
		if (level >= maxLevel) {
			return false;
		}
		return true;
	}
	public void startDocument() throws IOException, OWLException {
		
		try {
			collectInformation();
			addNamespaces();
			xml.addEntity("xsd", XMLSchemaSimpleDatatypeVocabulary.XS);
			
			xml.startDocument();
			xml.startElement(RDFVocabularyAdapter.RDF, "RDF");
		} catch (ModelException e) {
			throw new OWLException(e);
		} catch (URISyntaxException e) {
			throw new OWLException(e);
		}
		
	}
	
	private void startElement(URI uri) throws IOException {
		xml.startElement(qnames.findPrefixURI(uri), qnames.findLocal(uri));
	}
	
	public void endDocument() throws OWLException {
		try {
			xml.endDocument();
		} catch (Exception e) {
			throw new OWLException(e);
		}
	}

	/**
	 * @param base
	 */
	public void setBase(URI base) {
		this.base = base;
		nodeComparator = new NodeComparator(base.toString());
		xml.setBase(base);
	}
	
	
}