OWLIndividual.java

Go to the documentation of this file.

package edu.tum.cs.ias.knowrob.owl;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import edu.tum.cs.ias.knowrob.prolog.PrologInterface;
import edu.tum.cs.ias.knowrob.prolog.PrologQueryUtils;


public class OWLIndividual extends OWLThing {
        

        protected Vector<OWLClass> types;

        protected Map<String, Vector<String>> data_props;
        
        protected Map<String, Vector<String>> obj_props;
        


        protected OWLIndividual(String iri, String label) {
                
                super(iri, label);
                this.types = new Vector<OWLClass>();
                data_props = Collections.synchronizedMap(new HashMap<String, Vector<String>>());
                obj_props = Collections.synchronizedMap(new HashMap<String, Vector<String>>());
        }


        protected OWLIndividual(OWLThing ind) {
                this(ind.getIRI(), ind.getLabel());
        }
        
        
        public static OWLIndividual getOWLIndividual(String iri, String label) {

                // return exact match if available
                if(identifiers.containsKey(iri) && identifiers.get(iri) instanceof OWLIndividual) {
                        return (OWLIndividual) identifiers.get(iri);                    
                }
                
                // create OWLIndividual from higher-level objects if the existing object for this IRI has a more abstract type
                OWLIndividual res = new OWLIndividual(OWLThing.getOWLThing(iri, label));
                identifiers.put(iri, res);
                return res;
        }
        
        public static OWLIndividual getOWLIndividual(String iri) {
                return getOWLIndividual(iri, null); 
        }
        
        
        
        public static OWLIndividual getOWLIndividualOfClass(String cl) {
                
                OWLIndividual res = getOWLIndividual(getUniqueID(cl), null);
                res.addType(OWLClass.getOWLClass(cl));
                
                return res;
        }


        public Vector<OWLClass> getTypes() {
                return types;
        }

        public void setTypes(Vector<OWLClass> types) {
                this.types.clear();
                this.types.addAll(types);
        }

        public void addType(OWLClass type) {
                types.add(type);
        }

        public void addTypes(Collection<OWLClass> t) {
                types.addAll(t);
        }

        public boolean hasType(OWLClass type) {
                
                if(types.contains(type))
                        return true;
                else
                        return false;
        }
        
        public boolean hasType(String type_iri) {
                
                for(OWLClass c : types) {
                        if(c.getIRI().equals(type_iri) || c.getShortName().equals(type_iri))
                                return true;
                }
                return false;
        }

        public Map<String, Vector<String>> getDataProperties() {
                return data_props;
        }
        
        public Map<String, Vector<String>> getObjProperties() {
                return obj_props;
        }
        
        public void setDataProperties(Map<String, Vector<String>> properties) {
                this.data_props.clear();
                this.data_props.putAll(properties);
        }
        
        public void setObjProperties(Map<String, Vector<String>> properties) {
                this.obj_props.clear();
                this.obj_props.putAll(properties);
        }

        
        public boolean hasDataProperty(String property) {
                if(data_props.containsKey(property))
                        return true;
                else return false;
        }
        
        public boolean hasObjProperty(String property) {
                if(obj_props.containsKey(property))
                        return true;
                else return false;
        }

        public Vector<String> getDataPropValues(String property) {
                return data_props.get(property);
        }
        
        public Vector<String> getObjPropValues(String property) {
                return obj_props.get(property);
        }
        
        public void addDataPropValue(String property, String value) {
                
                if(!data_props.containsKey(property))
                        data_props.put(property, new Vector<String>());
                
                data_props.get(property).add(value);
        }
        
        public void addObjPropValue(String property, String value) {
                
                if(!obj_props.containsKey(property))
                        obj_props.put(property, new Vector<String>());
                
                obj_props.get(property).add(value);
        }
        
        

        public void writeToProlog() {
                
                // check whether instance need to be written to avoid infinite loops
                if(!this.needsSaveToProlog()) {
                        return;
                }

                // set flag that this class has been written 
                // (in the beginning of this method to avoid problems with infinite 
                // recursion due to recursive relations)
                this.setSaveToProlog(false);


                // check for deleted types
                for(String t : PrologQueryUtils.readTypesOfInstance(iri)) {
                        
                        OWLClass cl = OWLClass.getOWLClass(OWLThing.removeSingleQuotes(t));
                        if(!types.contains(cl)) {
                                PrologInterface.executeQuery("rdf_retractall('" + iri + "', rdf:type, '" + cl.getIRI() + "')");
                        }
                }

                // set instance types
                for(OWLClass t : types) {
                        if(PrologInterface.executeQuery("rdf_has('" + iri + "', rdf:type, '" + t.getIRI() + "')") == null)
                                PrologInterface.executeQuery("rdf_assert('" + iri + "', rdf:type, '" + t.getIRI() + "')");
                }
                
                
                // write object properties
                for(String p : obj_props.keySet()) {
                        
                        PrologInterface.executeQuery("rdf_retractall('" + iri + "', '"+p+"', _)");
                
                        for(String v : obj_props.get(p)) {
                                PrologQueryUtils.assertObjectPropertyForInst(iri, p, v);
                        }
                }
                
                // write data properties
                for(String p : data_props.keySet()) {

                        PrologInterface.executeQuery("rdf_retractall('" + iri + "', '"+p+"', _)");

                        for(String v : data_props.get(p)) {                             
                                String type = "http://www.w3.org/2001/XMLSchema#string";
                                try {
                                        Float.valueOf(v);
                                        type = "http://www.w3.org/2001/XMLSchema#float";
                                } catch(NumberFormatException e) {}
                                PrologQueryUtils.assertDataPropertyForInst(iri, p, v, type);
                        }
                }
        }
}