krssconverter.java

来自「Semantic Web Ontology Editor」· Java 代码 · 共 902 行 · 第 1/4 页

package org.mindswap.swoop.utils.owlapi;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.StreamTokenizer;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
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 org.apache.xerces.impl.dv.XSSimpleType;
import org.mindswap.pellet.datatypes.Datatype;
import org.mindswap.pellet.datatypes.XSDDecimal;
import org.mindswap.pellet.exceptions.UnsupportedFeatureException;
import org.mindswap.pellet.utils.ATermUtils;
import org.mindswap.pellet.utils.AlphaNumericComparator;
import org.mindswap.swoop.utils.owlapi.CorrectedRDFRenderer;
import org.semanticweb.owl.model.OWLClass;
import org.semanticweb.owl.model.OWLDataFactory;
import org.semanticweb.owl.model.OWLDescription;
import org.semanticweb.owl.model.OWLDisjointClassesAxiom;
import org.semanticweb.owl.model.OWLEntity;
import org.semanticweb.owl.model.OWLEquivalentClassesAxiom;
import org.semanticweb.owl.model.OWLException;
import org.semanticweb.owl.model.OWLObjectProperty;
import org.semanticweb.owl.model.OWLOntology;
import org.semanticweb.owl.model.OWLProperty;
import org.semanticweb.owl.model.OWLSubClassAxiom;
import org.semanticweb.owl.model.change.AddClassAxiom;
import org.semanticweb.owl.model.change.AddDomain;
import org.semanticweb.owl.model.change.AddEntity;
import org.semanticweb.owl.model.change.AddEquivalentClass;
import org.semanticweb.owl.model.change.AddInverse;
import org.semanticweb.owl.model.change.AddObjectPropertyRange;
import org.semanticweb.owl.model.change.AddSuperClass;
import org.semanticweb.owl.model.change.AddSuperProperty;
import org.semanticweb.owl.model.change.ChangeVisitor;
import org.semanticweb.owl.model.change.OntologyChange;
import org.semanticweb.owl.model.change.SetFunctional;
import org.semanticweb.owl.model.change.SetInverseFunctional;
import org.semanticweb.owl.model.change.SetSymmetric;
import org.semanticweb.owl.model.change.SetTransitive;
import org.semanticweb.owl.model.helper.OWLBuilder;

import aterm.ATermAppl;

/**
 * Parse and test the cases from DL benchmark suite. This class provides parsing
 * for KRSS files.
 *
 * @author Evren Sirin
 */
public class KRSSConverter {
       public static boolean DEBUG = false;

   public static String base = "http://www.example.org/test#";

       public static boolean FORCE_UPPERCASE = false;

       public final int CLASS= 1;
       public final int DATA_PROP = 2;
       public final int OBJECT_PROP = 3;
       public final int INDIVIDUAL = 4;
       public final int FUNC= 5;
       public final int INV_FUNC = 6;
       public final int SYMM = 7;
       public final int TRANS = 8;
       public final int SUB_CLASS = 9;
       public final int SUB_DPROP = 10;
       public final int SUB_OPROP = 11;
       public final int DATA_DOMAIN= 12;
       public final int OBJ_DOMAIN= 13;
       public final int DATA_RANGE= 14;
       public final int OBJ_RANGE= 15;
       public final int INV_PROP= 16;
       public final int SAME_CLASS = 17;
       public final int DISJ_CLASS = 18;

       private ArrayList terms;

       public void assertTrue(boolean b) {
               if(!b) throw new RuntimeException("assert error");
       }

       public void parseToken(StreamTokenizer in, int token) throws Exception {
               assertTrue(token == in.nextToken());
       }

       public void parseToken(StreamTokenizer in, String token) throws Exception {
           in.nextToken();
               assertTrue(token.equals(in.sval));
       }

       public void skipToken(StreamTokenizer in) throws Exception {
               in.nextToken();
       }

       public boolean peekToken(StreamTokenizer in, int token) throws Exception {
               int next = in.nextToken();
               in.pushBack();
               return (token == next);
       }

       public String getToken(StreamTokenizer in) throws Exception {
               in.nextToken();

               return in.sval;
       }

       public int getInt(StreamTokenizer in) throws Exception {
               in.nextToken();

               return (int) in.nval;
       }

       public double getNumber(StreamTokenizer in) throws Exception {
               in.nextToken();

               return in.nval;
       }

       public ATermAppl getTerm(StreamTokenizer in) throws Exception {
           String token = getToken(in);
           if(FORCE_UPPERCASE)
               token = token.toUpperCase();
               return ATermUtils.makeTermAppl( token );
       }

       public ATermAppl term(String str) throws Exception {
               return ATermUtils.makeTermAppl(str);
       }

       public StreamTokenizer initTokenizer(String file) throws Exception {
               StreamTokenizer in = new StreamTokenizer(new FileReader(file));
               in.lowerCaseMode(false);
               in.commentChar(';');
               in.wordChars('/', '/');
               in.wordChars('_', '_');
               in.wordChars('*', '*');
               in.wordChars('?', '?');
               in.wordChars('%', '%');
               in.wordChars('>', '>');
               in.wordChars('<', '<');
               in.wordChars('=', '=');
               in.quoteChar('|');

               return in;
       }

//      public KnowledgeBase initKB(long timeout) {
//          KnowledgeBase kb = new KnowledgeBase();
//
//              kb = new KnowledgeBase();
//              kb.setTimeout(timeout * 1000);
//
//              return kb;
//      }

       OWLProperty getProperty(StreamTokenizer in, OWLOntology ontology, int type) {

               OWLProperty prop = null;
               try {
                       if (peekToken(in, '(')) {
                               skipToken(in);
                               parseToken(in, "INV");
                               ATermAppl r = getTerm(in);
                               prop = ontology.getObjectProperty(new URI(r.getName()));
                               if (((OWLObjectProperty) prop).getInverses(ontology).size()>0) {
                                       return (OWLObjectProperty) ((OWLObjectProperty) prop).getInverses(ontology).iterator().next();
                               }
                               else {
                                       // create new property q to be inverse of prop and return q
                                       OWLObjectProperty q = (OWLObjectProperty) this.addEntity(ontology, new URI(r.getName()+"_INVERSE"), OBJECT_PROP);
                                       List args = new ArrayList();
                                       args.add(prop);
                                       args.add(q);
                                       this.addAxiom(ontology, INV_PROP, args);
                                       return q;
                               }
                       }
                       else {
                               // simply return property
                               ATermAppl r = getTerm(in);
                               if (type == OBJECT_PROP)
                                       prop = ontology.getObjectProperty(new URI(r.getName()));
                               else
                                       prop = ontology.getDataProperty(new URI(r.getName()));

                               if( prop == null ) {
                                       if (type == OBJECT_PROP)
                                               prop = (OWLObjectProperty) this.addEntity(ontology, new URI(r.getName()), OBJECT_PROP);
                                       else
                                               prop = (OWLObjectProperty) this.addEntity(ontology, new URI(r.getName()), DATA_PROP);
                               }
                       }
               }
               catch (Exception ex) {
                       ex.printStackTrace();
               }
               return prop;
       }

       List parseExprList(StreamTokenizer in, OWLOntology ontology) throws Exception {
           int count = 0;
           while(peekToken(in, '(')) {
               skipToken(in);
               count++;
           }

           List terms = new ArrayList();
           while(true) {
               if(peekToken(in, ')')) {
                   if(count == 0)
                       break;
                   skipToken(in);
                   count--;
                   if(count == 0)
                       break;
               }