Java Ontology.addImport方法代码示例

import com.hp.hpl.jena.ontology.Ontology; //导入方法依赖的package包/类
private void addImportToJenaModel(String modelName, String importUri, String importPrefix, Model importedOntModel) {
	getTheJenaModel().getDocumentManager().addModel(importUri, importedOntModel, true);
	Ontology modelOntology = getTheJenaModel().createOntology(modelName);
	if (importPrefix == null) {
		try {
			importPrefix = getConfigMgr(getCurrentResource(), getOwlModelFormat(getProcessorContext()))
					.getGlobalPrefix(importUri);
		} catch (ConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	if (importPrefix != null) {
		getTheJenaModel().setNsPrefix(importPrefix, importUri);
	}
	com.hp.hpl.jena.rdf.model.Resource importedOntology = getTheJenaModel().createResource(importUri);
	modelOntology.addImport(importedOntology);
	getTheJenaModel().addSubModel(importedOntModel);
	getTheJenaModel().addLoadedImport(importUri);
	addOrderedImport(importUri);
}
 

import com.hp.hpl.jena.ontology.Ontology; //导入方法依赖的package包/类
private OntModel createInstanceModel(String thisModelName)
			throws IOException,
			ConfigurationException {
		if (instanceDataModels != null && instanceDataModels.containsKey(thisModelName)) {
			return instanceDataModels.get(thisModelName);
		}
		if (editedTboxModels != null && editedTboxModels.containsKey(thisModelName)) {
			return editedTboxModels.get(thisModelName);
		}
		OntModel model = ModelFactory.createOntologyModel(getConfigurationMgr().getOntModelSpec(null));
		model.getDocumentManager().setFileManager(getConfigurationMgr().getJenaDocumentMgr().getFileManager());
		Resource importOnt = model.getResource(getModelName());
		Ontology ont = model.createOntology(thisModelName);
		ont.addImport(importOnt);
		ont.addComment("This ontology model was created by SadlServerPE.", "en");
		model.getDocumentManager().setProcessImports(true);
		model.loadImports();
//		if (logger.isDebugEnabled()) {
			Iterator<String> importItr = model.listImportedOntologyURIs().iterator();
			while (importItr.hasNext()) {
//				logger.debug("Model '" + thisModelName + "' imports '" + importItr.next() + "'");
				System.out.println("Model '" + thisModelName + "' imports '" + importItr.next() + "'");
		}
//		}
		model.getDocumentManager().setProcessImports(false);
		if (instanceDataModels == null) {
			instanceDataModels = new HashMap<String, OntModel>(); 
		}
		instanceDataModels.put(thisModelName, model);
		return model;
	}
 

import com.hp.hpl.jena.ontology.Ontology; //导入方法依赖的package包/类
@Override
	public List<ImportMapping> loadImportedModel(Ontology importingOntology, OntModel importingModel,
			String publicImportUri, String altImportUrl) throws ConfigurationException {
    	// if not given the publicImportUri, then we must have the altImportUrl so find the publicImportUri in mapping
    	if (publicImportUri == null) {
    		if (altImportUrl == null) {
    			throw new ConfigurationException("Must have either a public URI or an actual URL to import a model.");
    		}
    		publicImportUri = getPublicUriFromActualUrl(altImportUrl);
    	}
    	
    	if (importingOntology == null) {
    		throw new ConfigurationException("Importing ontology is null!");
    	}
    	    	    	
    	// if not given altImportUrl, then we must have the publicImportUri so find the altImportUrl in mapping
    	if (altImportUrl == null) {
    		altImportUrl = getAltUrlFromPublicUri(publicImportUri);
    	}
    	
    	String importingOntologyUri = importingOntology.getURI();
    	if (importingOntologyUri == null) {
    		throw new ConfigurationException("Importing ontology '" + importingOntology.toString() + "' does not have an ontology declaration.");
    	}
    	if (!importingOntologyUri.equals(publicImportUri)) {	// don't import to self
	    	// Now load import model (with setCachedModels true so it loads any indirect imports)
	       	// and add all import OntModels to importing mappings
	    	Resource importedOntology = importingModel.createResource(publicImportUri);
	    	importingOntology.addImport(importedOntology);
    	}
//    	this.getJenaDocumentMgr().setCacheModels(true);
   		this.getJenaDocumentMgr().setProcessImports(true);
   		ReadFailureHandler rfh = this.getJenaDocumentMgr().getReadFailureHandler();
   		if (rfh instanceof SadlReadFailureHandler) {
   			((SadlReadFailureHandler)rfh).setSadlConfigMgr(this);
   		}
   		getModelGetter().configureToModel(importingModel);
		importingModel.loadImports();
		if (readError != null) {
			String err = readError;
			readError = null;
			if (importingModel.hasLoadedImport(publicImportUri)) {
				// this must be removed or it will prevent correct loading from another project
				importingModel.removeLoadedImport(publicImportUri);
			}
	   		this.getJenaDocumentMgr().setProcessImports(false);
			throw new ConfigurationException(err);
		}
   		this.getJenaDocumentMgr().setProcessImports(false);
    	
    	List<ImportMapping> map = new ArrayList<ImportMapping>();
		Iterator<String> itr = importingModel.listImportedOntologyURIs(true).iterator();
		while (itr.hasNext()) {
			String impUri = itr.next();
			if (impUri.equals(importingOntology.getURI())) {
				// don't count ourselves as an import
				importingModel.setNsPrefix("", ConfigurationManager.addHashToNonTerminatedNamespace(impUri));
				continue;
			}
			String prefix = importingModel.getNsURIPrefix(ConfigurationManager.addHashToNonTerminatedNamespace(impUri));
			if (prefix == null) {
				prefix = getGlobalPrefix(impUri);
				if (prefix != null) {
					importingModel.setNsPrefix(prefix, ConfigurationManager.addHashToNonTerminatedNamespace(impUri));
				}
			}
			OntModel impModel = importingModel.getImportedModel(impUri);
			String actImpUrl = getAltUrlFromPublicUri(impUri);
			logger.debug("processing importingModel, url = "+actImpUrl);
			ImportMapping im = new ImportMapping(impUri, actImpUrl, null);
			im.setModel(impModel);
			im.setPrefix(prefix);
			map.add(im);
		}	
		this.getJenaDocumentMgr().setProcessImports(false);
//		this.getJenaDocumentMgr().setCacheModels(false);
    	return map;
	}
 

import com.hp.hpl.jena.ontology.Ontology; //导入方法依赖的package包/类
public MeasurementTypeGenerator() {
	
	// prep the namespace prefixes
	namespaces.put("ecso", ecsoPrefix);
	namespaces.put("taxa", taxaPrefix);
	namespaces.put("envo", envoPrefix);
	namespaces.put("pato", patoPrefix);
	namespaces.put("uo", uoPrefix);

	namespaces.put("oboe", AnnotationGenerator.oboe);
	namespaces.put("oboe-core", AnnotationGenerator.oboe_core);
	namespaces.put("oboe-characteristics", AnnotationGenerator.oboe_characteristics);
	
	// retrieve the ECSO ontology
	ecsoModel = ModelFactory.createOntologyModel();
	ecsoModel.read(ecso);
	
	AnnotationGenerator.initializeCache();

	// construct the ontology model for additions
	m = ModelFactory.createOntologyModel();
	
	Ontology ont = m.createOntology(ecso);
	ont.addImport(m.createResource(AnnotationGenerator.oboe));
	m.addSubModel(OntDocumentManager.getInstance().getModel(AnnotationGenerator.oboe));
	
	// properties
	rdfsLabel = ecsoModel.getProperty(AnnotationGenerator.rdfs + "label");
	
	measuresCharacteristic = ecsoModel.getObjectProperty(AnnotationGenerator.oboe_core + "measuresCharacteristic");
	measuresEntity = ecsoModel.getObjectProperty(AnnotationGenerator.oboe_core + "measuresEntity");

	// classes
	entityClass =  ecsoModel.getOntClass(AnnotationGenerator.oboe_core + "Entity");
	characteristicClass = ecsoModel.getOntClass(AnnotationGenerator.oboe_core + "Characteristic");
	measurementTypeClass =  ecsoModel.getOntClass(AnnotationGenerator.oboe_core + "MeasurementType");
	
	// where do we begin with our counting?
	classId = Settings.getConfiguration().getInt("annotator.ontology.classId");
	
	// prep ALL concepts for quick look up
	ExtendedIterator<OntClass> classIter = ecsoModel.listNamedClasses();
	while (classIter.hasNext()) {
		OntClass cls = classIter.next();
		String label = cls.getLabel(null);
		if (label == null) {
			label = cls.getLocalName();
		}
		log.trace("Initializing class label: " + label);
		allConcepts.put(label, cls);
	}
	
}
 

import com.hp.hpl.jena.ontology.Ontology; //导入方法依赖的package包/类
public void run(Configuration configuration) {
    try {
        this.connector.connect();
        final NextPageResolver resolver = configuration.getNextPageResolver();

        int i = 0;
        while (resolver.hasNext()) {
            final String currentId = configuration.getId() + "-" + String.format("%04d", i);
            final String ontoId = configuration.getBaseOntoPrefix() + currentId;

            final String input = resolver.next();
            logger.info("Page " + i+" : "+input);

            final OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM);
            final Ontology ont = model.createOntology(ontoId);
            for (final String imp : configuration.getSchemas()) {
                ont.addImport(ModelFactory.createOntologyModel().createOntology(imp));
            }

            Individual org = model.createIndividual(configuration.getPublisher(), model.createClass(Vocabulary.w3cOrganization));
            model.add(ont, DC.source, input);
            model.add(ont, DC.publisher, org);
            model.add(ont, DC.date, model.createLiteral(new Date().toString()));

            logger.debug("   parsing definitions ...");

            for (InitialDefinition entry : configuration.getInitialDefinitions()) {
                new Crowler(model, configuration, input, input, entry).crawl();
            }

            logger.debug("   opening persist model...");
            final Model persistModel = connector.getModel(ontoId);
            logger.debug("   saving ...");
            persistModel.add(model);
            logger.debug("   closing...");
            connector.closeModel(persistModel);
            logger.debug("   done.");

            i++;
       }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        logger.info("Disconnecting backend.");
        connector.disconnect();
    }
}