damlsreader_0_7.java

开发owl的API,提供了W3C规定标准接口,是目前比较少的API.

// The MIT License
//
// Copyright (c) 2004 Evren Sirin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

/*
 * Created on Dec 27, 2003
 *
 */
package org.mindswap.owls.io.impl;

import java.net.URI;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.mindswap.owl.OWLFactory;
import org.mindswap.owl.Util;
import org.mindswap.owls.OWLSFactory;
import org.mindswap.owls.grounding.AtomicGrounding;
import org.mindswap.owls.grounding.Grounding;
import org.mindswap.owls.grounding.MessageMap;
import org.mindswap.owls.grounding.MessageMapList;
import org.mindswap.owls.grounding.UPnPAtomicGrounding;
import org.mindswap.owls.grounding.WSDLAtomicGrounding;
import org.mindswap.owls.process.AtomicProcess;
import org.mindswap.owls.process.Choice;
import org.mindswap.owls.process.CompositeProcess;
import org.mindswap.owls.process.ControlConstruct;
import org.mindswap.owls.process.DataFlow;
import org.mindswap.owls.process.DataFlowElement;
import org.mindswap.owls.process.Parameter;
import org.mindswap.owls.process.Process;
import org.mindswap.owls.process.ProcessComponent;
import org.mindswap.owls.process.ProcessComponentList;
import org.mindswap.owls.process.ProcessModel;
import org.mindswap.owls.process.Sequence;
import org.mindswap.owls.process.Unordered;
import org.mindswap.owls.process.ValueMap;
import org.mindswap.owls.profile.Profile;
import org.mindswap.owls.service.Service;
import org.mindswap.owls.vocabulary.jena.FLAServiceOnt;
import org.mindswap.owls.vocabulary.jena.DAMLS_0_7;

import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.vocabulary.DAML_OIL;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;

/**
 * @author Evren Sirin
 *
 */
public class DAMLSReader_0_7 extends OWLSReaderImpl {
	public static boolean DEBUG = false;
	
	/**
	 * 
	 */
	public DAMLSReader_0_7() {
		version = "0.7";
	}
	
	/* (non-Javadoc)
	 * @see org.mindswap.DAMLS_0_7.parser.Parser#parse(java.lang.String)
	 */
	public List readAll(URI fileURI) {
		List list = null;
		try {
			Model model = reader.read(fileURI);

			list = createService(fileURI, model);
		} catch(Exception e) {
			error("cannot create service " + fileURI);
			e.printStackTrace();
		}	

		return list;
	}

	
	protected List createService(URI fileURI, Model model) {
		StmtIterator si = model.listStatements(null, RDF.type, DAMLS_0_7.Service.Service);
		List list = new ArrayList();
		
		while(si.hasNext()) {
			Resource serviceInfo = si.nextStatement().getSubject();		
			try {
				startService(serviceInfo.toString());
				Resource profileInfo = serviceInfo.getProperty(DAMLS_0_7.Service.presents).getResource();
				Resource processModelInfo = serviceInfo.getProperty(DAMLS_0_7.Service.describedBy).getResource();
				Resource groundingInfo = serviceInfo.getProperty(DAMLS_0_7.Service.supports).getResource();
				
				Service service = OWLSFactory.createService(serviceInfo);
				service.setFileURI(fileURI);
				service.setOWLSVersion(version);
	
				createProcessModel(service, processModelInfo);
				createProfile(service, profileInfo);		
				createGrounding(service, groundingInfo);
				
				if(!errorOccurred)
					list.add(service);
				
				finishService(serviceInfo.toString());				
			} catch (Exception e) {
				error("cannot create service " + serviceInfo);
				e.printStackTrace();
			}
		}
		
		return list;		
	}

	private void createProcessModel(Service service, Resource processModelInfo) {	
		Resource processInfo = processModelInfo.getProperty(DAMLS_0_7.Process.hasProcess).getResource();
		
		ProcessModel processModel = OWLSFactory.createProcessModel(processModelInfo);
		Process process = createProcess(service, processInfo);
		
		processModel.setProcess(process);
		processModel.setService(service);	
	}

	private boolean isProcess(Resource processInfo) {
		return processInfo.hasProperty(RDFS.subClassOf, DAMLS_0_7.Process.AtomicProcess) ||
			   processInfo.hasProperty(RDFS.subClassOf, DAMLS_0_7.Process.CompositeProcess) ||
			   processInfo.hasProperty(RDFS.subClassOf, DAMLS_0_7.Process.SimpleProcess);
	}
		
	public Process createProcess(Service service, Resource processInfo) {	
		if(!isProcess(processInfo))
			throw new RuntimeException("The process is neither atomic nor a sequence: " + processInfo.getURI());
			
		Process process = null;	
		if(processInfo.hasProperty(RDFS.subClassOf, DAMLS_0_7.Process.AtomicProcess))
			process = createAtomicProcess(service, processInfo);
		if(processInfo.hasProperty(RDFS.subClassOf, DAMLS_0_7.Process.CompositeProcess))
			process = createCompositeProcess(service, processInfo);
	
		createProcessParams(process, processInfo);		
		createDefaultValues(process.getDefaultValues(), processInfo);
		createDataFlow(process, processInfo);	
				
		process.setService(service);
		
		return process;
	}
	
	private AtomicProcess createAtomicProcess(Service service, Resource processInfo) {	
		AtomicProcess process =	OWLSFactory.createAtomicProcess(processInfo);
		
		return process;
	}

	private CompositeProcess createCompositeProcess(Service service, Resource processInfo) {
		Resource composedInfo = null;

		StmtIterator s = processInfo.listProperties(RDFS.subClassOf);
		while(s.hasNext()) {
			composedInfo = s.nextStatement().getResource();
			if(composedInfo.hasProperty(DAML_OIL.onProperty, DAMLS_0_7.Process.composedOf)) {
				composedInfo = composedInfo.getProperty(DAML_OIL.toClass).getResource();
				break;		
			}
		}
		
		ControlConstruct controlConstruct = createControlConstruct(service, composedInfo);
		
		CompositeProcess process = OWLSFactory.createCompositeProcess(processInfo);
		process.setComposedOf(controlConstruct);
		
		return process;   
	}	
	
	private ProcessComponent createProcessComponent(Service service, Resource processComponentInfo) {
		ProcessComponent processComponent = null;
		
		if(isProcess(processComponentInfo))
			processComponent = createProcess(service, processComponentInfo);
		else
			processComponent = createControlConstruct(service, processComponentInfo);

		return processComponent;
	}	
	
	private List getControlConstructs(Resource info) {
		List list = new ArrayList();
		StmtIterator i = info.listProperties(RDFS.subClassOf);
		while(i.hasNext()) {
			Statement stmt = i.nextStatement();
			list.add(stmt.getResource());
		}
		if(info.hasProperty(DAML_OIL.intersectionOf)) {
			list.addAll(Util.createList(info.getProperty(DAML_OIL.intersectionOf).getResource()));
		}
		
		return list;
	}
		
	private ControlConstruct createControlConstruct(Service service, Resource controlConstructInfo) {
		Resource componentsInfo = null;
		
		List list = getControlConstructs(controlConstructInfo);
		Iterator i = list.iterator();
		while(i.hasNext()) {
			Resource r = (Resource) i.next();
			if(r.hasProperty(RDF.type, DAML_OIL.Restriction) 
			&& r.hasProperty(DAML_OIL.onProperty, DAMLS_0_7.Process.components)) {
				componentsInfo = r.getProperty(DAML_OIL.toClass).getResource();
				break;
			}				
		}
		
		ControlConstruct cc = null;
		if(list.isEmpty())
			return null;
		else if(list.contains(DAMLS_0_7.Process.Sequence))
			cc = createSequence(service, componentsInfo);
		else if(list.contains(DAMLS_0_7.Process.Choice))
			cc = createChoice(service, componentsInfo);
		else if(list.contains(DAMLS_0_7.Process.Unordered))
			cc = createUnordered(service, componentsInfo);
		else
			error("Don't know how to read the control construct " + list);
		
		return cc;
	}	
	
	private Sequence createSequence(Service service, Resource sequenceInfo) {
		Sequence sequence = OWLSFactory.createSequence(sequenceInfo);

		createComponents(service, sequence, sequenceInfo);		
		
		return sequence;
	}	
	
	private Unordered createUnordered(Service service, Resource unorderedInfo) {
		Unordered unordered = OWLSFactory.createUnordered(unorderedInfo);

		createComponents(service,unordered, unorderedInfo);		
		
		return unordered;
	}		

	private Choice createChoice(Service service, Resource choiceInfo) {
		Choice choice = OWLSFactory.createChoice(choiceInfo);

		createComponents(service, choice, choiceInfo);		
		
		return choice;
	}
		
	private void createComponents(Service service, ControlConstruct cc, Resource ccInfo) {		
		Resource r = ccInfo.getProperty(DAMLS_0_7.Process.listOfInstancesOf).getResource();
		
		List list = Util.createList(r);
		for(int i = 0; i < list.size(); i++) {
			Resource processComponentInfo = (Resource) list.get(i);
			ProcessComponent processComponent = createProcessComponent(service, processComponentInfo);
			
			if(processComponent == null)
				error("Invalid ProcessComponent description " + processComponentInfo);
			else
				cc.getComponents().add(processComponent);
		}
	}	

	
	private void createDefaultValues(ValueMap defaultValues, Resource processComponentInfo) {
	}

	private void createDataFlow(Process process, Resource processComponentInfo) {
		DataFlow dataFlow = process.getDataFlow();
		StmtIterator i = processComponentInfo.listProperties(DAMLS_0_7.Process.sameValues);
		while(i.hasNext()) {
			Resource sameValuesList = i.nextStatement().getResource();
			Resource value1 = sameValuesList.getProperty(RDF.first).getResource();
			Resource value2 = sameValuesList.getProperty(RDF.rest).getResource().getProperty(RDF.first).getResource();

			Statement stmt;
			
			Resource processName1, paramName1, processName2, paramName2;
			
			//Resource processName1 = value1.getProperty(DAMLS_0_7.Process.atClass).getResource();
			//Resource paramName1   = value1.getProperty(DAMLS_0_7.Process.theProperty).getResource();
			//Resource processName2 = value2.getProperty(DAMLS_0_7.Process.atClass).getResource();
			//Resource paramName2   = value2.getProperty(DAMLS_0_7.Process.theProperty).getResource();

			stmt = value1.getProperty(DAMLS_0_7.Process.theProperty);
			if(stmt.getObject() instanceof Resource)
				paramName1 = stmt.getResource();
			else
				paramName1 = Util.toResource(stmt.getObject().toString());

			stmt = value1.getProperty(DAMLS_0_7.Process.atClass);
			if(stmt.getObject() instanceof Resource)
				processName1 = stmt.getResource();
			else
				processName1 = Util.toResource(stmt.getObject().toString());
			
			stmt = value2.getProperty(DAMLS_0_7.Process.theProperty);
			if(stmt.getObject() instanceof Resource)
				paramName2 = stmt.getResource();
			else
				paramName2 = Util.toResource(stmt.getObject().toString());

			stmt = value2.getProperty(DAMLS_0_7.Process.atClass);
			if(stmt.getObject() instanceof Resource)
				processName2 = stmt.getResource();
			else
				processName2 = Util.toResource(stmt.getObject().toString());
						
			Process p1 = findProcess(process, Util.toURI(processName1));
			Process p2 = findProcess(process, Util.toURI(processName2));
			Parameter param1 = null, param2 = null;
			
			if(p1 == null) {
				error("Cannot find the process data flow refers to " + 
						"\n      process " + processName1 +
						"\n    parameter " + paramName1 +
						"\n data flow in " + process.getURI());
			}
			else {
				param1 = p1.getParameter(Util.toURI(paramName1));
				if(param1 == null) {
					error("Cannot find the parameter data flow refers to " + 
							"\n      process " + processName1 +
							"\n    parameter " + paramName1 +
							"\n data flow in " + process.getURI());					
				}
			}

			if(p2 == null) {
				error("Cannot find the process data flow refers to " +