import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
protected static void renderHierarchy(PrintStream out, OntClass cls, List<Object> occurs, int depth) {
  renderClassDescription(out, cls, depth);
  out.println();

  // recurse to the next level down
  if (cls.canAs(OntClass.class) && !occurs.contains(cls)) {
    for (Iterator<?> i = cls.listSubClasses(true); i.hasNext(); ) {
      OntClass sub = (OntClass) i.next();

      // we push this expression on the occurs list before we recurse
      occurs.add(cls);
      renderHierarchy(out, sub, occurs, depth + 1);
      occurs.remove(cls);
    }
    for (Iterator<?> i = cls.listInstances(); i.hasNext(); ) {
      Individual individual = (Individual) i.next();
      renderURI(out, individual.getModel(), individual.getURI());
      out.print(" [");
      for (Iterator<?> j = individual.listLabels(null); j.hasNext(); ) {
        out.print(((Literal) j.next()).getString() + ", ");
      }
      out.print("] ");
      out.println();
    }
  }
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public static void renderClassDescription(PrintStream out, OntClass c, int depth) {
  indent(out, depth);

  if (c.isRestriction()) {
    renderRestriction(out, (Restriction) c.as(Restriction.class));
  } else {
    if (!c.isAnon()) {
      out.print("Class ");
      renderURI(out, c.getModel(), c.getURI());

      out.print(c.getLocalName());

      out.print(" [");
      for (Iterator<?> i = c.listLabels(null); i.hasNext(); ) {
        out.print(((Literal) i.next()).getString() + ", ");
      }
      out.print("] ");
    } else {
      renderAnonymous(out, c, "class");
    }
  }
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
private void processSingle(OntModel m) {
  for (Iterator<?> i = m.listClasses(); i.hasNext(); ) {
    OntClass c = (OntClass) i.next();
    try {
      // too confusing to list all the restrictions as root classes 
      if (c.isAnon()) {
        continue;
      }

      if (c.hasSuperClass(m.getProfile().THING(), true) || c.getCardinality(m.getProfile().SUB_CLASS_OF()) == 0) {
        // this class is directly descended from Thing
        roots.add(c);
      }
    } catch (Exception e) {
      Log.error("Error during extraction or root Classes from Ontology Model: ", e);
    }
  }
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createCardinalityRestriction(OntProperty p,
		int cardinality) {

	/*
	 * NOTE: the create(Min|Max)CardinalityRestriction(...) methods from
	 * Jena - or the turtle serialization - encodes the cardinality as an
	 * xsd:int, which should be an xsd:nonNegativeInteger according to
	 * https://www.w3.org/TR/owl2-mapping-to-rdf/
	 * 
	 * That's why we create and set the typed literal that represents the
	 * cardinality ourselves.
	 */

	OntClass restriction = this.ontmodel.createCardinalityRestriction(null,
			p, cardinality);
	restriction.removeAll(OWL.cardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL.cardinality, cardAsNonNegativeInteger);
	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createMinCardinalityRestriction(OntProperty p,
		int cardinality) {

	/*
	 * NOTE: the create(Min|Max)CardinalityRestriction(...) methods from
	 * Jena - or the turtle serialization - encodes the cardinality as an
	 * xsd:int, which should be an xsd:nonNegativeInteger according to
	 * https://www.w3.org/TR/owl2-mapping-to-rdf/
	 * 
	 * That's why we create and set the typed literal that represents the
	 * cardinality ourselves.
	 */

	OntClass restriction = this.ontmodel
			.createMinCardinalityRestriction(null, p, cardinality);
	restriction.removeAll(OWL.minCardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL.minCardinality, cardAsNonNegativeInteger);
	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createMaxCardinalityRestriction(OntProperty p,
		int cardinality) {

	/*
	 * NOTE: the create(Min|Max)CardinalityRestriction(...) methods from
	 * Jena - or the turtle serialization - encodes the cardinality as an
	 * xsd:int, which should be an xsd:nonNegativeInteger according to
	 * https://www.w3.org/TR/owl2-mapping-to-rdf/
	 * 
	 * That's why we create and set the typed literal that represents the
	 * cardinality ourselves.
	 */

	OntClass restriction = this.ontmodel
			.createMaxCardinalityRestriction(null, p, cardinality);
	restriction.removeAll(OWL.maxCardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL.maxCardinality, cardAsNonNegativeInteger);
	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
private void mapAndAddSuperClass(ClassInfo ci, OntClass c,
		ClassInfo supertype) {

	Resource mappedResource = map(supertype);

	if (mappedResource == null) {
		MessageContext mc = result.addError(this, 6, supertype.name(),
				ci.name());
		if (mc != null) {
			mc.addDetail(this, 10000, ci.fullName());
		}

	} else {
		c.addSuperClass(mappedResource);
	}
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
/**
 * @param cls
 *            class for which a all-values-from restriction is created
 * @param pi
 *            property
 * @param p
 *            ontology representation of the property
 */
protected void addAllValuesFrom(OntClass cls, PropertyInfo pi, Property p) {

	if (pi.matches(
			OWLISO19150.RULE_OWL_PROP_RANGE_LOCAL_UNIVERSAL_QUANTIFICATION)) {

		Resource range = this.rangeByPropertyInfo.get(pi);

		if (range != null) {

			OntClass restriction = ontmodel
					.createAllValuesFromRestriction(null, p, range);
			cls.addSuperClass(restriction);

		} else {
			/*
			 * The restriction is not created because the range is unknown
			 */
			MessageContext mc = result.addWarning(this, 35, pi.name());
			if (mc != null) {
				mc.addDetail(this, 10001, pi.fullName());
			}
		}
	}
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
/**
 * Creates an ontology class (in the internal {@link #refmodel}), with
 * namespace identified by looking up the prefix of the QName in the
 * configuration of namespaces. Also creates an import of that namespace.
 * 
 * @param qname
 *            identifies a class
 * @return ontology class identified by the qname
 */
private Resource mapClass(String qname) {

	String[] qnamePars = qname.split(":",2);
	String prefix = qnamePars[0];
	String resourceName = qnamePars[1];

	// identify rdf namespace based upon prefix and standard namespaces
	String rdfNs = config.fullNamespace(prefix);
	String location = config.locationOfNamespace(rdfNs);

	String uri = rdfNs + resourceName;

	OntClass c = refmodel.getOntClass(uri);
	if (c == null)
		c = refmodel.createClass(uri);

	// also add import for the namespace
	addImport(rdfNs, location);

	// return correct element definition
	return c;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
@Override
public void map(List<DIF> pojoList, Properties props) {
  // create the base model
  OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
  ontModel.setNsPrefix("dif_v9.8.2", MUDROD_GCMD_DIF_9_8_2);
  ontModel.setNsPrefix("geo", "http://www.opengis.net/ont/geosparql#");
  ontModel.read(SWEET_REPR_DATA_PRODUCT, null, "TURTLE");

  // get the https://sweetontology.net/reprDataProduct/Dataset class reference
  Resource dataset = ontModel.getResource(SWEET_REPR_DATA_PRODUCT_NS + "Dataset");
  // create the https://sweetontology.net/reprDataProduct/PODAACDataset class
  // reference
  OntClass podaacDataset = ontModel.createClass(PODAAC_DATASET + "PODAACDataset");
  // make PODAACDataset a subclass of Dataset
  podaacDataset.addSuperClass(dataset);
  // create an individual for each DIF POJO
  for (DIF dif : pojoList) {
    Individual gcmdDif = podaacDataset.createIndividual(PODAAC_DATASET + dif.getEntryID());
    buildIndividual(ontModel, dif, gcmdDif);
  }
  writeOntologyModel(ontModel, props);
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
@Override
   public final boolean hasSuperTemplate(Template superTemplate)
   {
if (superTemplate == null) throw new IllegalArgumentException("Template cannot be null");
       
       ExtendedIterator<OntClass> it = listSuperClasses(false);
       try
       {
           while (it.hasNext())
           {
               OntClass nextClass = it.next();
               if (nextClass.canAs(Template.class))
               {
                   Template nextTemplate = nextClass.as(Template.class);
                   if (nextTemplate.equals(superTemplate) || nextTemplate.hasSuperTemplate(superTemplate))
                       return true;
               }
           }
       }
       finally
       {
           it.close();
       }
       
       return false;
   }
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public Resource process(Resource resource)
{
    // add UUID as dh:slug value to instances of dh:Container and dh:Item, if they don't have one
    // unlike using STRUUID() in dh:DocumentConstructor, we can cache pages without worrying about reusing slugs
    if (!resource.hasProperty(DH.slug))
    {
        Statement typeStmt = resource.getProperty(RDF.type);
        if (typeStmt != null && typeStmt.getObject().isURIResource())
        {
            OntClass ontClass = getOntology().getOntModel().getOntClass(typeStmt.getResource().getURI());
            if (ontClass != null)
            {
                // cannot use ontClass.hasSuperClass() here as it does not traverse the chain
                Set<Resource> superClasses = JenaUtil.getAllSuperClasses(ontClass);
                if (superClasses.contains(DH.Container) || superClasses.contains(DH.Item))
                    resource.addLiteral(DH.slug, UUID.randomUUID().toString());
            }
        }
    }

    return resource;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public TurtleInputPanel(OntClass clazz) {
	super(new BorderLayout());
	this.clazz = clazz;

	add(new JScrollPane(turtleTextArea), CENTER);

	turtleTextArea.setText("<#changeme> a <" + clazz.getURI() + ">\n\n\n.");

	JPanel buttonPanel = new JPanel();
	buttonPanel.setLayout(new BorderLayout());
	JButton validateButton = new DeselectingButton(new AbstractAction(
			"Validate") {
		@Override
		public void actionPerformed(ActionEvent arg0) {
			getContentAsModel();
		}
	});
	buttonPanel.add(errors, CENTER);
	errors.setOpaque(false);
	buttonPanel.add(validateButton, EAST);
	add(buttonPanel, SOUTH);
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
/**
 * Parse OWL ontology files using Apache Jena
 */
@Override
public void parse(Ontology ont, OntModel m) {
  this.ont = ont;
  for (Iterator<OntClass> i = rootClasses(m); i.hasNext(); ) {
    OntClass c = i.next();

    //dont deal with anonymous classes
    if (c.isAnon()) {
      continue;
    }

    parseClass(c, new ArrayList<>(), 0);
  }
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
/**
 * Parses out all root classes of the given 
 * {@link org.apache.jena.ontology.OntModel}
 * @param m the {@link org.apache.jena.ontology.OntModel} we wish to obtain 
 * all root classes for.
 * @return an {@link java.util.Iterator} of {@link org.apache.jena.ontology.OntClass}
 * elements representing all root classes.
 */
@Override
public Iterator<OntClass> rootClasses(OntModel m) {
  Iterator<?> i = m.listClasses();
  if (i.hasNext() && i.next() instanceof OntClass) {
    //assume ontology has root classes
    processSingle(m);
  } else {
    //check for presence of aggregate/collection ontologies such as sweetAll.owl
    processCollection(m);
  }

  return roots.iterator();
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createQCardinalityRestriction(OntProperty p,
		int cardinality, Resource range) {
	/*
	 * NOTE: We cannot use the create(Min|Max)CardinalityQRestriction(...)
	 * methods from the Jena API, because they throw the following
	 * exception: org.apache.jena.ontology.ProfileException: Attempted to
	 * use language construct CARDINALITY_Q that is not supported in the
	 * current language profile: OWL Full
	 * 
	 * So, we use a workaround to create the qualified cardinality
	 * restriction. For further details, see
	 * http://stackoverflow.com/questions/20562107/how-to-add-qualified-
	 * cardinality-in-jena
	 */

	OntClass restriction = this.ontmodel.createCardinalityRestriction(null,
			p, cardinality);
	restriction.removeAll(OWL.cardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL2.qualifiedCardinality,
			cardAsNonNegativeInteger);
	restriction.addProperty(OWL2.onClass, range);

	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createQMinCardinalityRestriction(OntProperty p,
		int cardinality, Resource range) {
	/*
	 * NOTE: We cannot use the create(Min|Max)CardinalityQRestriction(...)
	 * methods from the Jena API, because they throw the following
	 * exception: org.apache.jena.ontology.ProfileException: Attempted to
	 * use language construct CARDINALITY_Q that is not supported in the
	 * current language profile: OWL Full
	 * 
	 * So, we use a workaround to create the qualified cardinality
	 * restriction. For further details, see
	 * http://stackoverflow.com/questions/20562107/how-to-add-qualified-
	 * cardinality-in-jena
	 */

	OntClass restriction = this.ontmodel
			.createMinCardinalityRestriction(null, p, cardinality);
	restriction.removeAll(OWL.minCardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL2.minQualifiedCardinality,
			cardAsNonNegativeInteger);
	restriction.addProperty(OWL2.onClass, range);

	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass createQMaxCardinalityRestriction(OntProperty p,
		int cardinality, Resource range) {
	/*
	 * NOTE: We cannot use the create(Min|Max)CardinalityQRestriction(...)
	 * methods from the Jena API, because they throw the following
	 * exception: org.apache.jena.ontology.ProfileException: Attempted to
	 * use language construct CARDINALITY_Q that is not supported in the
	 * current language profile: OWL Full
	 * 
	 * So, we use a workaround to create the qualified cardinality
	 * restriction. For further details, see
	 * http://stackoverflow.com/questions/20562107/how-to-add-qualified-
	 * cardinality-in-jena
	 */

	OntClass restriction = this.ontmodel
			.createMaxCardinalityRestriction(null, p, cardinality);
	restriction.removeAll(OWL.maxCardinality);
	Literal cardAsNonNegativeInteger = ontmodel.createTypedLiteral(
			cardinality,
			"http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
	restriction.addLiteral(OWL2.maxQualifiedCardinality,
			cardAsNonNegativeInteger);
	restriction.addProperty(OWL2.onClass, range);

	return restriction;
}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
public OntClass addClassDefinition(ClassInfo ci) {

		if (finalized) {
			this.result.addWarning(this, 3, ci.name());
			return null;
		}

		// create the Class <OWL>
		OntClass c = ontmodel
				.createClass(computeReference(getPrefix(), normalizedName(ci)));

		this.ontClassByClassInfo.put(ci, c);
		this.resourceByClassInfo.put(ci, c);

		applyDescriptorTargets(c, ci, DescriptorTarget.AppliesTo.CLASS);

		if (ci.isAbstract()
				&& ci.matches(OWLISO19150.RULE_OWL_CLS_19150_2_ISABSTRACT)) {
			this.ontmodel.setNsPrefix(OWLISO19150.PREFIX_ISO_19150_2,
					OWLISO19150.RDF_NS_ISO_19150_2);
			c.addLiteral(ISO19150_2.isAbstract,
					ontmodel.createTypedLiteral(true));
		}

		addCustomSubClassOf(c, ci);
		addConstraintDeclarations(c, ci);

		// NOTE: properties are created once all classes have been created

		return c;
	}
 

import org.apache.jena.ontology.OntClass; //导入依赖的package包/类
protected Map<Property, Parameter> addSuperParameters(Template template, Map<Property, Parameter> args)
{
    if (template == null) throw new IllegalArgumentException("Template Set cannot be null");        
    if (args == null) throw new IllegalArgumentException("Parameter Map cannot be null");        
    
    ExtendedIterator<OntClass> superIt = template.listSuperClasses();
    try
    {
        while (superIt.hasNext())
        {
            OntClass superClass = superIt.next();
            if (superClass.canAs(Template.class))
            {
                Template superTemplate = superClass.as(Template.class);
                Map<Property, Parameter> superArgs = superTemplate.getLocalParameters();
                Iterator<Entry<Property, Parameter>> entryIt = superArgs.entrySet().iterator();
                while (entryIt.hasNext())
                {
                    Entry<Property, Parameter> entry = entryIt.next();
                    args.putIfAbsent(entry.getKey(), entry.getValue()); // reject Parameters for existing predicates
                }
                
                addSuperParameters(superTemplate, args);  // recursion to super class
            }
        }
    }
    finally
    {
        superIt.close();
    }

    return args;
}