triplevisitor.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 1,245 行 · 第 1/3 页

/*
 * Created on Mar 31, 2005
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package org.mindswap.swoop.utils.rdfapi;

import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
import java.util.Vector;

import org.semanticweb.owl.io.vocabulary.OWLVocabularyAdapter;
import org.semanticweb.owl.io.vocabulary.XMLSchemaSimpleDatatypeVocabulary;
import org.semanticweb.owl.model.OWLAnd;
import org.semanticweb.owl.model.OWLAnnotationInstance;
import org.semanticweb.owl.model.OWLAnnotationProperty;
import org.semanticweb.owl.model.OWLBooleanDescription;
import org.semanticweb.owl.model.OWLClass;
import org.semanticweb.owl.model.OWLClassAxiom;
import org.semanticweb.owl.model.OWLDataAllRestriction;
import org.semanticweb.owl.model.OWLDataCardinalityRestriction;
import org.semanticweb.owl.model.OWLDataEnumeration;
import org.semanticweb.owl.model.OWLDataProperty;
import org.semanticweb.owl.model.OWLDataPropertyInstance;
import org.semanticweb.owl.model.OWLDataPropertyRangeAxiom;
import org.semanticweb.owl.model.OWLDataSomeRestriction;
import org.semanticweb.owl.model.OWLDataType;
import org.semanticweb.owl.model.OWLDataValue;
import org.semanticweb.owl.model.OWLDataValueRestriction;
import org.semanticweb.owl.model.OWLDescription;
import org.semanticweb.owl.model.OWLDifferentIndividualsAxiom;
import org.semanticweb.owl.model.OWLDisjointClassesAxiom;
import org.semanticweb.owl.model.OWLEnumeration;
import org.semanticweb.owl.model.OWLEquivalentClassesAxiom;
import org.semanticweb.owl.model.OWLEquivalentPropertiesAxiom;
import org.semanticweb.owl.model.OWLException;
import org.semanticweb.owl.model.OWLFrame;
import org.semanticweb.owl.model.OWLFunctionalPropertyAxiom;
import org.semanticweb.owl.model.OWLIndividual;
import org.semanticweb.owl.model.OWLIndividualAxiom;
import org.semanticweb.owl.model.OWLIndividualTypeAssertion;
import org.semanticweb.owl.model.OWLInverseFunctionalPropertyAxiom;
import org.semanticweb.owl.model.OWLInversePropertyAxiom;
import org.semanticweb.owl.model.OWLNamedObject;
import org.semanticweb.owl.model.OWLNot;
import org.semanticweb.owl.model.OWLObject;
import org.semanticweb.owl.model.OWLObjectAllRestriction;
import org.semanticweb.owl.model.OWLObjectCardinalityRestriction;
import org.semanticweb.owl.model.OWLObjectProperty;
import org.semanticweb.owl.model.OWLObjectPropertyInstance;
import org.semanticweb.owl.model.OWLObjectPropertyRangeAxiom;
import org.semanticweb.owl.model.OWLObjectSomeRestriction;
import org.semanticweb.owl.model.OWLObjectValueRestriction;
import org.semanticweb.owl.model.OWLObjectVisitor;
import org.semanticweb.owl.model.OWLOntology;
import org.semanticweb.owl.model.OWLOr;
import org.semanticweb.owl.model.OWLProperty;
import org.semanticweb.owl.model.OWLPropertyAxiom;
import org.semanticweb.owl.model.OWLPropertyAxiomVisitor;
import org.semanticweb.owl.model.OWLPropertyDomainAxiom;
import org.semanticweb.owl.model.OWLRestriction;
import org.semanticweb.owl.model.OWLSameIndividualsAxiom;
import org.semanticweb.owl.model.OWLSubClassAxiom;
import org.semanticweb.owl.model.OWLSubPropertyAxiom;
import org.semanticweb.owl.model.OWLSymmetricPropertyAxiom;
import org.semanticweb.owl.model.OWLTransitivePropertyAxiom;
import org.semanticweb.owl.model.helper.OWLPropertyAxiomVisitorAdapter;

import edu.unika.aifb.rdf.api.model.Model;
import edu.unika.aifb.rdf.api.model.ModelException;
import edu.unika.aifb.rdf.api.model.ModelWarning;
import edu.unika.aifb.rdf.api.model.RDFNode;
import edu.unika.aifb.rdf.api.model.Statement;
import edu.unika.aifb.rdf.api.util.RDFConstants;
import edu.unika.aifb.rdf.mainmemory.TransactionableModelImpl;

/**
 * @author ronwalf
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class TripleVisitor implements OWLObjectVisitor {

	protected Model model;
	protected SwoopNodeFactory nodeFactory;
	protected NodeProvider nodeProvider;
	protected OWLOntology ontology;
	protected OWLVocabularyAdapter owl = OWLVocabularyAdapter.INSTANCE;
	protected XMLSchemaSimpleDatatypeVocabulary xsd = XMLSchemaSimpleDatatypeVocabulary.INSTANCE;
	//protected QNameShortFormProvider qnames = new QNameShortFormProvider();
	//protected Set rendered;
	protected Set rendered;
	protected Map resources;
	protected Set serialized;
	
	protected OWLDescription currentClass;
	protected OWLProperty currentProperty;
	protected boolean replaceParent;
	protected Stack currentStack;
	protected Stack objectStack;
	
	
	
	public TripleVisitor(OWLOntology ontology) throws OWLException {
		this.ontology = ontology;
		nodeProvider = new StandardNodeProvider();
		createModel(ontology.getURI().toString());
		reset();
	}
	
	
	public TripleVisitor(OWLOntology ontology, NodeProvider nodeProvider) throws OWLException {
		this.ontology = ontology;
		this.nodeProvider = nodeProvider;
		createModel(ontology.getURI().toString());
		reset();
	}
	
	public TripleVisitor(OWLOntology ontology, Model model) throws OWLException {
		this.ontology = ontology;
		this.model = model;
		try {
			this.nodeFactory = (SwoopNodeFactory) model.getNodeFactory();
			nodeProvider = new StandardNodeProvider(nodeFactory);
		} catch (ModelException e) {
			throw new OWLException(e);
		}
		reset();
	}
	
	protected void add(OWLNamedObject subject, OWLProperty property, OWLNamedObject value) throws OWLException {
		add(getResource(subject), getResource(property), getResource(value));
	}
	
	protected void add(OWLNamedObject subject, OWLProperty property, OWLDataValue value) throws OWLException {
		add(getResource(subject), getResource(property), getRDFNode(value));
	}
	
	protected void add(SwoopResource subject, SwoopResource predicate, RDFNode object) throws OWLException {
		try {
			Statement statement = nodeFactory.createStatement(subject, predicate, object);
			model.add(statement);
		} catch (ModelWarning e) {
			// Do nothing
		} catch (ModelException e) {
			throw new OWLException(e);
		}
	}
	
	protected void addAnnotations(OWLObject obj) throws OWLException {
		for (Iterator annotationIter = obj.getAnnotations(ontology).iterator(); annotationIter.hasNext();) {
			OWLAnnotationInstance annotation = (OWLAnnotationInstance) annotationIter.next();
			
			annotation.accept(this);
		}
	}
	
	protected void addEquivalences(String equivalenceProperty, Collection items) throws OWLException {
		SwoopResource equivalence = getResource(equivalenceProperty);
		SwoopResource center = null;
		if ((currentObject() != null) && items.contains(currentObject())) {
			center = getResource(currentObject());
		}
		for (Iterator itemIter = items.iterator(); itemIter.hasNext();) {
			SwoopResource item = getResource((OWLObject) itemIter.next());
			if (center == null) {
				center = item;
			}
			
			if (center != item) {
				add(center, equivalence, item);
			}
		}
	}
	
	protected SwoopResource addList(Collection items) throws OWLException {
		if (items.size() == 0) {
			return getResource(owl.getNil());
		}
		
		//Sort changes
		Collection list = new TreeSet(new NodeComparator(ontology.getURI().toString()));
		for (Iterator objectIter = items.iterator(); objectIter.hasNext();) {
			OWLObject element = (OWLObject) objectIter.next();
			list.add(getRDFNode(element));
		}
		
		SwoopResource start = (SwoopResource) nodeFactory.createResource();
		SwoopResource current = null;
		for (Iterator objectIter = list.iterator(); objectIter.hasNext();) {
			RDFNode element = (RDFNode) objectIter.next();
			
			if (current == null) {
				current = start;
			} else {
				SwoopResource previous = current;
				current = (SwoopResource) nodeFactory.createResource();
				add(previous, getResource(RDFConstants.RDF_REST), current);
			}
			add(current, getResource(RDFConstants.RDF_FIRST), element);
		}
		add(current, getResource(RDFConstants.RDF_REST), getResource(owl.getNil()));
		return start;
	}

	
//	protected void addNamespace(SwoopResource uri) throws ModelException {
//		
//		try {
//			qnames.shortForm(new URI(uri.getURI()));
//		} catch (URISyntaxException e) {
//			e.printStackTrace();
//		} catch (ModelException e) {
//			e.printStackTrace();
//		}
//	}
	
//	public void addNamespace(String prefix, String namespace) {
//		qnames.setMapping(prefix, namespace);
//	}
	
	protected void addProperties(SwoopResource node, Map properties) throws OWLException {
		for (Iterator propIter = properties.keySet().iterator(); propIter.hasNext();) {
			String property = (String) propIter.next();
			Set values = (Set) properties.get(property);
			for (Iterator valueIter = values.iterator(); valueIter.hasNext();) {
				OWLObject value = (OWLObject) valueIter.next();
				add(node, getResource(property), getRDFNode(value));
			}
		}
	}
	
	/**
	 * Adds given property from each individual to the rest unless currentObject()
	 * is not null and is contained in 'individuals'.  In this case, it adds
	 * the prop link from currentObject() to the rest of the individuals.
	 * @param prop
	 * @param individuals
	 */
	
	protected void addSymmetric(SwoopResource prop, Collection individuals) throws OWLException {
		SwoopResource center = null;
		if (currentObject() != null && individuals.contains(currentObject())) {
			center = getResource(currentObject());
		}
		
		for (Iterator objectIter = individuals.iterator(); objectIter.hasNext();) {
			SwoopResource object = getResource((OWLObject)objectIter.next());
			
			if ((center != null)){
				if (!center.equals(object)) {
					add(center, prop, object);
				}
			} else {
				for (Iterator subjectIter = individuals.iterator(); subjectIter.hasNext();) {
					SwoopResource subject = getResource((OWLObject) subjectIter.next());

					if (!subject.equals(object)) {
						add(subject, prop, object);
					}
				}
			}
		}
	}
	
	protected void addType(OWLObject obj, String type) throws OWLException {
		add(getResource(obj), getResource(owl.getInstanceOf()), getResource(type));
	}
	
	protected void addType(OWLObject obj) throws OWLException {
		if (obj instanceof OWLClass) {
			OWLClass class_ = (OWLClass)obj;
			if ((class_.getURI() == null) || !owl.getThing().equals(class_.getURI().toString())) {
				addType(obj, owl.getClass_());
			}
		}
		if (obj instanceof OWLBooleanDescription) {
			addType(obj, owl.getClass_());
		} else if (obj instanceof OWLRestriction) {
			addType(obj, owl.getRestriction());
		} else if (obj instanceof OWLOntology) {
			addType(obj, owl.getOntology());
		} else if (obj instanceof OWLObjectProperty) {
			addType(obj, owl.getObjectProperty());
		} else if (obj instanceof OWLDataProperty) {
			addType(obj, owl.getDatatypeProperty());
		} else if (obj instanceof OWLAnnotationProperty) {
			addType(obj, owl.getAnnotationProperty());
		} else if (obj instanceof OWLDataEnumeration) {
			addType(obj, owl.getDataRange());
		} else if (obj instanceof OWLDataType) {
			addType(obj, owl.getDatatype());
		} else if (obj instanceof OWLDifferentIndividualsAxiom) {
			addType(obj, owl.getAllDifferent());
		} else if (obj instanceof OWLIndividual) {
			boolean needOWLThing = true;
			OWLIndividual individual = (OWLIndividual) obj;
			for (Iterator typeIter = individual.getTypes(ontology).iterator(); typeIter.hasNext();) {
				needOWLThing = false;
				add(getResource(obj), getResource(owl.getInstanceOf()), getRDFNode((OWLObject)typeIter.next()));
			}
			if (needOWLThing) {
				add(getResource(obj), getResource(owl.getInstanceOf()), getResource(owl.getThing()));
			}
		}
	}
	
	/**
	 * Check if object has already been rendererd.
	 * @param parent
	 * @param object
	 * @return
	 */
	protected boolean checkRendered(OWLObject parent, OWLObject object) {
		return checkRendered(parent, object, true);
	}
	
	protected boolean checkRendered(OWLObject parent, OWLObject object, boolean change) {
		
		Object objKey = getKey(object);
		
		if (rendered.contains(objKey)) {
			return true;
		}
		
		if (change) {
			rendered.add(objKey);
		}
		return false;
	}
	
	protected void createModel(String physicalURI) throws OWLException {
		try {
			
			nodeFactory = nodeProvider.getNodeFactory();
			
			
			// rdfapi is dumb and tries to make a URL out of the URI.  It often fails and returns null.
			// model = RDFManager.createModel(physicalURI, nodeFactory); 
			// So we just make it by hand.
			model=new TransactionableModelImpl(nodeFactory);
			model.setPhysicalURI(physicalURI);
			model.setLogicalURI(physicalURI);
			
		} catch (ModelException e) {
			e.printStackTrace();
			throw new OWLException(e);
		}
	}
	
	protected OWLObject currentObject() {
		if (objectStack.size() == 0) {
			return null;
		}
		return (OWLObject) objectStack.peek();
	}
	
	/**
	 * Returns a key representing the object.  
	 * @param obj
	 * @return
	 */
	protected Object getKey(OWLObject obj) {
		Object objKey = obj;
		if (((obj instanceof OWLDescription) && !(obj instanceof OWLNamedObject)) 
				|| (obj instanceof OWLDataEnumeration)) {

			List v = new Vector();
			v.add(0, objectStack.clone());
			v.add(1, currentClass);
			v.add(2, currentProperty);
			v.add(3, obj);
			objKey = v;
		}
		return objKey;
	}
	
	
	/**
	 * Returns the  model being added to.
	 * @return
	 */
	public Model getModel() {
		return this.model;
	}
	
	/*
	protected RDFNode getRDFNode(OWLObject obj) throws OWLException {
		RDFNode node = null;
		if (obj instanceof OWLDataValue) {
			OWLDataValue dv = (OWLDataValue) obj;
			
			try {
				String data = null;
				if (dv.getValue() != null) 
					data = dv.getValue().toString();
				String dtype = null;
				if (dv.getURI() != null)
					dtype = dv.getURI().toString();
				node = nodeFactory.createLiteral(data, dtype, dv.getLang());
			} catch (ModelException e) {
				throw new OWLException(e);
			}