owls/grounding/JavaAtomicGroundingImpl.java

	JavaAtomicGroundingImpl.java revision 30
214N/A/*
214N/A * Created on 13.04.2005
967N/A */
214N/Apackage impl.owls.grounding;
214N/A
919N/Aimport java.lang.reflect.InvocationTargetException;
919N/Aimport java.lang.reflect.Method;
919N/Aimport java.net.URI;
919N/Aimport java.net.URL;
919N/A
919N/Aimport org.mindswap.exceptions.ExecutionException;
919N/Aimport org.mindswap.owl.EntityFactory;
919N/Aimport org.mindswap.owl.OWLDataValue;
919N/Aimport org.mindswap.owl.OWLFactory;
919N/Aimport org.mindswap.owl.OWLIndividual;
919N/Aimport org.mindswap.owl.OWLIndividualList;
919N/Aimport org.mindswap.owl.OWLKnowledgeBase;
919N/Aimport org.mindswap.owl.OWLObject;
919N/Aimport org.mindswap.owl.OWLValue;
919N/Aimport org.mindswap.owls.grounding.AtomicGrounding;
919N/Aimport org.mindswap.owls.grounding.JavaAtomicGrounding;
919N/Aimport org.mindswap.owls.grounding.JavaParameter;
214N/Aimport org.mindswap.owls.grounding.JavaVariable;
214N/Aimport org.mindswap.owls.grounding.MessageMapList;
214N/Aimport org.mindswap.owls.process.Input;
214N/Aimport org.mindswap.owls.process.Output;
493N/Aimport org.mindswap.owls.process.Parameter;
803N/Aimport org.mindswap.owls.vocabulary.MoreGroundings;
970N/Aimport org.mindswap.owls.vocabulary.OWLS;
493N/Aimport org.mindswap.query.ValueMap;
649N/Aimport org.mindswap.utils.ReflectionUtils;
214N/Aimport org.mindswap.utils.URIUtils;
493N/A
493N/A/**
214N/A * A JavaAtomicGrounding grounds an OWL-S Service to a Java method invocation. The method call
493N/A * is specified by its method signature in an OWL-S Ontology. The driving parts are:
967N/A * <ul>
380N/A *  <li>fully qualified class name</li>
493N/A *  <li>method name</li>
493N/A *  <li>a map of all input parameters (at the time only primitive datatypes and their adapter classes)</li>
967N/A *  <li>an output type (at the time only primitive datatypes and their adapter classes)</li>
 * </ul>
 *
 * @author Michael Daenzer, University of Z�rich
 *
 * @see <a href="http://www.ifi.unizh.ch/ddis/ont/owl_s/MoreGroundings.owl">Grounding Ontology</a>
 * @see org.mindswap.owls.grounding.AtomicGrounding
 * @see org.mindswap.owls.vocabulary.NextOnt
 * @see impl.owls.grounding.AtomicGroundingImpl
 */
public class JavaAtomicGroundingImpl extends AtomicGroundingImpl implements JavaAtomicGrounding {
    /**
     * @param ind
     */
    public JavaAtomicGroundingImpl(OWLIndividual ind) {
        super(ind);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#setClaz(java.lang.String)
     */
    public void setClaz(String claz) {
        setProperty(MoreGroundings.javaClass, claz);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#getClaz()
     */
    public String getClaz() {
        return getPropertyAsString(MoreGroundings.javaClass);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#setMethod(java.lang.String)
     */
    public void setMethod(String method) {
        setProperty(MoreGroundings.javaMethod, method);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#getMethod()
     */
    public String getMethod() {
        return getPropertyAsString(MoreGroundings.javaMethod);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#getDescriptionURL()
     */
    public URL getDescriptionURL() {
        return null;
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#addMessageMap(org.mindswap.owls.process.Parameter, java.lang.String, java.lang.String)
     */
    public void addMessageMap(Parameter owlsParameter,
            String groundingParameter, String xsltTransformation) {
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#getInputMap()
     */
    public MessageMapList getInputMap() {
        return null;
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#getOutputMap()
     */
    public MessageMapList getOutputMap() {
        return null;
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#invoke(org.mindswap.query.ValueMap)
     */
    public ValueMap invoke(ValueMap values) throws ExecutionException {
        return invoke(values, OWLFactory.createKB());
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.AtomicGrounding#invoke(org.mindswap.query.ValueMap, org.mindswap.owl.OWLKnowledgeBase)
     */
    public ValueMap invoke(ValueMap values, OWLKnowledgeBase kb) throws ExecutionException {
        Class claz = null;
        Method method = null;
        Class params[] = null;
        Object paramValues[] = null;
        ValueMap results = new ValueMap();
        Object result = null;

        // get and check class
        String strClaz = getClaz();
        if ((strClaz == null) || (strClaz.equals("")))
            throw new ExecutionException("JavaAtomicGrounding: No Java Class defined in Grounding!");
        // get and check method
        String strMethod = getMethod();
        if ((strMethod == null) || (strMethod.equals("")))
            throw new ExecutionException("JavaAtomicGrounding: No Java Method defined in Grounding!");

        // prepare parameters
        int paramSize = getInputParameters().size();
        params = new Class[paramSize];
        for (int i = 0; i < paramSize; i++)
            params[i] = getJavaParameterTypeAt(i);

        // get class and method reference
        try {
            claz = Class.forName(strClaz);
            method = claz.getDeclaredMethod(strMethod, params);
        } catch (ClassNotFoundException e){
            throw new ExecutionException("JavaAtomicGrounding: Class " + strClaz + " defined in Grounding not found." );
        } catch (NoSuchMethodException e) {
            throw new ExecutionException("JavaAtomicGrounding: Method " + strMethod + " defined in Grounding not found." );
        } catch (Exception e) {
            throw new ExecutionException("JavaAtomicGrounding: " + e.getClass().toString() + " ocurred: " + e.getMessage());
        }

        // prepare inputs
        paramValues = new Object[paramSize];
        for (int i = 0; i < params.length; i++) {

            OWLValue owlValue = values.getValue(getOWLSParameterAt(i));
            if (owlValue.isDataValue())
                paramValues[i] = ReflectionUtils.getCastedObjectFromStringValue(((OWLDataValue) owlValue).getLexicalValue(), params[i]);
            else if (owlValue.isIndividual()) {
                paramValues[i] = getJavaParameterAt(i, (OWLIndividual) owlValue);
            }
            //System.out.println( "Parameter " + i + " " + paramValues[i] );
        }

        // invoke java method
        try {
            Object obj = claz.newInstance();
            if (method.getReturnType().toString().equalsIgnoreCase("void"))
                method.invoke(obj, paramValues);
            else
                result = method.invoke(obj, paramValues);
        } catch (InvocationTargetException e) {
            throw new ExecutionException("JavaAtomicGrounding: Error in executed method\n" + e.getTargetException().toString() + " ocurred: ");
        } catch (Exception e) {
            throw new ExecutionException("JavaAtomicGrounding: Error while executing method\n" + e.getClass().toString() + " ocurred: ");
        }

        // set output
        if (result != null) {
            Parameter param = getOWLSOutput();
            if (param == null)
                throw new ExecutionException("JavaAtomicGrounding: Output in Grounding not specified although method provides a return value.");
            if(param.getParamType().isDataType())
                results.setValue(param, EntityFactory.createDataValue(result));
            else
                results.setValue(param, transformResult(result));
        }

        return results;
    }

    private OWLIndividual transformResult(Object result) {
        JavaVariable output = getOutput();
        if (output == null)
            return null;

        String transformerName = output.getTransformator().trim();
        if (transformerName != null && !transformerName.trim().equals("")) {
            try {
                Class transformerClass = Class.forName(transformerName);
                JavaClassTransformator transformer = (JavaClassTransformator) transformerClass.newInstance();
                return transformer.transformToOWL(result);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    // returns the OWL-S Output Parameter
    private Parameter getOWLSOutput() {
        OWLObject owlsParam = getProperty(MoreGroundings.javaOutput).getProperty(MoreGroundings.owlsParameter);
        return (owlsParam == null) ? null : (Parameter) owlsParam.castTo(Parameter.class);
    }


    // returns the n-th OWL-S Input Parameter
    private Parameter getOWLSParameterAt(int index) {
        JavaParameter param = getInputParamter(index);
        if (param == null)
            return null;

        return param.getOWLSParameter();
    }

    // returns the n-th Parameter of the Java Method specified in the OWL-S JavaAtomicProcessGrounding
    private Class getJavaParameterTypeAt(int index) {
        JavaParameter param = getInputParamter(index);
        if (param == null)
            return null;

        String transformerName = param.getTransformator().trim();
        String javaType = param.getJavaType();
        if (transformerName != null && !transformerName.trim().equals("")) {
            try {
                Class transformerClass = Class.forName(transformerName);
                JavaClassTransformator transformer = (JavaClassTransformator) transformerClass.newInstance();
                return transformer.getJavaClass();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            return null;
        } else {
            return ReflectionUtils.getClassFromString(javaType);
        }
    }

    // returns the n-th Parameter of the Java Method specified in the OWL-S JavaAtomicProcessGrounding
    private Object getJavaParameterAt(int index, OWLIndividual owlValue) {
        JavaParameter param = getInputParamter(index);
        if (param == null)
            return null;

        String transformerName = param.getTransformator().trim();
        String javaType = param.getJavaType();
        if (transformerName != null && !transformerName.trim().equals("")) {
            try {
                Class transformerClass = Class.forName(transformerName);
                JavaClassTransformator transformer = (JavaClassTransformator) transformerClass.newInstance();
                return transformer.transformFromOWL(owlValue);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            return null;
        } else {
            return ReflectionUtils.getClassFromString(javaType);
        }
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#setOutputVar(java.lang.String, java.lang.String, org.mindswap.owls.process.Output)
     */
    public void setOutput(String name, String type, Output owlsParameter) {
        OWLIndividual ind = getOntology().createInstance(MoreGroundings.JavaVariable, URI.create(name));
        ind.setProperty(MoreGroundings.javaType, type);
        ind.setProperty(MoreGroundings.owlsParameter, owlsParameter);
        setProperty(MoreGroundings.javaOutput, ind);
    }

    /* (non-Javadoc)
     * @see org.mindswap.owls.grounding.JavaAtomicGrounding#setInputVar(java.lang.String, java.lang.String, int, org.mindswap.owls.process.Input)
     */
    public void setInputParameter(String name, String type, int index, Input owlsParameter) {
        OWLIndividual ind = getOntology().createInstance(MoreGroundings.JavaParameter, URIUtils.createURI(name));
        ind.setProperty(MoreGroundings.javaType, type);
        ind.setProperty(MoreGroundings.owlsParameter, owlsParameter);
        ind.setProperty(MoreGroundings.paramIndex, Integer.toString(index));
        addProperty(MoreGroundings.hasJavaParameter, ind);
    }

    @Override
    public String getGroundingType() {
        return AtomicGrounding.GROUNDING_JAVA;
    }

    @Override
    public String toString() {
        return getClaz() + "." + getMethod();
    }

    private void removeAll() {
        if (hasProperty(MoreGroundings.javaClass))
            removeProperties(MoreGroundings.javaClass);
        if (hasProperty(MoreGroundings.javaMethod))
            removeProperties(MoreGroundings.javaMethod);

        // TODO an rdf:type property of the related input stays persistent. why????
        if (hasProperty(MoreGroundings.hasJavaParameter)) {
            OWLIndividualList indList = getProperties(MoreGroundings.hasJavaParameter);
            for (int i = 0; i < indList.size(); i++) {
                OWLIndividual ind = indList.individualAt(i);
                if (ind.hasProperty(MoreGroundings.javaType))
                    ind.removeProperties(MoreGroundings.javaType);
                if (ind.hasProperty(MoreGroundings.owlsParameter))
                    ind.removeProperties(MoreGroundings.owlsParameter);
                if (ind.hasProperty(MoreGroundings.paramIndex))
                    ind.removeProperties(MoreGroundings.paramIndex);
                removeProperty(MoreGroundings.hasJavaParameter, ind);
                ind.delete();
            }
        }

        if (hasProperty(MoreGroundings.javaOutput)) {
            OWLIndividual ind = getProperty(MoreGroundings.javaOutput);
            if (ind.hasProperty(MoreGroundings.javaType))
                ind.removeProperties(MoreGroundings.javaType);
            if (ind.hasProperty(MoreGroundings.owlsParameter))
                ind.removeProperties(MoreGroundings.owlsParameter);
            removeProperties(MoreGroundings.javaOutput);
            ind.delete();
        }

        if (hasProperty(MoreGroundings.owlsProcess))
            removeProperties(MoreGroundings.owlsProcess);
        if (hasProperty(OWLS.Grounding.owlsProcess))
            removeProperties(OWLS.Grounding.owlsProcess);
    }

    @Override
    public void delete() {
        removeAll();

        super.delete();
    }

    public JavaParameter getInputParamter(Input input) {
        OWLIndividualList list = getPropertiesAs(MoreGroundings.hasJavaParameter, JavaParameter.class);
        for (int i = 0; i < list.size(); i++) {
            OWLIndividual ind = list.individualAt(i).getProperty(MoreGroundings.owlsParameter);
            if (ind.getURI().equals(input.getURI()))
                return (JavaParameter) list.individualAt(i);
        }
        return null;
    }

    public JavaParameter getInputParamter(int index) {
        OWLIndividualList list = getPropertiesAs(MoreGroundings.hasJavaParameter, JavaParameter.class);
        for (int i = 0; i < list.size(); i++) {
            String curIndex = list.individualAt(i).getProperty(MoreGroundings.paramIndex).getLexicalValue();
            if (Integer.valueOf(curIndex).intValue() == index)
                return (JavaParameter) list.individualAt(i);
        }
        return null;
    }

    public JavaVariable getOutput() {
        return (JavaVariable) getPropertyAs(MoreGroundings.javaOutput, JavaVariable.class);
    }

    public OWLIndividualList getInputParameters() {
        OWLIndividualList list = getPropertiesAs(MoreGroundings.hasJavaParameter, JavaParameter.class);

        list.add("tempPlaceForSwap");
        // loop through every element
        for (int i = 0; i < list.size() - 2; i++) {
            int element = Integer.parseInt(list.individualAt(i).getProperty(
                    MoreGroundings.paramIndex).getLexicalValue());
            int min = Integer.MAX_VALUE;
            int pos = i;
            // find the minimal element in the rest
            for (int j = i + 1; j < list.size() - 1; j++) {
                int temp = Integer.parseInt(list.individualAt(j).getProperty(
                        MoreGroundings.paramIndex).getLexicalValue());
                if (temp < min) {
                    min = temp;
                    pos = j;
                }
            }
            // swap it to the front
            if (min < element) {
                list.set(list.size() -1, list.get(i));
                list.set(i, list.get(pos));
                list.set(pos, list.get(list.size() - 1));
            }
        }

        list.remove(list.size() - 1);
        return list;
    }

    public String getTransformator(JavaVariable variable) {
        return getPropertyAsString(MoreGroundings.transformatorClass);
    }

    public void setTransformator(String transformClass) {
        setProperty(MoreGroundings.transformatorClass, transformClass);
    }
}