import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
/**
 * Reads all the bytes from the specified stream into a temporary buffer,
 * which is necessary because we may need to access the input stream more
 * than once. In other words, this method caches the input stream.
 * 
 * @param stream
 *           The stream to be cached
 */
private void readIntoBuffer(InputStream reader)
{
   try {
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      final int length = 100000;
      byte[] tempBuffer = new byte[length];
      int read = 0;
      do {
         read = reader.read(tempBuffer, 0, length);
         if (read > 0) {
            bos.write(tempBuffer, 0, read);
         }
      }
      while (read > 0);
      mBuffer = bos.toByteArray();
   }
   catch (IOException e) {
      throw new OWLRuntimeException(e);
   }
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public IRI getIRI(String prefixIRI) {
    if (prefixIRI.startsWith("<")) {
        return IRI.create(prefixIRI.substring(1, prefixIRI.length() - 1));
    }
    int sep = prefixIRI.indexOf(':');
    if (sep == -1) {
        if (getDefaultPrefix() != null) {
            return IRI.create(getDefaultPrefix() + prefixIRI);
        } else {
            return IRI.create(prefixIRI);
        }
    } else {
        String prefixName = prefixIRI.substring(0, sep + 1);
        if (!containsPrefixMapping(prefixName)) {
            throw new OWLRuntimeException("Prefix not registered for prefix name: " + prefixName);
        }
        String prefix = getPrefix(prefixName);
        String localName = prefixIRI.substring(sep + 1);
        return IRI.create(prefix, localName);
    }
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
/**
 * @param literal the lexical form
 * @param lang the language; can be null or an empty string, in which case datatype can be any
 *        datatype but not null
 * @param datatype the datatype; if lang is null or the empty string, it can be null or it MUST
 *        be RDFPlainLiteral
 */
public OWLLiteralImpl(@Nonnull String literal, @Nullable String lang,
    @Nullable OWLDatatype datatype) {
    this.literal = new LiteralWrapper(checkNotNull(literal, "literal cannot be null"));
    if (lang == null || lang.isEmpty()) {
        language = "";
        if (datatype == null) {
            this.datatype = RDF_PLAIN_LITERAL;
        } else {
            this.datatype = datatype;
        }
    } else {
        if (datatype != null && !datatype.isRDFPlainLiteral()) {
            // ERROR: attempting to build a literal with a language tag and
            // type different from plain literal
            throw new OWLRuntimeException("Error: cannot build a literal with type: "
                + datatype.getIRI() + " and language: " + lang);
        }
        language = lang;
        this.datatype = RDF_PLAIN_LITERAL;
    }
    hashcode = getHashCode(literal);
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public void render(OWLOntology ontology, PrintWriter writer) throws OWLRendererException {
    try {
        OWLFuncionalSyntaxRefsetObjectRenderer ren = new OWLFuncionalSyntaxRefsetObjectRenderer(ontology,
                writer);
        ontology.accept(ren);
        writer.flush();
    } catch (OWLRuntimeException e) {
        throw new OWLRendererIOException(e);
    }
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
public OWLRuntimeException convert(ElkException e) {
	if (e instanceof ElkFreshEntitiesException)
		return convert((ElkFreshEntitiesException) e);
	else if (e instanceof ElkInconsistentOntologyException)
		return convert((ElkInconsistentOntologyException) e);
	else if (e instanceof ElkInterruptedException)
		return convert((ElkInterruptedException) e);
	else
		return new OWLRuntimeException(e);
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
private OWLOntology loadViaOWLAPI() throws Owl2ParseException {
	try {
		return TestOWLManager.createOWLOntologyManager()
				.loadOntologyFromOntologyDocument(mOntoSource);

	} catch (OWLOntologyCreationException e) {
		throw new Owl2ParseException(e);
	} catch (OWLRuntimeException re) {
		throw new Owl2ParseException(re);
	}
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWL2Datatype getBuiltInDatatype() {
    if (!builtin) {
        throw new OWLRuntimeException(
                iri
                        + " is not a built in datatype.  The getBuiltInDatatype() method should only be called on built in datatypes.");
    } else {
        return OWL2Datatype.getDatatype(iri);
    }
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public boolean parseBoolean() {
    throw new OWLRuntimeException(getClass().getName() + " does not have a boolean value");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public double parseDouble() {
    throw new OWLRuntimeException(getClass().getName() + " does not have a double value");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public float parseFloat() {
    throw new OWLRuntimeException(getClass().getName() + " does not have a float value");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLClass asOWLClass() {
    throw new OWLRuntimeException("Not an OWLClass!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLDatatype asOWLDatatype() {
    throw new OWLRuntimeException("Not an OWLDatatype!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLNamedIndividual asOWLNamedIndividual() {
    throw new OWLRuntimeException("Not an OWLIndividual!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLObjectProperty asOWLObjectProperty() {
    throw new OWLRuntimeException("Not an OWLObjectProperty!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLAnnotationProperty asOWLAnnotationProperty() {
    throw new OWLRuntimeException("Not an annotation property");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLClass asOWLClass() {
    throw new OWLRuntimeException(
            "Not an OWLClass.  This method should only be called if the isAnonymous method returns false!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLObjectProperty asOWLObjectProperty() {
    throw new OWLRuntimeException(
            "Property is not a named property.  Check using the isAnonymous method before calling this method!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLDataProperty asOWLDataProperty() {
    throw new OWLRuntimeException("Not a data property!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLNamedIndividual asOWLNamedIndividual() {
    throw new OWLRuntimeException("Not an individual!");
}
 

import org.semanticweb.owlapi.model.OWLRuntimeException; //导入依赖的package包/类
@Override
public OWLObjectProperty asOWLObjectProperty() {
    throw new OWLRuntimeException("Not an object property");
}