Uses of Interface com.hp.hpl.jena.rdf.model.Resource (Jena Framework)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Interface
com.hp.hpl.jena.rdf.model.Resource

Packages that use Resource
com.hp.hpl.jena.assembler
com.hp.hpl.jena.ontology	Provides a set of abstractions and convenience classes for accessing and manipluating ontologies represented in RDF.
com.hp.hpl.jena.rdf.model	A package for creating and manipulating RDF graphs.
com.hp.hpl.jena.reasoner	The Jena2 reasoner subsystem is designed to allow a range of inference engines to be plugged into Jena.
com.hp.hpl.jena.reasoner.rulesys	Provides a selection of simple rule engines for Jena inference models.
com.hp.hpl.jena.reasoner.transitiveReasoner	This package contains a reasoner which supports transitive-reflexive closure of subPropertyOf and subClassOf relations.
com.hp.hpl.jena.shared	This package defines some classes common to the Jena API and SPI levels, in particular the JenaException class from which all Jena-specific exceptions hang, and the interface PrefixMapping for translation to and from QNames.
com.hp.hpl.jena.util	Miscellaneous collection of utility classes.
com.hp.hpl.jena.vocabulary	A package containing constant classes with predefined constant objects for classes and properties defined in well known vocabularies.
jena	A package for some Jena command-line programs, including copying RDF data with representation conversion, eg XML to N3 comparing two RDF files for isomorphism (extended equality) an interface to the ARP RDF parser access to the RDQL interpreter a schema-to-Java generator

Uses of Resource in com.hp.hpl.jena.assembler

Fields in com.hp.hpl.jena.assembler declared as Resource
`static Resource`	`JA.Connectable`
`static Resource`	`JA.Connection`
`static Resource`	`JA.Content`
`static Resource`	`JA.ContentItem`
`static Resource`	`JA.convenient`
`static Resource`	`JA.DefaultModel`
`static Resource`	`JA.DocumentManager`
`static Resource`	`JA.Expanded`
`static Resource`	`JA.ExternalContent`
`static Resource`	`JA.False`
`static Resource`	`JA.FileManager`
`static Resource`	`JA.FileModel`
`static Resource`	`JA.HasFileManager`
`static Resource`	`JA.HasRules`
`static Resource`	`JA.InfModel`
`static Resource`	`JA.LiteralContent`
`static Resource`	`JA.LocationMapper`
`static Resource`	`JA.MemoryModel`
`static Resource`	`JA.minimal`
`static Resource`	`JA.Model`
`static Resource`	`JA.ModelSource`
`static Resource`	`JA.NamedModel`
`static Resource`	`JA.Object`
`static Resource`	`JA.OntModel`
`static Resource`	`JA.OntModelSpec`
`static Resource`	`JA.PrefixMapping`
`static Resource`	`JA.RDBModel`
`static Resource`	`JA.RDBModelSource`
`static Resource`	`JA.ReasonerFactory`
`static Resource`	`JA.ReificationMode`
`static Resource`	`JA.RuleSet`
`static Resource`	`JA.SinglePrefixMapping`
`static Resource`	`JA.standard`
`static Resource`	`JA.This`
`static Resource`	`JA.True`
`static Resource`	`JA.UnionModel`

Methods in com.hp.hpl.jena.assembler that return Resource
`static Resource`	`AssemblerHelp.findSpecificType(Resource root)` Answer the most specific type of `root` that is a subclass of ja:Object.
`static Resource`	`AssemblerHelp.findSpecificType(Resource root, Resource baseType)` Answer the most specific type of `root` that is a subclass of `givenType`.
`static Resource`	`AssemblerHelp.getResource(Statement s)` Answer the resource that is the object of the statement `s`.
`static Resource`	`AssemblerHelp.singleModelRoot(Model singleRoot)` Answer the single resource in `singleRoot` of type `ja:Model`.
`static Resource`	`AssemblerHelp.singleRoot(Model singleRoot, Resource type)` Answer the single resource in `singleRoot` of type `type`.
`static Resource`	`AssemblerHelp.withFullModel(Resource root)` Answer a Resource .equals() to `root`, but in the expanded model.

Methods in com.hp.hpl.jena.assembler that return types with arguments of type Resource
`static java.util.Set<Resource>`	`AssemblerHelp.findAssemblerRoots(Model model)` Answer a Set of the ja:Object resources in the full expansion of the assembler specification model `model`.
`static java.util.Set<Resource>`	`AssemblerHelp.findAssemblerRoots(Model model, Resource type)` Answer a Set of the objects in the full expansion of the assembler specification `model` which have rdf:type `type`, which must be a subtype of `ja:Object`.
`static java.util.Set<Resource>`	`AssemblerHelp.findSpecificTypes(Resource root, Resource baseType)` Answer all the types of `root` which are subtypes of `baseType` and which do not have subtypes which are also types of `root`.

Methods in com.hp.hpl.jena.assembler with parameters of type Resource
`static java.util.Set<Resource>`	`AssemblerHelp.findAssemblerRoots(Model model, Resource type)` Answer a Set of the objects in the full expansion of the assembler specification `model` which have rdf:type `type`, which must be a subtype of `ja:Object`.
`static Resource`	`AssemblerHelp.findSpecificType(Resource root)` Answer the most specific type of `root` that is a subclass of ja:Object.
`static Resource`	`AssemblerHelp.findSpecificType(Resource root, Resource baseType)` Answer the most specific type of `root` that is a subclass of `givenType`.
`static java.util.Set<Resource>`	`AssemblerHelp.findSpecificTypes(Resource root, Resource baseType)` Answer all the types of `root` which are subtypes of `baseType` and which do not have subtypes which are also types of `root`.
`java.lang.Object`	`Assembler.open(Assembler a, Resource root)` Answer `open( a, root, Mode.DEFAULT )`.
`java.lang.Object`	`Assembler.open(Assembler a, Resource root, Mode mode)` The core operation: answer a new object constructed according to the object description hanging from `root`, using the assembler `a` for any sub-objects.
`java.lang.Object`	`Assembler.open(Resource root)` Answer `open( this, root, Mode.DEFAULT )`.
`Model`	`Assembler.openModel(Resource root)` Answer `(Model) open( this, root, Mode.DEFAULT )`, unless the result cannot be or is not a Model, in which case throw an exception.
`Model`	`Assembler.openModel(Resource root, Mode mode)` Answer `(Model) open( this, root, mode )`, unless the result cannot be or is not a Model, in which case throw an exception.
`boolean`	`Mode.permitCreateNew(Resource root, java.lang.String name)` Answer true if the object `root` with the given `name` can be created if it does not already exist.
`boolean`	`Mode.permitUseExisting(Resource root, java.lang.String name)` Answer true if the existing object `root` with the given `name` can be reused.
`static Resource`	`AssemblerHelp.singleRoot(Model singleRoot, Resource type)` Answer the single resource in `singleRoot` of type `type`.
`static Resource`	`AssemblerHelp.withFullModel(Resource root)` Answer a Resource .equals() to `root`, but in the expanded model.

Uses of Resource in com.hp.hpl.jena.ontology

Subinterfaces of Resource in com.hp.hpl.jena.ontology
`interface`	`AllDifferent` Interface defining an individual in which all members of a collection are declared pair-wise disjoint.
`interface`	`AllValuesFromRestriction` A property restriction that requires the named property to have have any range instances to be members of a given class.
`interface`	`AnnotationProperty` Interface that represents the category of annotation properties in an ontology language.
`interface`	`BooleanClassDescription` Encapsulates a class description formed from a boolean combination of other class descriptions (ie union, intersection or complement).
`interface`	`CardinalityQRestriction` Interface representing the ontology abstraction for a qualified cardinality restriction.
`interface`	`CardinalityRestriction` A property restriction that requires the named property to have have exactly the given number of values for a given instance to be a member of the class defined by the restriction.
`interface`	`ComplementClass` Class description that is formed from the complement of another class description
`interface`	`DataRange` Represents an ontology DataRange: a class-like construct that contains only concrete data literals.
`interface`	`DatatypeProperty` Interface that encapsulates the class of properties whose range values are datatype values (as distinct from `ObjectProperty` whose values are individuals).
`interface`	`EnumeratedClass` Encapsulates a class description representing a closed enumeration of individuals.
`interface`	`FunctionalProperty` Interface encapsulating the class of properties that are functional: that is, properties in which a given given domain value has a unique value in the range.
`interface`	`HasValueRestriction` A property restriction that requires the named property to have a given individual as its value.
`interface`	`Individual` Interface that encapsulates an individual in an ontology, sometimes referred to as a fact or assertion, or a member of the a-box.
`interface`	`IntersectionClass` Encapsulates a class description that is the intersection of a list of class expressions.
`interface`	`InverseFunctionalProperty` Interface encapsulating the class of properties that are inverse functional: that is, properties in which a given given range value has a unique value in the domain (effectively, a key).
`interface`	`MaxCardinalityQRestriction` Interface representing the ontology abstraction for a qualified maximum cardinality restriction.
`interface`	`MaxCardinalityRestriction` A property restriction that requires the named property to have have at most the given number of values for a given instance to be a member of the class defined by the restriction.
`interface`	`MinCardinalityQRestriction` Interface representing the ontology abstraction for a qualified minimum cardinality restriction.
`interface`	`MinCardinalityRestriction` A property restriction that requires the named property to have have at least the given number of values for a given instance to be a member of the class defined by the restriction.
`interface`	`ObjectProperty` Interface encapsulating properties whose range values are restricted to individuals (as distinct from datatype valued `properties`).
`interface`	`OntClass` Interface that represents an ontology node characterising a class description.
`interface`	`Ontology` Interface encapsulating the distinguished instance in a given ontology document that presents meta-data and other processing data about the document (including which other documents are imported by a document).
`interface`	`OntProperty` Interface encapsulating a property in an ontology.
`interface`	`OntResource` Provides a common super-type for all of the abstractions in this ontology representation package.
`interface`	`QualifiedRestriction` Represents a qualified restriction, in which all values of the restricted property are required to be members of a given class.
`interface`	`Restriction` Interface that encapsulates a class description formed by restricting one or more properties to have constrained values and/or cardinalities.
`interface`	`SomeValuesFromRestriction` A property restriction that requires the named property to have at least one range instance belonging to the given class.
`interface`	`SymmetricProperty` Interface that encapsulates a property that is symmetric, i.e. one in which if `p(x, y)` holds, then`p(y, x)` must also hold.
`interface`	`TransitiveProperty` Interface that denotes a property that is transitive i.e. one in which if `x p y` holds, and `y p z` holds, then `x p z` must also hold.
`interface`	`UnionClass` Class description that is formed from the union of a list of a class descriptions.

Fields in com.hp.hpl.jena.ontology declared as Resource
`static Resource`	`OntDocumentManager.DOC_MGR_POLICY` rdf:type for document manager policy nodes
`static Resource`	`OntDocumentManager.ONTOLOGY_SPEC` rdf:type for ontology specification nodes in meta-data file

Methods in com.hp.hpl.jena.ontology that return Resource
`Resource`	`Profile.ALL_DIFFERENT()` Answer the resource that represents the class of axioms denoting that a set of individuals are pairwise distinct.
`Resource`	`Profile.ANNOTATION_PROPERTY()` Answer the class that denotes an annotation property
`Resource`	`Profile.CLASS()` Answer the resource that represents the class 'class' in this vocabulary.
`Resource`	`Profile.DATARANGE()` Answer the class that defines a closed range of concrete data values.
`Resource`	`Profile.DATATYPE_PROPERTY()` Answer the resource that represents the class of properties whose range elements are literals (not individuals)
`Resource`	`Profile.DEPRECATED_CLASS()` Answer the resource that represents the documentation class of deprecated classes.
`Resource`	`Profile.DEPRECATED_PROPERTY()` Answer the resource that represents the documentation class of deprecated properties.
`Resource`	`Profile.FUNCTIONAL_PROPERTY()` Answer the resource that represents the class of properties that are functional, i.e. whose range is unique for a given domain element.
`Resource`	`Profile.getAliasFor(Resource res)` Answer an alias for the given resource.
`Resource`	`AllValuesFromRestriction.getAllValuesFrom()` Answer the resource characterising the constraint on all values of the restricted property.
`Resource`	`OntResource.getIsDefinedBy()` Answer a resource that is declared to provide a definition of this resource.
`Resource`	`OntTools.LCAIndex.getLCA(Resource u, Resource v)`
`Resource`	`OntTools.DisjointSet.getNode()`
`Resource`	`OntResource.getRDFType()` Answer the `rdf:type` (i.e.
`Resource`	`OntResource.getRDFType(boolean direct)` Answer the `rdf:type` (i.e.
`Resource`	`OntResource.getSeeAlso()` Answer a resource that provides additional information about this resource.
`Resource`	`SomeValuesFromRestriction.getSomeValuesFrom()` Answer the resource characterising the constraint on at least one value of the restricted property.
`Resource`	`OntTools.Path.getTerminalResource()` Answer the resource at the end of the path, if defined, or null
`Resource`	`Profile.INVERSE_FUNCTIONAL_PROPERTY()` Answer the resource that represents the class of properties that are inverse functional, i.e. whose domain is unique for a given range element.
`Resource`	`Profile.LIST()` The `rdf:type` for cells in this list
`Resource`	`Profile.NIL()` The resource that denotes the end of the list
`Resource`	`Profile.NOTHING()` Answer the resource that represents the necessarily empty class.
`Resource`	`Profile.OBJECT_PROPERTY()` Answer the resource that represents the class of properties whose range elements are individuals (not literals)
`Resource`	`Profile.ONTOLOGY_PROPERTY()` Answer the class that denotes an ontology property
`Resource`	`Profile.ONTOLOGY()` Answer the resource that represents the class of ontology header elements.
`Resource`	`Profile.PROPERTY()` Answer the resource that represents the general class of properties.
`Resource`	`Profile.RESTRICTION()` Answer the resource that represents the a class formed by placing constraints (restrictions) on the values of a property.
`Resource`	`Profile.SYMMETRIC_PROPERTY()` Answer the resource that represents the class of properties that are symmetric.
`Resource`	`Profile.THING()` Answer the resource that represents the class all individuals.
`Resource`	`Profile.TRANSITIVE_PROPERTY()` Answer the resource that represents the class of properties that apply transitively.

Methods in com.hp.hpl.jena.ontology that return types with arguments of type Resource
`java.util.Iterator<Resource>`	`Profile.getAnnotationProperties()` Answer an iterator over the properties in this language that are denoted annotation properties.
`java.util.Iterator<Resource>`	`Profile.getAxiomTypes()` Answer an iterator over the rdf:types in this language that denote stand-alone axioms.
`java.util.Iterator<Resource>`	`Profile.getClassDescriptionTypes()` Answer an iterator over the various types of class description defined in the language.
`java.util.Iterator<Resource>`	`Profile.listAliasesFor(Resource res)` Answer an iterator over the defined aliases for a resource.
`com.hp.hpl.jena.util.iterator.ExtendedIterator<? extends Resource>`	`OntResource.listDifferentFrom()` Answer an iterator over all of the resources that are declared to be different from this resource.
`com.hp.hpl.jena.util.iterator.ExtendedIterator<Resource>`	`OntResource.listRDFTypes(boolean direct)` Answer an iterator over the RDF classes to which this resource belongs.
`com.hp.hpl.jena.util.iterator.ExtendedIterator<? extends Resource>`	`OntResource.listSameAs()` Answer an iterator over all of the resources that are declared to be the same as this resource.

Methods in com.hp.hpl.jena.ontology with parameters of type Resource

void Ontology.addBackwardCompatibleWith(Resource res)
Add a resource representing an ontology that this ontology (strictly, the ontology represented by this node) is backwards compatible with.

void OntResource.addDifferentFrom(Resource res)
Add a statement declaring that this resource is distinct from the given resource.

void OntClass.addDisjointWith(Resource cls)
Add a class that this class is disjoint with.

void AllDifferent.addDistinctMember(Resource res)
Add the given individual to the list of distinct members of this AllDifferent declaration.

void OntProperty.addDomain(Resource res)
Add a resource representing the domain of this property.

void OntClass.addEquivalentClass(Resource cls)
Add a class that is equivalent to this class.

void Ontology.addImport(Resource res)
Add a resource representing an ontology that this ontology (strictly, the ontology represented by this node) imports.

void Ontology.addIncompatibleWith(Resource res)
Add a resource representing an ontology that this ontology (strictly, the ontology represented by this node) is incompatible with.

void OntResource.addIsDefinedBy(Resource res)
Add a resource that is declared to provide a definition of this resource.

void EnumeratedClass.addOneOf(Resource res)
Add an individual to the enumeration that defines the class extension of this class.

void Individual.addOntClass(Resource cls)
Add the given ontology class as one of the classes to which this individual belongs.

void BooleanClassDescription.addOperand(Resource cls)
Add a class the operands of this boolean expression.

void Ontology.addPriorVersion(Resource res)
Add a resource representing an ontology that this ontology (strictly, the ontology represented by this node) supercedes.

void OntProperty.addRange(Resource res)
Add a resource representing the range of this property.

void OntResource.addRDFType(Resource cls)
Add the given class as one of the rdf:type's for this resource.

void OntResource.addSameAs(Resource res)
Add a resource that is declared to be equivalent to this resource.

void OntResource.addSeeAlso(Resource res)
Add a resource that is declared to provided additional information about the definition of this resource

void OntClass.addSubClass(Resource cls)
Add a sub-class of this class.

void OntClass.addSuperClass(Resource cls)
Add a super-class of this class.

static OntModelSpec OntModelSpec.assemble(Resource root)
Answer the OntModelSpec described using the Jena Assembler vocabulary properties of root.

AllValuesFromRestriction Restriction.convertToAllValuesFromRestriction(Resource cls)
Convert this restriction to an all values from class expression.

ComplementClass OntClass.convertToComplementClass(Resource cls)
Answer a view of this class as an complement of the given class.

SomeValuesFromRestriction Restriction.convertToSomeValuesFromRestriction(Resource cls)
Convert this restriction to a some values from class expression

AllValuesFromRestriction OntModel.createAllValuesFromRestriction(java.lang.String uri, Property prop, Resource cls)
Answer a class description defined as the class of those individuals for which all values of the given property belong to the given class

ComplementClass OntModel.createComplementClass(java.lang.String uri, Resource cls)
Answer a resource representing the class that is the complement of the given argument class

Individual OntModel.createIndividual(Resource cls)
Answer a resource that represents an Individual node in this model.

Individual OntModel.createIndividual(java.lang.String uri, Resource cls)
Answer a resource that represents an Individual node in this model.





<T extends OntResource> 


T

OntModel.createOntResource(java.lang.Class<T> javaClass,
                  Resource rdfType,
                  java.lang.String uri)

Answer a resource that represents a generic ontology node in this model.

SomeValuesFromRestriction OntModel.createSomeValuesFromRestriction(java.lang.String uri, Property prop, Resource cls)
Answer a class description defined as the class of those individuals that have at least one property with a value belonging to the given class

void OntClass.dropIndividual(Resource individual)
Remove the given individual from the set of instances that are members of this class.

static OntTools.Path OntTools.findShortestPath(Model m, Resource start, RDFNode end, com.hp.hpl.jena.util.iterator.Filter<Statement> onPath)
Answer the shortest path from the start resource to the end RDF node, such that every step on the path is accepted by the given filter.

Resource Profile.getAliasFor(Resource res)
Answer an alias for the given resource.

Resource OntTools.LCAIndex.getLCA(Resource u, Resource v)

OntResource OntModel.getOntResource(Resource res)
Answer a resource presenting the OntResource facet, which corresponds to the given resource but attached to this model.

OntTools.DisjointSet OntTools.LCAIndex.getSet(Resource r)

boolean Profile.hasAliasFor(Resource res)
Answer true if the given resource has an alias in this profile.

boolean AllValuesFromRestriction.hasAllValuesFrom(Resource cls)
Answer true if this property restriction has the given class as the class to which all values of the restricted property must belong.

boolean AllDifferent.hasDistinctMember(Resource res)
Answer true if this AllDifferent declaration includes res as one of the distinct individuals.

boolean OntProperty.hasDomain(Resource res)
Answer true if the given resource a class specifying the domain of this property.

boolean OntClass.hasEquivalentClass(Resource cls)
Answer true if the given class is equivalent to this class.

boolean EnumeratedClass.hasOneOf(Resource res)
Answer true if the given individual is one of the enumerated individuals in the class extension of this class.

boolean Individual.hasOntClass(Resource ontClass)
Answer true if this individual is a member of the class denoted by the given ontology class resource.

boolean Individual.hasOntClass(Resource ontClass, boolean direct)
Answer true if this individual is a member of the class denoted by the given class resource.

boolean BooleanClassDescription.hasOperand(Resource cls)
Answer true if this Boolean class expression has the given class as an operand.

boolean Ontology.hasPriorVersion(Resource res)
Answer true if this ontology (the ontology represented by this resource) supercedes the given resource.

boolean OntProperty.hasRange(Resource res)
Answer true if the given resource a class specifying the range of this property.

boolean OntResource.hasRDFType(Resource ontClass)
Answer true if this resource is a member of the class denoted by the given class resource.

boolean OntResource.hasRDFType(Resource ontClass, boolean direct)
Answer true if this resource is a member of the class denoted by the given class resource.

boolean OntResource.hasSeeAlso(Resource res)
Answer true if this resource has the given resource as a source of additional information.

boolean SomeValuesFromRestriction.hasSomeValuesFrom(Resource cls)
Answer true if this property restriction has the given class as the class to which at least one value of the restricted property must belong.

boolean OntClass.hasSubClass(Resource cls)
Answer true if the given class is a sub-class of this class.

boolean OntClass.hasSubClass(Resource cls, boolean direct)
Answer true if the given class is a sub-class of this class.

boolean OntClass.hasSuperClass(Resource cls)
Answer true if the given class is a super-class of this class.

boolean OntClass.hasSuperClass(Resource cls, boolean direct)
Answer true if the given class is a super-class of this class.

boolean Ontology.imports(Resource res)
Answer true if this ontology (the ontology represented by this resource) imports the given resource.

boolean Ontology.isBackwardCompatibleWith(Resource res)
Answer true if this ontology (the ontology represented by this resource) is backward compatible with the given resource.

boolean OntResource.isDefinedBy(Resource res)
Answer true if this resource is defined by the given resource.

boolean OntResource.isDifferentFrom(Resource res)
Answer true if this resource is different from the given resource.

boolean OntClass.isDisjointWith(Resource cls)
Answer true if this class is disjoint with the given class.

boolean Ontology.isIncompatibleWith(Resource res)
Answer true if this ontology (the ontology represented by this resource) is incompatible with the given resource.

boolean OntResource.isSameAs(Resource res)
Answer true if this resource is the same as the given resource.

java.util.Iterator<Resource> Profile.listAliasesFor(Resource res)
Answer an iterator over the defined aliases for a resource.

com.hp.hpl.jena.util.iterator.ExtendedIterator<Individual> OntModel.listIndividuals(Resource cls)
Answer an iterator that ranges over the resources in this model that are instances of the given class.

void AllValuesFromRestriction.removeAllValuesFrom(Resource cls)
Remove the statement that this restriction has all values from the given class among the values for the restricted property.

void Ontology.removeBackwardCompatibleWith(Resource res)
Remove the statement that this ontology is backwards compatible with the ontology represented by the given resource.

void OntResource.removeDefinedBy(Resource res)
Remove the statement that this resource is defined by the given resource.

void OntResource.removeDifferentFrom(Resource res)
Remove the statement that this resource is different the given resource.

void OntClass.removeDisjointWith(Resource cls)
Remove the statement that this class and the given class are disjoint.

void AllDifferent.removeDistinctMember(Resource res)
Remove the given resource from the list of distinct individuals.

void OntProperty.removeDomain(Resource cls)
Remove the given class from the stated domain(s) of this property.

void OntClass.removeEquivalentClass(Resource cls)
Remove the statement that this class and the given class are equivalent.

void Ontology.removeImport(Resource res)
Remove the statement that this ontology imports the ontology represented by the given resource.

void Ontology.removeIncompatibleWith(Resource res)
Remove the statement that the given ontology is incompatible with this ontology.

void EnumeratedClass.removeOneOf(Resource res)
Remove the statement that this enumeration includes res among its members.

void Individual.removeOntClass(Resource ontClass)
Attempt to remove this individual as a member of the given ontology class.

void BooleanClassDescription.removeOperand(Resource res)
Remove the given resource from the operands of this class expression.

void Ontology.removePriorVersion(Resource res)
Remove the statement that the given ontology is a prior version of this ontology.

void OntProperty.removeRange(Resource cls)
Remove the given class from the stated range(s) of this property.

void OntResource.removeRDFType(Resource cls)
Remove the statement that this resource is of the given RDF type.

void OntResource.removeSameAs(Resource res)
Remove the statement that this resource is the same as the given resource.

void OntResource.removeSeeAlso(Resource res)
Remove the statement indicating the given resource as a source of additional information about this resource.

void SomeValuesFromRestriction.removeSomeValuesFrom(Resource cls)
Remove the statement that this restriction has some values from the given class among the values for the restricted property.

void OntClass.removeSubClass(Resource cls)
Remove the given class from the sub-classes of this class.

void OntClass.removeSuperClass(Resource cls)
Remove the given class from the super-classes of this class.

void AllValuesFromRestriction.setAllValuesFrom(Resource cls)
Assert that this restriction restricts the property to have all values be members of the given class.

void Ontology.setBackwardCompatibleWith(Resource res)
Assert that this ontology is backward compatible with the given ontology.

void OntResource.setDifferentFrom(Resource res)
Assert that the given resource and this resource are distinct.

void OntClass.setDisjointWith(Resource cls)
Assert that this class is disjoint with the given class.

void OntProperty.setDomain(Resource res)
Assert that the given resource represents the class of individuals that form the domain of this property.

void OntClass.setEquivalentClass(Resource cls)
Assert that the given class is equivalent to this class.

void Ontology.setImport(Resource res)
Assert that this ontology imports only the given ontology.

void Ontology.setIncompatibleWith(Resource res)
Assert that this ontology is incompatible with the given ontology.

void OntResource.setIsDefinedBy(Resource res)
Assert that the given resource provides a source of definitions about this resource.

void OntTools.LCAIndex.setLCA(Resource u, Resource v, Resource lca)

void Individual.setOntClass(Resource cls)
Set the ontology class for this individual, replacing any existing class membership.

void ComplementClass.setOperand(Resource cls)
Set the class that the class represented by this class expression is a complement of.

void Ontology.setPriorVersion(Resource res)
Assert that this ontology is a new version of the given ontology.

void OntProperty.setRange(Resource res)
Assert that the given resource represents the class of individuals that form the range of this property.

void OntResource.setRDFType(Resource cls)
Set the RDF type (i.e.

void OntResource.setSameAs(Resource res)
Assert equivalence between the given resource and this resource.

void OntResource.setSeeAlso(Resource res)
Assert that the given resource provides additional information about the definition of this resource

void SomeValuesFromRestriction.setSomeValuesFrom(Resource cls)
Assert that this restriction restricts the property to have at least one value that is a member of the given class.

void OntClass.setSubClass(Resource cls)
Assert that this class is super-class of the given class.

void OntClass.setSuperClass(Resource cls)
Assert that this class is sub-class of the given class.

Method parameters in com.hp.hpl.jena.ontology with type arguments of type Resource
`void`	`AllDifferent.addDistinctMembers(java.util.Iterator<? extends Resource> individuals)` Add the given individuals to the list of distinct members of this AllDifferent declaration.
`void`	`EnumeratedClass.addOneOf(java.util.Iterator<? extends Resource> individuals)` Add each individual from the given iteration to the enumeration that defines the class extension of this class.
`void`	`BooleanClassDescription.addOperands(java.util.Iterator<? extends Resource> classes)` Add all of the classes from the given iterator to the operands of this boolean expression.

Constructors in com.hp.hpl.jena.ontology with parameters of type Resource
`OntTools.DisjointSet(Resource node)`

Uses of Resource in com.hp.hpl.jena.rdf.model

Subinterfaces of Resource in com.hp.hpl.jena.rdf.model
`interface`	`Alt` An RDF Alternative container.
`interface`	`Bag` An RDF Bag container.
`interface`	`Container` An RDF Container.
`interface`	`Property` An RDF Property.
`interface`	`RDFList` Provides a convenience encapsulation for lists formed from chains of RDF statements arranged to form a head/tail cons-cell structure.
`interface`	`ReifiedStatement` A ReifiedStatement represents a Statement as a Resource.
`interface`	`Seq` RDF Sequence container.

Fields in com.hp.hpl.jena.rdf.model with type parameters of type Resource
`static com.hp.hpl.jena.util.iterator.Map1<Statement,Resource>`	`Statement.Util.getSubject`

Methods in com.hp.hpl.jena.rdf.model that return Resource
`Resource`	`Resource.abort()` Abort the transaction in the associated model.
`Resource`	`Resource.addLiteral(Property p, boolean o)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addLiteral(Property p, char o)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addLiteral(Property value, double d)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addLiteral(Property value, float d)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addLiteral(Property p, Literal o)` Add the property `p` with the pre-constructed Literal value `o` to this resource, ie add (this, p, o) to this's model.
`Resource`	`Resource.addLiteral(Property p, long o)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addLiteral(Property p, java.lang.Object o)` Add the property `p` with the typed-literal value `o` to this resource, ie add (this, p, typed(o)) to this's model.
`Resource`	`Resource.addProperty(Property p, RDFNode o)` Add a property to this resource.
`Resource`	`Resource.addProperty(Property p, java.lang.String o)` Add a property to this resource.
`Resource`	`Resource.addProperty(Property p, java.lang.String lexicalForm, RDFDatatype datatype)` Add a property to this resource.
`Resource`	`Resource.addProperty(Property p, java.lang.String o, java.lang.String l)` Add a property to this resource.
`Resource`	`RDFNode.asResource()` If this node is a Resource, answer that resource; otherwise throw an exception.
`Resource`	`Resource.begin()` Begin a transaction in the associated model.
`Resource`	`Resource.commit()` Commit the transaction in the associated model.
`static Resource`	`ResourceFactory.createResource()` create a new anonymous resource.
`Resource`	`ResourceFactory.Interface.createResource()` create a new anonymous resource.
`Resource`	`Model.createResource()` Create a new anonymous resource whose model is this model.
`Resource`	`Model.createResource(AnonId id)` Create a blank node resource with a specified identifier.
`Resource`	`ResourceF.createResource(Resource r)` Deprecated. Create new resource instance which extends the behaviour of a supplied resource.
`Resource`	`ModelCon.createResource(Resource type)` Create a new anonymous resource with a given type.
`Resource`	`ModelCon.createResource(ResourceF f)` Deprecated.
`static Resource`	`ResourceFactory.createResource(java.lang.String uriref)` create a new resource.
`Resource`	`ResourceFactory.Interface.createResource(java.lang.String uriref)` create a new resource.
`Resource`	`Model.createResource(java.lang.String uri)` Create a new resource associated with this model.
`Resource`	`ModelCon.createResource(java.lang.String uri, Resource type)` Create a new resource with a given type.
`Resource`	`ModelCon.createResource(java.lang.String uri, ResourceF f)` Deprecated.
`Resource`	`Model.getAnyReifiedStatement(Statement s)` Find or create a `ReifiedStatement` corresponding to a Statement.
`Resource`	`Alt.getDefaultResource()` Return the default value for this resource.
`Resource`	`Alt.getDefaultResource(ResourceF f)` Deprecated.
`Resource`	`Resource.getPropertyResourceValue(Property p)` Answer some resource R for which this.hasProperty( p, R ), or null if no such R exists.
`Resource`	`Statement.getResource()` Return the object of the statement.
`Resource`	`Seq.getResource(int index)` Get the member at a given index.
`Resource`	`Seq.getResource(int index, ResourceF f)` Deprecated.
`Resource`	`Statement.getResource(ResourceF f)` Deprecated.
`Resource`	`Model.getResource(java.lang.String uri)` Return a Resource instance with the given URI in this model.
`Resource`	`ModelCon.getResource(java.lang.String uri, ResourceF f)` Deprecated.
`Resource`	`Statement.getSubject()` An accessor method to return the subject of the statements.
`Resource`	`SimpleSelector.getSubject()` Return the subject constraint of this selector.
`Resource`	`Selector.getSubject()` Answer the only subject Resource that this Selector will match, or null if it can match more that a single resource.
`Resource`	`Resource.inModel(Model m)` Override RDFNode.inModel() to produce a staticly-typed Resource in the given Model.
`Resource`	`ResIterator.nextResource()`
`Resource`	`Resource.removeAll(Property p)` Delete all the statements with predicate `p` for this resource from its associated model.
`Resource`	`Resource.removeProperties()` Delete all the properties for this resource from the associated model.
`Resource`	`ModelGraphInterface.wrapAsResource(Node n)`

Methods in com.hp.hpl.jena.rdf.model that return types with arguments of type Resource
`static java.util.Set<Resource>`	`ModelFactory.findAssemblerRoots(Model m)` Answer a Set of resources present in `m` that are explicitly or implicitly of type ja:Object, ie, suitable as roots for `assemblerModelFrom`.

Methods in com.hp.hpl.jena.rdf.model with parameters of type Resource
`Model`	`ModelCon.add(Resource s, Property p, RDFNode o)` add a statement to this model.
`Model`	`ModelCon.add(Resource s, Property p, java.lang.String o)` add a statement to this model.
`Model`	`ModelCon.add(Resource s, Property p, java.lang.String o, boolean wellFormed)` add a statement to this model.
`Model`	`ModelCon.add(Resource s, Property p, java.lang.String lex, RDFDatatype datatype)` add a statement to this model.
`Model`	`ModelCon.add(Resource s, Property p, java.lang.String o, java.lang.String l)` add a statement to this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, boolean o)` Add the statement (s, p, createTypedLiteral( o )) to this model and answer this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, char o)` Add the statement (s, p, createTypedLiteral( o )) to this model and answer this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, double o)` Add the statement (s, p, o') to the model, where o' is the typed literal corresponding to o.
`Model`	`ModelCon.addLiteral(Resource s, Property p, float o)` Add the statement (s, p, o') to the model, where o' is the typed literal corresponding to o.
`Model`	`ModelCon.addLiteral(Resource s, Property p, int o)` Add the statement (s, p, createTypedLiteral( o )) to this model and answer this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, Literal o)` add a statement to this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, long o)` Add the statement (s, p, createTypedLiteral( o )) to this model and answer this model.
`Model`	`ModelCon.addLiteral(Resource s, Property p, java.lang.Object o)` Deprecated. Freshly (should have been done a while ago)
`static Model`	`ModelFactory.assembleModelFrom(Resource root)` Answer a Model as described the the Assembler specification rooted at the Resource `root` in its Model.
`boolean`	`Model.contains(Resource s, Property p)` Determine whether this model contains any statements with a given subject and property.
`boolean`	`Model.contains(Resource s, Property p, RDFNode o)` Determine if an (S, P, O) pattern is present in this model, with null allowed to represent a wildcard match.
`boolean`	`ModelCon.contains(Resource s, Property p, java.lang.String o)` Determine if a statement is present in this model.
`boolean`	`ModelCon.contains(Resource s, Property p, java.lang.String o, java.lang.String l)` Determine if a statement is present in this model.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, boolean o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, char o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, double o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, float o)` Answer true iff this model contains (s, p, o') where o' is the typed literal corresponding to o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, int o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, long o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`boolean`	`ModelCon.containsLiteral(Resource s, Property p, java.lang.Object o)` Answer true iff this model contains the statement (s, p, o') where o' is the typed literal corresponding to the value o.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, boolean o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, char o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, double o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, float o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, int o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, long o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Statement`	`ModelCon.createLiteralStatement(Resource s, Property p, java.lang.Object o)` Answer a new Statement object (s, p, o') where o' is the typed literal corresponding to o using createTypedLiteral.
`Resource`	`ResourceF.createResource(Resource r)` Deprecated. Create new resource instance which extends the behaviour of a supplied resource.
`Resource`	`ModelCon.createResource(Resource type)` Create a new anonymous resource with a given type.
`Resource`	`ModelCon.createResource(java.lang.String uri, Resource type)` Create a new resource with a given type.
`static Statement`	`ResourceFactory.createStatement(Resource subject, Property predicate, RDFNode object)` create a new statement.
`Statement`	`ResourceFactory.Interface.createStatement(Resource subject, Property predicate, RDFNode object)` create a new statement.
`Statement`	`Model.createStatement(Resource s, Property p, RDFNode o)` Create a Statement instance.
`Statement`	`ModelCon.createStatement(Resource s, Property p, java.lang.String o)` Create a Statement instance.
`Statement`	`ModelCon.createStatement(Resource s, Property p, java.lang.String o, boolean wellFormed)` Create a Statement instance.
`Statement`	`ModelCon.createStatement(Resource s, Property p, java.lang.String o, java.lang.String l)` Create a Statement instance.
`Statement`	`ModelCon.createStatement(Resource s, Property p, java.lang.String o, java.lang.String l, boolean wellFormed)` Create a Statement instance.
`Model`	`ModelExtract.extract(Resource r, Model s)` Answer the rooted sub-model.
`Model`	`ModelExtract.extractInto(Model model, Resource r, Model s)` Answer `model` after updating it with the sub-graph of `s` rooted at `r`, bounded by this instances `boundary`.
`Alt`	`ModelCon.getAlt(Resource r)` Return an Alt instance based on a given resource.
`Bag`	`ModelCon.getBag(Resource r)` Return a bag instance based on a given resource.
`Statement`	`Model.getProperty(Resource s, Property p)` Answer a statement (s, p, ?O) from this model.
`Statement`	`Model.getRequiredProperty(Resource s, Property p)` Return a statement with given subject and property.
`Seq`	`ModelCon.getSeq(Resource r)` Return a Seq instance based on a given resource.
`StmtIterator`	`ModelCon.listLiteralStatements(Resource subject, Property predicate, boolean object)` Answer a statement iterator that will iterate over all the statements (S, P, O) in this model where S matches `subject`, P matches `predicate`, and O matches the typed literal corresponding to `object`.
`StmtIterator`	`ModelCon.listLiteralStatements(Resource subject, Property predicate, char object)` Answer a statement iterator that will iterate over all the statements (S, P, O) in this model where S matches `subject`, P matches `predicate`, and O matches the typed literal corresponding to `object`.
`StmtIterator`	`ModelCon.listLiteralStatements(Resource subject, Property predicate, double object)` Answer a statement iterator that will iterate over all the statements (S, P, O) in this model where S matches `subject`, P matches `predicate`, and O matches the typed literal corresponding to `object`.
`StmtIterator`	`ModelCon.listLiteralStatements(Resource subject, Property predicate, float object)` Answer a statement iterator that will iterate over all the statements (S, P, O) in this model where S matches `subject`, P matches `predicate`, and O matches the typed literal corresponding to `object`.
`StmtIterator`	`ModelCon.listLiteralStatements(Resource subject, Property predicate, long object)` Answer a statement iterator that will iterate over all the statements (S, P, O) in this model where S matches `subject`, P matches `predicate`, and O matches the typed literal corresponding to `object`.
`NodeIterator`	`Model.listObjectsOfProperty(Resource s, Property p)` List the values of a property of a resource.
`StmtIterator`	`Model.listStatements(Resource s, Property p, RDFNode o)` Find all the statements matching a pattern.
`StmtIterator`	`InfModel.listStatements(Resource subject, Property predicate, RDFNode object, Model posit)` Find all the statements matching a pattern.
`StmtIterator`	`ModelCon.listStatements(Resource subject, Property predicate, java.lang.String object)` Find all the statements matching a pattern.
`StmtIterator`	`ModelCon.listStatements(Resource subject, Property predicate, java.lang.String object, java.lang.String lang)` Find all the statements matching a pattern.
`Model`	`ModelCon.remove(Resource s, Property p, RDFNode o)` remove the statement `(s, p, o)` from this model and answer this model.
`Model`	`Model.removeAll(Resource s, Property p, RDFNode r)` Remove all the statements matching (s, p, o) from this model.
`java.lang.Object`	`RDFVisitor.visitBlank(Resource r, AnonId id)` Method to call when visiting a blank node r with identifier id.
`java.lang.Object`	`RDFVisitor.visitURI(Resource r, java.lang.String uri)` Method to call when visiting a URI node r with the given uri.

Constructors in com.hp.hpl.jena.rdf.model with parameters of type Resource
`SimpleSelector(Resource subject, Property predicate, boolean object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, char object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, double object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, float object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, long object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, java.lang.Object object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, RDFNode object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, java.lang.String object)` Create a selector.
`SimpleSelector(Resource subject, Property predicate, java.lang.String object, java.lang.String language)` Create a selector.

Uses of Resource in com.hp.hpl.jena.reasoner

Methods in com.hp.hpl.jena.reasoner that return Resource
`Resource`	`ReasonerRegistry.getDescription(java.lang.String uri)` Return information on a given Reasoner.

Methods in com.hp.hpl.jena.reasoner with parameters of type Resource
`void`	`Reasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`Reasoner`	`ReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`ReasonerRegistry.create(java.lang.String uri, Resource configuration)` Create and return a new instance of the reasoner identified by the given uri.

Uses of Resource in com.hp.hpl.jena.reasoner.rulesys

Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Resource
`void`	`LPBackwardRuleReasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`void`	`FBRuleReasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`void`	`BasicForwardRuleReasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`static java.lang.Boolean`	`Util.checkBinaryPredicate(Property predicate, Resource configuration)` Helper method - extracts the truth of a boolean configuration predicate.
`Reasoner`	`RDFSRuleReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`RDFSFBRuleReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`OWLMiniReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`OWLMicroReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`OWLFBRuleReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`GenericRuleReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`Reasoner`	`DAMLMicroReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner
`static java.lang.Integer`	`Util.getIntegerPredicate(Property predicate, Resource configuration)` Helper method - extracts the value of an integer configuration predicate.
`static void`	`Util.updateParameter(Resource config, Property parameter, java.lang.Object value)` Replace the value for a given parameter on the resource by a new value.

Constructors in com.hp.hpl.jena.reasoner.rulesys with parameters of type Resource
`FBRuleReasoner(ReasonerFactory factory, Resource configuration)` Constructor
`GenericRuleReasoner(ReasonerFactory factory, Resource configuration)` Constructor
`RDFSRuleReasoner(ReasonerFactory factory, Resource configuration)` Constructor

Uses of Resource in com.hp.hpl.jena.reasoner.transitiveReasoner

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Resource
`void`	`TransitiveReasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`Reasoner`	`TransitiveReasonerFactory.create(Resource configuration)` Constructor method that builds an instance of the associated Reasoner

Uses of Resource in com.hp.hpl.jena.shared

Fields in com.hp.hpl.jena.shared declared as Resource
`Resource`	`BadDescriptionNoRootException.type`
`Resource`	`BadDescriptionMultipleRootsException.type`

Constructors in com.hp.hpl.jena.shared with parameters of type Resource
`BadDescriptionMultipleRootsException(Model badModel, Resource type)`
`BadDescriptionNoRootException(Model badModel, Resource type)`

Uses of Resource in com.hp.hpl.jena.util

Methods in com.hp.hpl.jena.util with type parameters of type Resource

static



<T extends Resource> 


java.util.List<T>

ResourceUtils.maximalLowerElements(java.util.Collection<T> resources,
                     Property rel,
                     boolean inverse)

Answer the maximal lower elements of the given collection, given the partial ordering rel.

static



<T extends Resource> 


java.util.List<T>

ResourceUtils.maximalLowerElements(java.util.Iterator<T> resources,
                     Property rel,
                     boolean inverse)

Given a collection of resources, and a relation defining a partial order over those resources, answer the sub-collection that contains only those elements that appear in the maximal generator of the relation.

static



<T extends Resource> 


java.util.List<java.util.List<T>>

ResourceUtils.partition(java.util.List<T> l,
          Property p)

Answer a list of lists, which is a partition of the given input list of resources.

static



<T extends Resource> 


java.util.List<T>

ResourceUtils.removeEquiv(java.util.List<T> l,
            Property p,
            Resource ref)

Remove from the given list l of Resources, any Resource that is equivalent to the reference resource ref under the relation p.

Methods in com.hp.hpl.jena.util that return Resource
`static Resource`	`ResourceUtils.renameResource(Resource old, java.lang.String uri)` Answer a new resource that occupies the same position in the graph as the current resource `old`, but that has the given URI.

Methods in com.hp.hpl.jena.util with parameters of type Resource

static com.hp.hpl.jena.util.iterator.ExtendedIterator<java.util.List<? extends RDFNode>> ModelQueryUtil.queryBindingsWith(Model model, Model query, Resource[] variables)

static Model ResourceUtils.reachableClosure(Resource root)
Answer a model that contains all of the resources reachable from a given resource by any property, transitively.

static



<T extends Resource> 


java.util.List<T>

ResourceUtils.removeEquiv(java.util.List<T> l,
            Property p,
            Resource ref)