owlswriter_0_9.java

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

	
	private void writeProcessParams(Process process, ParameterList params) {
		for(int i = 0; i < params.size(); i++) {
			Parameter paramDesc = params.parameterAt(i);

			Resource restr = ResourceFactory.createResource();
			addStatement(process, RDFS.subClassOf, restr);
			addStatement(restr, RDF.type, OWL.Restriction);
			addStatement(restr, OWL.onProperty, paramDesc);
			addStatement(restr, OWL.cardinality, "1");
			
			addStatement(paramDesc, RDF.type, RDF.Property);
			if(paramDesc instanceof Input)
				addStatement(paramDesc, RDFS.subPropertyOf, OWLS.Process.input);			
			else
				addStatement(paramDesc, RDFS.subPropertyOf, OWLS.Process.output);			
			
			addStatement(paramDesc, RDFS.domain, process);
			addStatement(paramDesc, RDFS.range, paramDesc.getType());
		}
	}

	private void writeCompositeProcess(CompositeProcess process) {			
		addStatement(process, RDF.type, OWL.Class);
		addStatement(process, RDFS.subClassOf, OWLS.Process.CompositeProcess);	
		
		RDFNode cc = writeControlConstruct(process.getComposedOf());
		
		Resource restr = ResourceFactory.createResource();
		addStatement(process, RDFS.subClassOf, restr);		
		addStatement(restr, RDF.type, OWL.Restriction);		
		addStatement(restr, OWL.onProperty, OWLS.Process.composedOf);		
		addStatement(restr, OWL.allValuesFrom, cc);		
	}

	private RDFNode writeProcessComponent(ProcessComponent c) {
		if(c instanceof Process) {
			writeProcess((Process) c);
			return c.getJenaResource();
		}
		else 
			return writeControlConstruct((ControlConstruct) c);
	}	
		
	private RDFNode writeControlConstruct(ControlConstruct construct) {			
		RDFNode cc = null;
		if(construct instanceof Sequence)
			cc = writeSequence((Sequence) construct);

//		Resource restr = ResourceFactory.createResource();
//		addStatement(restr, RDF.type, OWL.Restriction);
//		addStatement(restr, OWL.onProperty, OWLS.Process.composedOf);
//		addStatement(restr, OWL.allValuesFrom, cc);
		
		return cc;
	}
	
	private RDFNode writeSequence(Sequence sequence) {
		RDFNode components = writeComponents(sequence.getComponents());
		Resource restr = ResourceFactory.createResource();		
		addStatement(restr, RDF.type, OWL.Restriction);
		addStatement(restr, OWL.onProperty, OWLS.Process.components);
		addStatement(restr, OWL.allValuesFrom, components);
		
		RDFList list = model.createList(new RDFNode[] {Util.toResource(OWLS.Process.Sequence), restr});
		
		Resource c = ResourceFactory.createResource();
		addStatement(c, RDF.type, OWL.Class);
		addStatement(c, OWL.intersectionOf, list);
		
		return c;
	}
	
	private RDFNode writeComponents(ProcessComponentList list) {
		RDFNode[] elems = new RDFNode[list.size()];
		for(int i = 0; i < list.size(); i++) {
			ProcessComponent c = list.processComponentAt(i);
			
			elems[i] = writeProcessComponent(c);
		}
		
		Resource c = ResourceFactory.createResource();
		addStatement(c, RDF.type, OWL.Class);
		addStatement(c, OWLS.Process.listOfInstancesOf, model.createList(elems));
		return c;
	}

	private void writeDataFlow(Process process) {
		DataFlow df = process.getDataFlow();
		for(int i = 0; i < df.size(); i++) {
			DataFlowElement dfe = df.dfeAt(i);
						
			RDFNode[] elems = new RDFNode[dfe.size()];
			for(int j = 0; j < dfe.size(); j++) {
				Parameter p = dfe.parameterAt(j);
				elems[j] = ResourceFactory.createResource();
				addStatement(elems[j], RDF.type, OWLS.Process.ValueOf);
				addStatement(elems[j], OWLS.Process.theProperty, p);
				if(p.getProcess() != null)
					addStatement(elems[j], OWLS.Process.atClass, p.getProcess());
			}			
			addStatement(process, OWLS.Process.sameValues, model.createList(elems));
		}
		
	}

	private void writeDefaultValues(Process process) {
		ValueMap values = process.getDefaultValues();
		Iterator i = values.entrySet().iterator();
		while(i.hasNext()) {
			Map.Entry entry = (Map.Entry) i.next();
			URI p = ((Parameter) entry.getKey()).getURI();
			String value = entry.getValue().toString();

			Resource restr = ResourceFactory.createResource();
			addStatement(restr, RDF.type, OWL.Restriction);
			addStatement(restr, OWL.onProperty, p);
			addStatement(restr, OWL.hasValue, value);
			
			addStatement(process, RDFS.subClassOf, restr);			
		}
	}
	
	private void writeGrounding(Grounding grounding) {
		boolean isWSDL = false;
		boolean isUPnP = false;
		
		addStatement(grounding, OWLS.Service.supportedBy, grounding.getService());
		
		Iterator i = grounding.getAtomicGroundings().iterator();
		while(i.hasNext()) {
			Object n = i.next();
			AtomicGrounding ag = (AtomicGrounding) n;
			isWSDL = isWSDL || (ag instanceof WSDLAtomicGrounding);
			isUPnP = isUPnP && (ag instanceof UPnPAtomicGrounding);
			
			if(ag instanceof WSDLAtomicGrounding) {
				addStatement(grounding, OWLS.Grounding.hasAtomicProcessGrounding, ag);
				writeWSDLGrounding((WSDLAtomicGrounding) ag);
			}
			else if(ag instanceof UPnPAtomicGrounding) {
				addStatement(grounding, OWLS.Grounding.hasAtomicProcessGrounding, ag);
				writeUPnPGrounding((UPnPAtomicGrounding) ag);
			}			
		}
		
		addStatement(grounding, OWLS.Service.supportedBy, grounding.getService());
		if(isWSDL)
			addStatement(grounding, RDF.type, OWLS.Grounding.WsdlGrounding);
		else if(isUPnP)
			addStatement(grounding, RDF.type, FLAServiceOnt.UPnPGrounding);
	}

	private void writeWSDLGrounding(WSDLAtomicGrounding grounding) {
		addStatement(grounding, RDF.type, OWLS.Grounding.WsdlAtomicProcessGrounding);
		addStatement(grounding, OWLS.Grounding.wsdlDocument, grounding.getWSDL());
		addStatement(grounding, OWLS.Grounding.owlsProcess, grounding.getProcess());
		
		
		try {
			addStatement(grounding, OWLS.Grounding.wsdlInputMessage, grounding.getInputMessage());
			addStatement(grounding, OWLS.Grounding.wsdlOutputMessage, grounding.getOutputMessage());
		} catch (Exception e) {
		}
		
		Resource opDesc = ResourceFactory.createResource();
		addStatement(grounding, OWLS.Grounding.wsdlOperation, opDesc);
		addStatement(opDesc, RDF.type, OWLS.Grounding.WsdlOperationRef);
		if(grounding.getPortType() != null)
			addStatement(opDesc, OWLS.Grounding.portType, grounding.getPortType());
		addStatement(opDesc, OWLS.Grounding.operation, grounding.getOperation());
		
		writeWSDLGroundingParams(grounding, true);
		writeWSDLGroundingParams(grounding, false);
	}

	private void writeWSDLGroundingParams(WSDLAtomicGrounding grounding, boolean writeInputs) {
		MessageMapList messageMapList;
		if(writeInputs)
			messageMapList = grounding.getInputMap();
		else
			messageMapList = grounding.getOutputMap();

		if(messageMapList.size() == 0)
			return;
				
		RDFNode[] elements = new RDFNode[messageMapList.size()];
		for(int i = 0; i < messageMapList.size(); i++) {
			MessageMap map = messageMapList.messageMapAt(i);

			Resource r = ResourceFactory.createResource();
			addStatement(r, RDF.type, OWLS.Grounding.wsdlMessageMap);
			addStatement(r, OWLS.Grounding.owlsParameter, map.getOWLSParameter());
			addStatement(r, OWLS.Grounding.wsdlMessagePart, map.getGroundingParameter());
			if(map.getTransformation() != null)
				addStatement(r, OWLS.Grounding.xsltTransformation, toRDF(map.getTransformation(), true));
			elements[i] = r;
		}	

		RDFList list = model.createList(elements);
		if(writeInputs)
			addStatement(grounding, OWLS.Grounding.wsdlInputMessageParts, list);
		else 
			addStatement(grounding, OWLS.Grounding.wsdlOutputMessageParts, list);			
		
	}
	
	private void writeUPnPGrounding(UPnPAtomicGrounding grounding) {
		addStatement(grounding, RDF.type, FLAServiceOnt.UPnPAtomicProcessGrounding);
		addStatement(grounding, OWLS.Grounding.owlsProcess, grounding.getProcess());
		
		addStatement(grounding, FLAServiceOnt.upnpCommand, grounding.getUPnPAction());
		addStatement(grounding, FLAServiceOnt.upnpDeviceURL, grounding.getUPnPDescription());
		addStatement(grounding, FLAServiceOnt.upnpServiceID, grounding.getUPnPService());
				
		writeUPnPGroundingParams(grounding, true);
		writeUPnPGroundingParams(grounding, false);	
	}

	private void writeUPnPGroundingParams(UPnPAtomicGrounding grounding, boolean writeInputs) {
		MessageMapList messageMapList;
		if(writeInputs)
			messageMapList = grounding.getInputMap();
		else
			messageMapList = grounding.getOutputMap();

		if(messageMapList.size() == 0)
			return;
				
		RDFNode[] elements = new RDFNode[messageMapList.size()];
		for(int i = 0; i < messageMapList.size(); i++) {
			MessageMap map = messageMapList.messageMapAt(i);

			Resource r = ResourceFactory.createResource();
			addStatement(r, RDF.type, FLAServiceOnt.UPnPMap);
			addStatement(r, OWLS.Grounding.owlsParameter, map.getOWLSParameter());
			addStatement(r, FLAServiceOnt.upnpParameter, map.getGroundingParameter());
			if(map.getTransformation() != null)
				addStatement(r, OWLS.Grounding.xsltTransformation, toRDF(map.getTransformation(), true));
			elements[i] = r;
		}	

		RDFList list = model.createList(elements);
		if(writeInputs)
			addStatement(grounding, FLAServiceOnt.UPnPInputMapping, list);
		else 
			addStatement(grounding, FLAServiceOnt.UPnPOutputMapping, list);			
		
	}
	
}