Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
com.hp.hpl.jena.rdf.model.Model

Packages that use Model
com.hp.hpl.jena.assembler |
com.hp.hpl.jena.db | A general database backend for persistent storage of Jena models.
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.arp | A parser for RDF/XML.
com.hp.hpl.jena.rdf.listeners | A package defining some useful implementations of `ModelChangedListener`, for listening to (a) all triples added or removed, exploding composite objects, (b) all objects added or removed, as themselves, (c) notification of additions/removals, but no details, and (d) accepting but ignoring all changes, as a base-class to be extended.
com.hp.hpl.jena.rdf.model | A package for creating and manipulating RDF graphs.
com.hp.hpl.jena.rdf.model.impl | This package contains implementations of the interfaces defined in the .model package, eg ModelCom for Model, ResourceImpl for Resource, and so on.
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.dig |
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.

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

Methods in com.hp.hpl.jena.assembler that return Model
`Model` | `Content.fill(Model m)` Answer the model `m` after filling it with the contents described by this object.
`static Model` | `AssemblerHelp.fullModel(ImportManager im, Model m)` Answer the full model of `m`, with all its imports included and with the necessary properties added from the JA schema.
`static Model` | `AssemblerHelp.fullModel(Model m)` Answer the full model of `m`, with all its imports included and with the necessary properties added from the JA schema.
`static Model` | `JA.getSchema()`
`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.
`Model` | `ImportManager.withImports(FileManager fm, Model model)` Answer `model` if it has no imports, or a union model with `model` as its base and its imported models as the other components.
`Model` | `ImportManager.withImports(Model model)` Answer `model` if it has no imports, or a union model with `model` as its base and its imported models as the other components.
`static Model` | `ModelExpansion.withSchema(Model model, Model schema)` Answer a new model which is the aggregation of the statements of `model` the non-bnode subclass statements of `schema` the subclass closure of those statements the rdf:type statements implied by the rdfs:domain statements of `schema` and the `model` statements using that statements property similarly for rdfs:range the rdf:type statements implied by the subclass closure

Methods in com.hp.hpl.jena.assembler with parameters of type Model
`static void` | `ModelExpansion.addSubClassClosure(Model m)` Do (limited) subclass closure on `m`.
`Model` | `Content.fill(Model m)` Answer the model `m` after filling it with the contents described by this object.
`static java.util.Set` | `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` | `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 Model` | `AssemblerHelp.fullModel(ImportManager im, Model m)` Answer the full model of `m`, with all its imports included and with the necessary properties added from the JA schema.
`static Model` | `AssemblerHelp.fullModel(Model m)` Answer the full model of `m`, with all its imports included and with the necessary properties added from the JA schema.
`static void` | `AssemblerHelp.loadArbitraryClasses(com.hp.hpl.jena.assembler.assemblers.AssemblerGroup g, Model m)` Load all the classes which are objects of any (t, ja:loadClass, S) statements in `m`.
`static void` | `AssemblerHelp.loadAssemblerClasses(com.hp.hpl.jena.assembler.assemblers.AssemblerGroup group, Model m)` Load all the classes which are objects of any (t, ja:assembler, S) statements in `m`.
`static void` | `AssemblerHelp.loadClasses(com.hp.hpl.jena.assembler.assemblers.AssemblerGroup group, Model m)` Deprecated. Use `loadAssemblerClasses` instead (since it's explicit in what kinds of classes it loads).
`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`.
`Model` | `ImportManager.withImports(FileManager fm, Model model)` Answer `model` if it has no imports, or a union model with `model` as its base and its imported models as the other components.
`Model` | `ImportManager.withImports(Model model)` Answer `model` if it has no imports, or a union model with `model` as its base and its imported models as the other components.
`static Model` | `ModelExpansion.withSchema(Model model, Model schema)` Answer a new model which is the aggregation of the statements of `model` the non-bnode subclass statements of `schema` the subclass closure of those statements the rdf:type statements implied by the rdfs:domain statements of `schema` and the `model` statements using that statements property similarly for rdfs:range the rdf:type statements implied by the subclass closure

Uses of Model in com.hp.hpl.jena.db

Classes in com.hp.hpl.jena.db that implement Model
`class` | `ModelRDB` A persistent relational database implemention of the RDF API.

Methods in com.hp.hpl.jena.db that return Model
`Model` | `IDBConnection.getDatabaseProperties()` Returns a Jena Model containing database properties.
`Model` | `DBConnection.getDatabaseProperties()`
`Model` | `IDBConnection.getDefaultModelProperties()` Retrieve a default set of model customization properties.
`Model` | `DBConnection.getDefaultModelProperties()`
`static Model` | `ModelRDB.getDefaultModelProperties(IDBConnection dbcon)` Retrieve a default set of model customization properties The returned default set of properties is suitable for use in a call to ModelRDB.create(..., modelProperties);
`Model` | `ModelRDB.getModelProperties()` Returns a Jena Model containing model-specific properties.
`Model` | `ModelRDB.loadAll()` Deprecated. Since Jena 2.0, this call is not recommended. Instead use the soon-to-be-released bulk-load functions.

Methods in com.hp.hpl.jena.db with parameters of type Model
`static ModelRDB` | `ModelRDB.createModel(IDBConnection dbcon, Model modelProperties)` Create a new model on an existing database.
`static ModelRDB` | `ModelRDB.createModel(IDBConnection dbcon, java.lang.String name, Model modelProperties)` Create a new model on an existing database.
`void` | `IDBConnection.setDatabaseProperties(Model propertyModel)` Sets database-specific properties.
`void` | `DBConnection.setDatabaseProperties(Model dbProperties)`

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

Subinterfaces of Model in com.hp.hpl.jena.ontology
`interface` | `OntModel` An enhanced view of a Jena model that is known to contain ontology data, under a given ontology `vocabulary` (such as OWL).

Methods in com.hp.hpl.jena.ontology that return Model
`Model` | `OntModelSpec.createBaseModel()` Answer a base model constructed according to this specification.
`Model` | `OntModelSpec.doCreateModel()` Create an OntModel according to this model specification.
`Model` | `OntModel.getBaseModel()` Answer the base model of this model.
`Model` | `OntDocumentManager.getModel(java.lang.String uri)` Answer the cached model corresponding to the given document, if known.
`Model` | `OntModelSpec.implementCreateModelOver(java.lang.String name)` Create an OntModel according to this model specification.
`Model` | `OntModel.write(java.io.OutputStream out)` Write a serialization of this model as an XML document.
`Model` | `OntModel.write(java.io.OutputStream out, java.lang.String lang)` Write a serialized representation of this model in a specified language.
`Model` | `OntModel.write(java.io.OutputStream out, java.lang.String lang, java.lang.String base)` Write a serialized representation of a model in a specified language.
`Model` | `OntModel.write(java.io.Writer writer)` Write the model as an XML document.
`Model` | `OntModel.write(java.io.Writer writer, java.lang.String lang)` Write a serialized representation of a model in a specified language.
`Model` | `OntModel.write(java.io.Writer writer, java.lang.String lang, java.lang.String base)` Write a serialized representation of a model in a specified language.
`Model` | `OntModel.writeAll(java.io.OutputStream out, java.lang.String lang, java.lang.String base)` Write a serialized representation of all of the contents of the model, including inferred statements and statements imported from other documents.
`Model` | `OntModel.writeAll(java.io.Writer writer, java.lang.String lang, java.lang.String base)` Write a serialized representation of all of the contents of the model, including inferred statements and statements imported from other documents.

Methods in com.hp.hpl.jena.ontology with parameters of type Model
`void` | `OntDocumentManager.addModel(java.lang.String docURI, Model model)` Add an entry that `model` is the appropriate model to use for the given ontology document.
`void` | `OntDocumentManager.addModel(java.lang.String docURI, Model model, boolean replace)` Add an entry that `model` is the appropriate model to use for the given ontology document
`void` | `OntModel.addSubModel(Model model)` Add the given model as one of the sub-models of the enclosed ontology union model.
`void` | `OntModel.addSubModel(Model model, boolean rebind)` Add the given model as one of the sub-models of the enclosed ontology union model.
`void` | `OntDocumentManager.ReadHook.afterRead(Model model, java.lang.String source, OntDocumentManager odm)` Behaviour that is invoked just after the contents of the given source (URI or filename) have been read into the given model.
`void` | `OntDocumentManager.DefaultReadHook.afterRead(Model model, java.lang.String source, OntDocumentManager odm)`
`static OntModelSpec` | `OntModelSpec.assemble(Model model)` Answer the OntModelSpec described using the Jena Assembler vocabulary properties of the single resource in `model` of type JA:OntModelSpec.
`java.lang.String` | `OntDocumentManager.ReadHook.beforeRead(Model model, java.lang.String source, OntDocumentManager odm)` Behaviour that is invoked before the contents of the given source (URI or filename) are read into the given model.
`java.lang.String` | `OntDocumentManager.DefaultReadHook.beforeRead(Model model, java.lang.String source, OntDocumentManager odm)`
`void` | `OntDocumentManager.configure(Model config)` Configure this document manager using the given configuration information, after first resetting the model back to all default values.
`void` | `OntDocumentManager.configure(Model config, boolean reset)` Configure this document manager according to the configuration options supplied by the given configuration model.
`static OntTools.Path` | `OntTools.findShortestPath(Model m, Resource start, RDFNode end, Filter 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.
`void` | `OntDocumentManager.ReadFailureHandler.handleFailedRead(java.lang.String url, Model model, java.lang.Exception e)` Behaviour to invoke when the `OntDocumentManager` tries and fails to read an ontology document from a given URL.
`void` | `OntModel.removeSubModel(Model model)` Remove the given model as one of the sub-models of the enclosed ontology union model.
`void` | `OntModel.removeSubModel(Model model, boolean rebind)` Remove the given model as one of the sub-models of the enclosed ontology union model.

Constructors in com.hp.hpl.jena.ontology with parameters of type Model
`OntDocumentManager(FileManager fileMgr, Model config)` Initialise a document manager with the given configuration model.
`OntDocumentManager(Model config)` Initialise a document manager with the given configuration model.

Uses of Model in com.hp.hpl.jena.rdf.arp

Methods in com.hp.hpl.jena.rdf.arp with parameters of type Model
`static SAX2Model` | `SAX2Model.create(java.lang.String base, Model m)` Factory method to create a new SAX2Model.
`static SAX2Model` | `SAX2Model.create(java.lang.String base, Model m, java.lang.String lang)` Factory method to create a new SAX2Model.
`static DOM2Model` | `DOM2Model.createD2M(java.lang.String base, Model m)` Create a new DOM2Model.
`static DOM2Model` | `DOM2Model.createD2M(java.lang.String base, Model m, java.lang.String lang)` Create a new DOM2Model.
`static SAX2Model` | `SAX2Model.newInstance(java.lang.String base, Model m)` Deprecated. Use `SAX2Model.create(String, Model)`
`static SAX2Model` | `SAX2Model.newInstance(java.lang.String base, Model m, java.lang.String lang)` Deprecated. Use `SAX2Model.create(String, Model, String)`
`void` | `JenaReader.read(Model m, java.io.InputStream in, java.lang.String xmlBase)` Reads from inputStream, using base URI xmlbase, adding triples to model.
`void` | `JenaReader.read(Model m, java.io.Reader reader, java.lang.String xmlBase)` Reads from reader, using base URI xmlbase, adding triples to model.
`void` | `JenaReader.read(Model m, java.lang.String url)` Reads from url, using url as base, adding triples to model.
`static void` | `JenaReader.useMe(Model m)` Deprecated. This is the default behaviour

Constructors in com.hp.hpl.jena.rdf.arp with parameters of type Model
`DOM2Model(java.lang.String base, Model m)` Deprecated. Use `DOM2Model.createD2M(String, Model)`
`DOM2Model(java.lang.String base, Model m, java.lang.String lang)` Deprecated. Use `DOM2Model.createD2M(String, Model, String)`

Uses of Model in com.hp.hpl.jena.rdf.listeners

Methods in com.hp.hpl.jena.rdf.listeners with parameters of type Model
`void` | `StatementListener.addedStatements(Model m)`
`void` | `ObjectListener.addedStatements(Model m)`
`void` | `NullListener.addedStatements(Model m)`
`void` | `ChangedListener.addedStatements(Model m)`
`void` | `StatementListener.notifyEvent(Model m, java.lang.Object event)`
`void` | `ObjectListener.notifyEvent(Model m, java.lang.Object event)`
`void` | `NullListener.notifyEvent(Model m, java.lang.Object event)`
`void` | `ChangedListener.notifyEvent(Model m, java.lang.Object event)`
`void` | `StatementListener.removedStatements(Model m)`
`void` | `ObjectListener.removedStatements(Model m)`
`void` | `NullListener.removedStatements(Model m)`
`void` | `ChangedListener.removedStatements(Model m)`

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

Subinterfaces of Model in com.hp.hpl.jena.rdf.model
`interface` | `InfModel` An extension to the normal Model interface that supports access to any underlying inference capability.

Methods in com.hp.hpl.jena.rdf.model that return Model
`Model` | `Model.abort()` Abort the current transaction and abandon any changes in progress.
`Model` | `Model.add(java.util.List statements)` add all the statements in the List to this Model, going through the bulk update interface (which means turning them into triples in one form or another).
`Model` | `Model.add(Model m)` Add all the statements in another model to this model, including the reified statements.
`Model` | `Model.add(Model m, boolean suppressReifications)` Add all the statements of the given model m to this model.
`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.add(Resource s, Property p, java.lang.String o, java.lang.String l, boolean wellFormed)` Deprecated. since Jena2. It is no longer legal to have a language tag on a well-formed XMLLiteral. Use the 4-argument form of `add` instead. add a statement to this model.
`Model` | `Model.add(Statement s)` Add a statement to this model.
`Model` | `Model.add(Statement[] statements)` Add all the statements to the Model, using through the bulk update interface.
`Model` | `Model.add(StmtIterator iter)` Add all the statements returned by an iterator 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, 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)` add a statement to this model.
`static Model` | `ModelFactory.assembleModelFrom(Model singleRoot)` Answer a Model constructed from the single resource in `singleRoot` of type `ja:Model`.
`static Model` | `ModelFactory.assembleModelFrom(Resource root)` Answer a Model as described the the Assembler specification rooted at the Resource `root` in its Model.
`Model` | `Model.begin()` Begin a new transation.
`Model` | `Model.commit()` Commit the current transaction.
`Model` | `ModelSource.createDefaultModel()` Answer this ModelSource's default model.
`static Model` | `ModelFactory.createDefaultModel()` Answer a fresh Model with the default specification and Standard reification style [reification triples contribute to ReifiedStatements, and are visible to listStatements, etc].
`static Model` | `ModelFactory.createDefaultModel(ReificationStyle style)` Answer a new memory-based model with the given reification style
`Model` | `ModelSource.createFreshModel()` Answer a Model that satisfies this ModelSource's shape.
`Model` | `ModelMaker.createModel(java.lang.String name)` Create a Model that does not already exist - equivalent to `createModel( name, false )`.
`Model` | `ModelMaker.createModel(java.lang.String name, boolean strict)` Create a new Model associated with the given name.
`static Model` | `ModelFactory.createModelForGraph(Graph g)` Answer a model that encapsulates the given graph.
`static Model` | `ModelFactory.createNonreifyingModel()` construct a new memory-based model that does not capture reification triples (but still handles reifyAs() and .as(ReifiedStatement).
`static Model` | `ModelFactory.createUnion(Model m1, Model m2)` Answer a new model that is the dynamic union of two other models.
`Model` | `Model.difference(Model model)` Create a new, independant, model containing all the statements in this model which are not in another.
`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`.
`Model` | `InfModel.getDeductionsModel()` Returns a derivations model.
`Model` | `Statement.getModel()` get the Model this Statement was created in.
`Model` | `Resource.getModel()` Return the model associated with this resource.
`Model` | `ModelGetter.getModel(java.lang.String URL)` Answer a Model whose content is that associated with the URL, if possible, and otherwise answer null.
`Model` | `ModelGetter.getModel(java.lang.String URL, ModelReader loadIfAbsent)` Answer a model appropriate for `URL`, If none is to hand, and it's possible to create one, create it and load it using `loadIfAbsent`.
`Model` | `InfModel.getRawModel()` Return the raw RDF model being processed (i.e. the argument to the Reasonder.bind call that created this InfModel).
`Model` | `Model.intersection(Model model)` Create a new, independant, model containing all the statements which are in both this model and another.
`Model` | `Model.notifyEvent(java.lang.Object e)` Notify any listeners that the event e has occurred.
`Model` | `ModelSource.openModel(java.lang.String name)` Answer a model.
`Model` | `ModelMaker.openModel(java.lang.String name, boolean strict)` Find an existing Model that this factory knows about under the given name.
`Model` | `ModelSource.openModelIfPresent(java.lang.String string)` Answer the model named by `string` in this ModelSource, if it [still] has one, or `null` if there isn't one.
`Model` | `Model.query(Selector s)` Create a new model containing the statements matching a query.
`Model` | `Model.read(java.io.InputStream in, java.lang.String base)` Add statements from an RDF/XML serialization.
`Model` | `Model.read(java.io.InputStream in, java.lang.String base, java.lang.String lang)` Add RDF statements represented in language `lang` to the model.
`Model` | `Model.read(java.io.Reader reader, java.lang.String base)` Using this method is often a mistake.
`Model` | `Model.read(java.io.Reader reader, java.lang.String base, java.lang.String lang)` Using this method is often a mistake.
`Model` | `Model.read(java.lang.String url)` Add the RDF statements from an XML document.
`Model` | `Model.read(java.lang.String url, java.lang.String lang)` Add statements from a serializion in language `lang` to the model.
`Model` | `Model.read(java.lang.String url, java.lang.String base, java.lang.String lang)` Read into this model the RDF at `url`, using `baseURI` as the base URI if it is non-null.
`Model` | `ModelReader.readModel(Model toRead, java.lang.String URL)` Read the contents of `URL` into `toRead` and answer `toRead`,
`Model` | `Model.register(ModelChangedListener listener)` Register a listener for model-changed events on this model.
`Model` | `Model.remove(java.util.List statements)` Remove all the statements in the list from this model, using the bulk update interface.
`Model` | `ModelCon.remove(Model m)` Remove all the Statements in a given model, including reified statements
`Model` | `ModelCon.remove(Model m, boolean suppressReifications)` Remove from this model all the statements found in the given model.
`Model` | `ModelCon.remove(Resource s, Property p, RDFNode o)` remove the statement `(s, p, o)` from this model and answer this model.
`Model` | `Model.remove(Statement s)` Removes a statement.
`Model` | `Model.remove(Statement[] statements)` Remove all the statements from the Model, using the bulk update interface.
`Model` | `ModelCon.remove(StmtIterator iter)` Remove all the Statements returned by an iterator.
`Model` | `Model.removeAll()` Remove all the statements from this model.
`Model` | `Model.removeAll(Resource s, Property p, RDFNode r)` Remove all the statements matching (s, p, o) from this model.
`Model` | `Model.union(Model model)` Create a new, independant, model containing all the statements in this model together with all of those in another given model.
`Model` | `Model.unregister(ModelChangedListener listener)` Unregister a listener from model-changed events on this model.
`static Model` | `ModelFactory.withHiddenStatements(Model m)` Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification.
`Model` | `Model.write(java.io.OutputStream out)` Write a serialization of this model as an XML document.
`Model` | `Model.write(java.io.OutputStream out, java.lang.String lang)` Write a serialized represention of this model in a specified language.
`Model` | `Model.write(java.io.OutputStream out, java.lang.String lang, java.lang.String base)` Write a serialized represention of a model in a specified language.
`Model` | `Model.write(java.io.Writer writer)` Write the model as an XML document.
`Model` | `Model.write(java.io.Writer writer, java.lang.String lang)` Write a serialized represention of a model in a specified language.
`Model` | `Model.write(java.io.Writer writer, java.lang.String lang, java.lang.String base)` Write a serialized represention of a model in a specified language.

Methods in com.hp.hpl.jena.rdf.model with parameters of type Model
`Model` | `Model.add(Model m)` Add all the statements in another model to this model, including the reified statements.
`Model` | `Model.add(Model m, boolean suppressReifications)` Add all the statements of the given model m to this model.
`void` | `ModelChangedListener.addedStatements(Model m)` Method to call when a model has been used to define the statements to be added to our attached model.
`static Model` | `ModelFactory.assembleModelFrom(Model singleRoot)` Answer a Model constructed from the single resource in `singleRoot` of type `ja:Model`.
`TripleBoundary` | `StatementTripleBoundary.asTripleBoundary(Model ignored)` Answer the supplied-to-constructor TripleBoundary.
`TripleBoundary` | `StatementBoundaryBase.asTripleBoundary(Model m)` Expresses this StatementBoundary as a TripleBoundary.
`TripleBoundary` | `StatementBoundary.asTripleBoundary(Model m)` Answer a TripleBoundary corresponding to this StatementBoundary, where Triples may be converted to Statements using `m`.
`boolean` | `Model.containsAll(Model model)` Determine if all of the statements in a model are also contained in this model.
`boolean` | `Model.containsAny(Model model)` Determine if any of the statements in a model are also contained in this model.
`static TripleBoundary` | `StatementBoundaryBase.convert(Model s, StatementBoundary b)` Answer a TripleBoundary that is implemented in terms of a StatementBoundary.
`static InfModel` | `ModelFactory.createInfModel(Reasoner reasoner, Model model)` Build an inferred model by attaching the given RDF model to the given reasoner.
`static InfModel` | `ModelFactory.createInfModel(Reasoner reasoner, Model schema, Model model)` Build an inferred model by attaching the given RDF model to the given reasoner.
`static OntModel` | `ModelFactory.createOntologyModel(OntModelSpec spec, Model base)` Answer a new ontology model, constructed according to the given ontology model specification, and starting with the ontology data in the given model.
`static OntModel` | `ModelFactory.createOntologyModel(OntModelSpec spec, ModelMaker maker, Model base)` Answer a new ontology model which will process in-memory models of ontologies expressed the default ontology language (OWL).
`static InfModel` | `ModelFactory.createRDFSModel(Model model)` Return a Model through which all the RDFS entailments derivable from the given model are accessible.
`static InfModel` | `ModelFactory.createRDFSModel(Model schema, Model model)` Return a Model through which all the RDFS entailments derivable from the given data and schema models are accessible.
`static Model` | `ModelFactory.createUnion(Model m1, Model m2)` Answer a new model that is the dynamic union of two other models.
`Model` | `Model.difference(Model model)` Create a new, independant, model containing all the statements in this model which are not in another.
`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`.
`static java.util.Set` | `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`.
`RDFNode` | `RDFNode.inModel(Model m)` Answer a .equals() version of this node, except that it's in the model `m`.
`Model` | `Model.intersection(Model model)` Create a new, independant, model containing all the statements which are in both this model and another.
`boolean` | `Model.isIsomorphicWith(Model g)` Compare this Model with another for equality ignoring the labels on bNodes.
`StmtIterator` | `InfModel.listStatements(Resource subject, Property predicate, RDFNode object, Model posit)` Find all the statements matching a pattern.
`void` | `ModelChangedListener.notifyEvent(Model m, java.lang.Object event)`
`void` | `RDFReader.read(Model model, java.io.InputStream r, java.lang.String base)` Read serialized RDF from an `InputStream` and add the statements to a `Model`.
`void` | `RDFReader.read(Model model, java.io.Reader r, java.lang.String base)` It is usually a mistake to use this method.
`void` | `RDFReader.read(Model model, java.lang.String url)` Read serialized RDF from a url and add the statements to a model.
`Model` | `ModelReader.readModel(Model toRead, java.lang.String URL)` Read the contents of `URL` into `toRead` and answer `toRead`,
`Model` | `ModelCon.remove(Model m)` Remove all the Statements in a given model, including reified statements
`Model` | `ModelCon.remove(Model m, boolean suppressReifications)` Remove from this model all the statements found in the given model.
`void` | `ModelChangedListener.removedStatements(Model m)` Method to call when a model has been used to remove statements from our attached model.
`Model` | `Model.union(Model model)` Create a new, independant, model containing all the statements in this model together with all of those in another given model.
`static Model` | `ModelFactory.withHiddenStatements(Model m)` Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification.
`void` | `RDFWriter.write(Model model, java.io.OutputStream out, java.lang.String base)` Serialize Model `model` to OutputStream `out.`
`void` | `RDFWriter.write(Model model, java.io.Writer out, java.lang.String base)` Caution: Serialize Model `model` to Writer `out`.

Uses of Model in com.hp.hpl.jena.rdf.model.impl

Classes in com.hp.hpl.jena.rdf.model.impl that implement Model
`class` | `com.hp.hpl.jena.rdf.model.impl.ModelCom` Common methods for model implementations.

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

Methods in com.hp.hpl.jena.reasoner that return Model
`Model` | `ReasonerRegistry.getAllDescriptions()` Return a composite set of RDF capability descriptions for all registered reasoners.
`Model` | `ReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `Reasoner.getReasonerCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.

Methods in com.hp.hpl.jena.reasoner with parameters of type Model
`void` | `Reasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`Reasoner` | `Reasoner.bindSchema(Model tbox)` This is most commonly used to attach an ontology (a set of tbox axioms in description logics jargon) to a reasoner.

Uses of Model in com.hp.hpl.jena.reasoner.dig

Methods in com.hp.hpl.jena.reasoner.dig that return Model
`Model` | `DIGReasoner.getAxioms()` Answer the model that contains the given axioms for this reasoner, or null if not defined.
`Model` | `DIGReasonerFactory.getCapabilities()`
`Model` | `DIGReasoner.getReasonerCapabilities()` Answer the capabilities of this reasoner.

Methods in com.hp.hpl.jena.reasoner.dig with parameters of type Model
`void` | `DIGAdapter.addClassDescription(org.w3c.dom.Element elem, Node node, Model sourceData)` Add a DIG reference to the class identifed in the source graph by the given Jena graph Node to the given XML element.
`void` | `DIGAdapter.addClassDescription(org.w3c.dom.Element elem, Resource res, Model sourceData)` Add a DIG reference to the class identifed in the source graph by the given Jena resource to the given XML element.
`void` | `DIGReasoner.addDescription(Model configSpec, Resource base)` Add this reasoner's description to the given configuration model.
`Reasoner` | `DIGReasoner.bindSchema(Model tbox)` Bind a schema, or tbox, to this DIG reasoner.
`boolean` | `DIGQueryTranslator.checkObject(Node object, DIGAdapter da, Model premises)` Additional test on the object of the incoming find pattern.
`boolean` | `DIGQuerySubsumesTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleFillerTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleAncestorsTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryIsRoleTranslator.checkObject(Node object, DIGAdapter da, Model premises)` Additional test on the object of the incoming find pattern.
`boolean` | `DIGQueryIsIndividualTranslator.checkObject(Node object, DIGAdapter da, Model premises)` Additional test on the object of the incoming find pattern.
`boolean` | `DIGQueryIsConceptTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryInstanceTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryInstancesTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryEquivalentsTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryDisjointTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryDifferentFromTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryAncestorsTranslator.checkObject(Node object, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryTranslator.checkPredicate(Node pred, DIGAdapter da, Model premises)` Additional test on the predicate of the incoming find pattern.
`boolean` | `DIGQueryRoleFillerTranslator.checkPredicate(Node predicate, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleFillersTranslator.checkPredicate(Node predicate, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRelatedIndividualsTranslator.checkPredicate(Node predicate, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryTypesTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)` Additional test on the subject of the incoming find pattern.
`boolean` | `DIGQuerySubsumesTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleFillerTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleFillersTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryRoleAncestorsTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryIsRoleTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryIsIndividualTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryIsConceptTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryEquivalentsTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryDisjointTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryDifferentFromTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryAncestorsTranslator.checkSubject(Node subject, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryTranslator.checkTriple(TriplePattern pattern, DIGAdapter da, Model premises)` An optional post-trigger check on the consituents of the triple pattern.
`boolean` | `DIGQueryIsEquivalentTranslator.checkTriple(TriplePattern pattern, DIGAdapter da, Model premises)` Check whether the pattern matches the preconditions for the translation step.
`boolean` | `DIGQueryEquivalentsTranslator.checkTriple(TriplePattern pattern, DIGAdapter da, Model premises)`
`ExtendedIterator` | `DIGQueryTranslator.find(TriplePattern pattern, DIGAdapter da, Model premises)` Translate the given pattern (with given premises) to a DIG query, and pass it on to the DIG adapter as a query.
`ExtendedIterator` | `DIGQueryIsRoleTranslator.find(TriplePattern pattern, DIGAdapter da, Model premises)` For this translation, we ignore premises
`ExtendedIterator` | `DIGQueryIsIndividualTranslator.find(TriplePattern pattern, DIGAdapter da, Model premises)` For this translation, we ignore premises
`ExtendedIterator` | `DIGQueryIsConceptTranslator.find(TriplePattern pattern, DIGAdapter da, Model premises)` For this translation, we ignore premises
`ExtendedIterator` | `DIGAdapter.find(TriplePattern pattern, Model premises)` Basic pattern lookup interface - answer an iterator over the triples matching the given (S,P,O) pattern, given also some premises for the query.
`DIGQueryTranslator` | `DIGAdapter.getQueryTranslator(TriplePattern pattern, Model premises)` Answer the query translator that matches the given pattern, if any
`boolean` | `DIGAdapter.isConcept(Node node, Model premises)` Answer true if the given node corresponds to one of the concepts known to the DIG reasoner.
`boolean` | `DIGAdapter.isRole(Node node, Model premises)` Answer true if the given node corresponds to one of the roles known to the DIG reasoner.
`org.w3c.dom.Document` | `DIGQueryTypesTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`abstract org.w3c.dom.Document` | `DIGQueryTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)` Answer an XML document that presents the translation of the query into DIG query language, given that either the subject or object may be expressions defined by the statements in the premises model.
`org.w3c.dom.Document` | `DIGQuerySubsumesTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)` Answer a query that will test subsumption between two classes, given that either one or both may be defined as an expression given the premises
`org.w3c.dom.Document` | `DIGQueryRoleFillerTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryRoleFillersTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryRoleAncestorsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryRelatedIndividualsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryIsRoleTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryIsIndividualTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryIsEquivalentTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryIsConceptTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryInstanceTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)` Answer a query that will test whether an invidividual is a member of a given named class or class expression (defined by the premises)
`org.w3c.dom.Document` | `DIGQueryInstancesTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)` Answer a query that will list the instances of a given concept, optionally defined as a class expression in the premises.
`org.w3c.dom.Document` | `DIGQueryEquivalentsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryDisjointTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryDifferentFromTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryAncestorsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryAllRolesTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryAllIndividualsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGQueryAllConceptsTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`org.w3c.dom.Document` | `DIGIteratedQueryTranslator.translatePattern(TriplePattern pattern, DIGAdapter da, Model premises)`
`boolean` | `DIGQueryTranslator.trigger(TriplePattern pattern, DIGAdapter da, Model premises)` Answer true if this translator applies to the given triple pattern.
`boolean` | `DIGQueryIsEquivalentTranslator.trigger(TriplePattern pattern, DIGAdapter da, Model premises)`

Constructors in com.hp.hpl.jena.reasoner.dig with parameters of type Model
`DIGAdapter(OntModelSpec spec, Graph source, DIGConnection connection, Model axioms)` Construct a DIG adapter for the given source data graph, which is encoding an ontology in a language represented by the given model spec.

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

Methods in com.hp.hpl.jena.reasoner.rulesys that return Model
`Model` | `RDFSRuleReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `RDFSFBRuleReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `OWLMiniReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `OWLMicroReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `OWLFBRuleReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `GenericRuleReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `DAMLMicroReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `LPBackwardRuleReasoner.getReasonerCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `FBRuleReasoner.getReasonerCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `BasicForwardRuleReasoner.getReasonerCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.

Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Model
`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.
`Reasoner` | `LPBackwardRuleReasoner.bindSchema(Model tbox)` Precompute the implications of a schema Model.
`Reasoner` | `FBRuleReasoner.bindSchema(Model tbox)` Precompute the implications of a schema Model.
`Reasoner` | `BasicForwardRuleReasoner.bindSchema(Model tbox)` Precompute the implications of a schema Model.

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

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner that return Model
`Model` | `TransitiveReasonerFactory.getCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.
`Model` | `TransitiveReasoner.getReasonerCapabilities()` Return a description of the capabilities of this reasoner encoded in RDF.

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Model
`void` | `TransitiveReasoner.addDescription(Model configSpec, Resource base)` Add a configuration description for this reasoner into a partial configuration specification model.
`Reasoner` | `TransitiveReasoner.bindSchema(Model tbox)` Extracts all of the subClass and subProperty declarations from the given schema/tbox and caches the resultant graphs.

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

Fields in com.hp.hpl.jena.shared declared as Model
`Model` | `BadDescriptionException.badModel`

Methods in com.hp.hpl.jena.shared that return Model
`static Model` | `RandomOrderGraph.createDefaultModel()`

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

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

Classes in com.hp.hpl.jena.util that implement Model
`class` | `MonitorModel` Model wrapper which provides normal access to an underlying model but also maintains a snapshot of the triples it was last known to contain.

Methods in com.hp.hpl.jena.util that return Model
`static Model` | `ModelLoader.connectToDB(java.lang.String urlStr, java.lang.String dbUser, java.lang.String dbPassword, java.lang.String modelName, java.lang.String dbType, java.lang.String driverName)` Connect to a database.
`Model` | `FileManager.getFromCache(java.lang.String filenameOrURI)` Read out of the cache - return null if not in the cache
`static Model` | `ModelLoader.loadModel(Model model, java.lang.String urlStr)` Deprecated. Use FileManager.get().readModel(model, urlStr) instead
`static Model` | `ModelLoader.loadModel(Model model, java.lang.String urlStr, java.lang.String lang)` Deprecated. Use FileManager.get().readModel(model, urlStr, lang) instead
`static Model` | `ModelLoader.loadModel(java.lang.String urlStr)` Deprecated. Use FileManager.get().loadModel(urlStr)
`Model` | `FileManager.loadModel(java.lang.String filenameOrURI)` Load a model from a file (local or remote).
`static Model` | `ModelLoader.loadModel(java.lang.String urlStr, java.lang.String lang)` Deprecated. Use FileManager.get().loadModel(urlStr, lang)
`Model` | `FileManager.loadModel(java.lang.String filenameOrURI, java.lang.String rdfSyntax)` Load a model from a file (local or remote).
`Model` | `FileManager.loadModel(java.lang.String filenameOrURI, java.lang.String baseURI, java.lang.String rdfSyntax)` Load a model from a file (local or remote).
`static Model` | `ModelLoader.loadModel(java.lang.String urlStr, java.lang.String lang, java.lang.String dbUser, java.lang.String dbPassword, java.lang.String modelName, java.lang.String dbType, java.lang.String driver)` Load a model or attached a persistent store.
`static Model` | `ResourceUtils.reachableClosure(Resource root)` Answer a model that contains all of the resources reachable from a given resource by any property, transitively.
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI)` Read a file of RDF into a model.
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI, java.lang.String rdfSyntax)` Read a file of RDF into a model.
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI, java.lang.String baseURI, java.lang.String syntax)` Read a file of RDF into a model.
`Model` | `LocationMapper.toModel()`

Methods in com.hp.hpl.jena.util with parameters of type Model
`void` | `FileManager.addCacheModel(java.lang.String uri, Model m)`
`static RDFNode` | `ModelQueryUtil.asRDF(Model m, Node n)`
`static Model` | `ModelLoader.loadModel(Model model, java.lang.String urlStr)` Deprecated. Use FileManager.get().readModel(model, urlStr) instead
`static Model` | `ModelLoader.loadModel(Model model, java.lang.String urlStr, java.lang.String lang)` Deprecated. Use FileManager.get().readModel(model, urlStr, lang) instead
`static java.util.List` | `ModelQueryUtil.mappy(Model m, java.lang.Object x)`
`void` | `LocationMapper.processConfig(Model m)`
`static ExtendedIterator` | `ModelQueryUtil.queryBindingsWith(Model model, Model query, Resource[] variables)`
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI)` Read a file of RDF into a model.
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI, java.lang.String rdfSyntax)` Read a file of RDF into a model.
`Model` | `FileManager.readModel(Model model, java.lang.String filenameOrURI, java.lang.String baseURI, java.lang.String syntax)` Read a file of RDF into a model.
`void` | `LocationMapper.toModel(Model model)`
`Graph` | `QueryMapper.toQueryGraph(Model m)`

Constructors in com.hp.hpl.jena.util with parameters of type Model
`LocationMapper(Model model)` Create a LocationMapper from an existing model
`MonitorModel(Model base)` Create a monitor over the given underlying base model.
`QueryMapper(Model m, Resource[] variables)`

Uses of Model in com.hp.hpl.jena.vocabulary

Methods in com.hp.hpl.jena.vocabulary that return Model
`static Model` | `JenaModelSpec.getSchema()` Deprecated. Answer the JenaModelSpec schema encoded into a model.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP