|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Quad in com.hp.hpl.jena.sparql.algebra.op |
---|
Methods in com.hp.hpl.jena.sparql.algebra.op that return Quad | |
---|---|
Quad |
OpQuad.getQuad()
|
Constructors in com.hp.hpl.jena.sparql.algebra.op with parameters of type Quad | |
---|---|
OpQuad(Quad quad)
|
Uses of Quad in com.hp.hpl.jena.sparql.core |
---|
Methods in com.hp.hpl.jena.sparql.core that return Quad | |
---|---|
Quad |
QuadPattern.get(int i)
|
static Quad |
Substitute.substitute(Quad quad,
Binding binding)
|
Methods in com.hp.hpl.jena.sparql.core that return types with arguments of type Quad | |
---|---|
Iterator<Quad> |
DatasetGraphWrapper.find()
|
Iterator<Quad> |
DatasetGraphBase.find()
|
Iterator<Quad> |
DatasetGraph.find()
Iterate over all quads in the dataset graph |
Iterator<Quad> |
DatasetGraphWrapper.find(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
Iterator<Quad> |
DatasetGraphBaseFind.find(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
Implementation of find based on splitting into triples (default graph) and quads (named graph) |
Iterator<Quad> |
DatasetGraphOne.find(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
abstract Iterator<Quad> |
DatasetGraphQuad.find(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
Iterator<Quad> |
DatasetGraph.find(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
Find matching quads in the dataset (including default graph) - may include wildcards, Node.ANY or null |
Iterator<Quad> |
DatasetGraphWrapper.find(Quad quad)
|
Iterator<Quad> |
DatasetGraphBase.find(Quad quad)
|
Iterator<Quad> |
DatasetGraph.find(Quad quad)
Find matching quads in the dataset - may include wildcards, Node.ANY or null |
Iterator<Quad> |
DatasetGraphWrapper.findNG(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
Iterator<Quad> |
DatasetGraphBaseFind.findNG(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
abstract Iterator<Quad> |
DatasetGraphQuad.findNG(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
|
Iterator<Quad> |
DatasetGraph.findNG(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o)
Find matching quads in the dataset in named graphs only - may include wildcards, Node.ANY or null |
List<Quad> |
QuadPattern.getList()
|
ListIterator<Quad> |
QuadPattern.iterator()
|
Methods in com.hp.hpl.jena.sparql.core with parameters of type Quad | |
---|---|
void |
QuadPattern.add(int i,
Quad q)
|
void |
DatasetGraphWrapper.add(Quad quad)
|
void |
QuadPattern.add(Quad q)
|
void |
DatasetGraphTriplesQuads.add(Quad quad)
|
void |
DatasetGraphBase.add(Quad quad)
|
void |
DatasetGraphOne.add(Quad quad)
|
void |
DatasetGraphCollection.add(Quad quad)
|
abstract void |
DatasetGraphQuad.add(Quad quad)
|
void |
DatasetGraph.add(Quad quad)
Add a quad |
boolean |
DatasetGraphWrapper.contains(Quad quad)
|
boolean |
DatasetGraphBase.contains(Quad quad)
|
boolean |
DatasetGraph.contains(Quad quad)
Test whether the dataset contains a quad (including default graph)- may include wildcards, Node.ANY or null |
void |
DatasetGraphWrapper.delete(Quad quad)
|
void |
DatasetGraphTriplesQuads.delete(Quad quad)
|
void |
DatasetGraphBase.delete(Quad quad)
|
void |
DatasetGraphOne.delete(Quad quad)
|
void |
DatasetGraphCollection.delete(Quad quad)
|
abstract void |
DatasetGraphQuad.delete(Quad quad)
|
void |
DatasetGraph.delete(Quad quad)
Delete a quad |
Iterator<Quad> |
DatasetGraphWrapper.find(Quad quad)
|
Iterator<Quad> |
DatasetGraphBase.find(Quad quad)
|
Iterator<Quad> |
DatasetGraph.find(Quad quad)
Find matching quads in the dataset - may include wildcards, Node.ANY or null |
static Quad |
Substitute.substitute(Quad quad,
Binding binding)
|
Uses of Quad in com.hp.hpl.jena.sparql.graph |
---|
Methods in com.hp.hpl.jena.sparql.graph that return Quad | |
---|---|
static Quad |
NodeTransformLib.transform(NodeTransform nodeTransform,
Quad quad)
Do a node->node conversion of a Quad - return original Quad for "no change" |
Methods in com.hp.hpl.jena.sparql.graph that return types with arguments of type Quad | |
---|---|
static List<Quad> |
NodeTransformLib.transformQuads(NodeTransform nodeTransform,
List<Quad> quads)
Do a node->node conversion of a List<Quad> - return original List<Quad> for "no change" |
Methods in com.hp.hpl.jena.sparql.graph with parameters of type Quad | |
---|---|
static Quad |
NodeTransformLib.transform(NodeTransform nodeTransform,
Quad quad)
Do a node->node conversion of a Quad - return original Quad for "no change" |
Method parameters in com.hp.hpl.jena.sparql.graph with type arguments of type Quad | |
---|---|
static List<Quad> |
NodeTransformLib.transformQuads(NodeTransform nodeTransform,
List<Quad> quads)
Do a node->node conversion of a List<Quad> - return original List<Quad> for "no change" |
Uses of Quad in com.hp.hpl.jena.sparql.modify |
---|
Methods in com.hp.hpl.jena.sparql.modify that return Quad | |
---|---|
static Quad |
TemplateLib.subst(Quad quad,
Binding b,
Map<com.hp.hpl.jena.graph.Node,com.hp.hpl.jena.graph.Node> bNodeMap)
Substitute into a quad, with rewriting of bNodes |
Methods in com.hp.hpl.jena.sparql.modify that return types with arguments of type Quad | |
---|---|
static Iterator<Quad> |
TemplateLib.calcQuads(List<Quad> quads,
Iterator<Binding> bindings)
Substitute into quad patterns |
static Iterator<Quad> |
TemplateLib.template(List<Quad> quads,
com.hp.hpl.jena.graph.Node dftGraph,
Iterator<Binding> bindings)
Take a template, as a list of quad patterns, a default graph, and an iterator of bindings, and produce an iterator of quads that result from applying the template to the bindings. |
Methods in com.hp.hpl.jena.sparql.modify with parameters of type Quad | |
---|---|
static Quad |
TemplateLib.subst(Quad quad,
Binding b,
Map<com.hp.hpl.jena.graph.Node,com.hp.hpl.jena.graph.Node> bNodeMap)
Substitute into a quad, with rewriting of bNodes |
Method parameters in com.hp.hpl.jena.sparql.modify with type arguments of type Quad | |
---|---|
static Iterator<Quad> |
TemplateLib.calcQuads(List<Quad> quads,
Iterator<Binding> bindings)
Substitute into quad patterns |
static MultiMap<com.hp.hpl.jena.graph.Node,com.hp.hpl.jena.graph.Triple> |
TemplateLib.calcTriples(List<Quad> quads,
List<Binding> bindings)
Substitute into quad patterns, and build a map of graph name to lists of triples |
static Iterator<Quad> |
TemplateLib.template(List<Quad> quads,
com.hp.hpl.jena.graph.Node dftGraph,
Iterator<Binding> bindings)
Take a template, as a list of quad patterns, a default graph, and an iterator of bindings, and produce an iterator of quads that result from applying the template to the bindings. |
static MultiMap<com.hp.hpl.jena.graph.Node,com.hp.hpl.jena.graph.Triple> |
TemplateLib.template(List<Quad> quads,
com.hp.hpl.jena.graph.Node dftGraph,
List<Binding> bindings)
Take a template, as a list of quad patterns, a default graph, and a list of bindings, and produce a map of graph name to lists of triples. |
Uses of Quad in com.hp.hpl.jena.sparql.modify.request |
---|
Methods in com.hp.hpl.jena.sparql.modify.request that return types with arguments of type Quad | |
---|---|
List<Quad> |
UpdateModify.getDeleteQuads()
|
List<Quad> |
UpdateModify.getInsertQuads()
|
List<Quad> |
UpdateData.getQuads()
|
List<Quad> |
UpdateDeleteWhere.getQuads()
|
List<Quad> |
QuadAcc.getQuads()
|
Methods in com.hp.hpl.jena.sparql.modify.request with parameters of type Quad | |
---|---|
void |
QuadAcc.addQuad(Quad quad)
|
Uses of Quad in com.hp.hpl.jena.sparql.sse |
---|
Methods in com.hp.hpl.jena.sparql.sse that return Quad | |
---|---|
static Quad |
SSE.parseQuad(String s)
Parse a string to obtain a Quad |
static Quad |
SSE.parseQuad(String s,
com.hp.hpl.jena.shared.PrefixMapping pmap)
Parse a string to obtain a Quad |
Methods in com.hp.hpl.jena.sparql.sse with parameters of type Quad | |
---|---|
static void |
SSE.write(IndentedWriter out,
Quad quad)
|
static void |
SSE.write(OutputStream out,
Quad quad)
|
static void |
SSE.write(Quad quad)
|
Uses of Quad in com.hp.hpl.jena.sparql.sse.builders |
---|
Methods in com.hp.hpl.jena.sparql.sse.builders that return Quad | |
---|---|
static Quad |
BuilderGraph.buildNode4(ItemList list)
|
static Quad |
BuilderGraph.buildQuad(ItemList list)
|
Uses of Quad in com.hp.hpl.jena.sparql.sse.writers |
---|
Methods in com.hp.hpl.jena.sparql.sse.writers with parameters of type Quad | |
---|---|
static void |
WriterNode.output(IndentedWriter out,
Quad qp,
SerializationContext naming)
|
static void |
WriterNode.outputPlain(IndentedWriter out,
Quad qp,
SerializationContext naming)
|
Uses of Quad in com.hp.hpl.jena.sparql.util |
---|
Methods in com.hp.hpl.jena.sparql.util with parameters of type Quad | |
---|---|
static boolean |
Utils.quadIso(Quad t1,
Quad t2,
NodeIsomorphismMap labelMap)
|
static String |
FmtUtils.stringForQuad(Quad quad)
|
static String |
FmtUtils.stringForQuad(Quad quad,
com.hp.hpl.jena.shared.PrefixMapping prefixMap)
|
Uses of Quad in org.openjena.riot |
---|
Methods in org.openjena.riot that return types with arguments of type Quad | |
---|---|
static Sink<Quad> |
RiotLoader.datasetSink(DatasetGraph dataset)
|
static SerializationFactory<Quad> |
SerializationFactoryFinder.quadSerializationFactory()
|
Method parameters in org.openjena.riot with type arguments of type Quad | |
---|---|
static LangNQuads |
RiotReader.createParserNQuads(InputStream input,
Sink<Quad> sink)
Create a parser for NQuads, with default behaviour |
static LangNQuads |
RiotReader.createParserNQuads(Tokenizer tokenizer,
Sink<Quad> sink)
Create a parser for NQuads, with default behaviour |
static LangRIOT |
RiotReader.createParserQuads(InputStream input,
Lang lang,
String baseIRI,
Sink<Quad> sink)
Create a parser for a quads (or triples) language |
static LangRIOT |
RiotReader.createParserQuads(Tokenizer tokenizer,
Lang lang,
String baseIRI,
Sink<Quad> sink)
Create a parser for a quads language |
static LangTriG |
RiotReader.createParserTriG(InputStream input,
String baseIRI,
Sink<Quad> sink)
Create a parser for TriG, with default behaviour |
static LangTriG |
RiotReader.createParserTriG(Tokenizer tokenizer,
String baseIRI,
Sink<Quad> sink)
Create a parser for TriG, with default behaviour |
static void |
RiotReader.parseQuads(InputStream in,
Lang lang,
String baseIRI,
Sink<Quad> sink)
Parse an InputStream, sending quads to a sink. |
static void |
RiotReader.parseQuads(String filename,
Lang lang,
String baseIRI,
Sink<Quad> sink)
Parse a file, sending quads to a sink. |
static void |
RiotReader.parseQuads(String filename,
Sink<Quad> sink)
Parse a file, sending quads to a sink. |
static void |
RiotLoader.readQuads(InputStream input,
Lang language,
String baseURI,
Sink<Quad> sink)
Parse an input stream and send the quads to the sink |
Uses of Quad in org.openjena.riot.lang |
---|
Methods in org.openjena.riot.lang with parameters of type Quad | |
---|---|
void |
SinkQuadsToDataset.send(Quad quad)
|
Constructor parameters in org.openjena.riot.lang with type arguments of type Quad | |
---|---|
LangNQuads(Tokenizer tokens,
ParserProfile profile,
Sink<Quad> sink)
|
|
LangTriG(String baseURI,
Tokenizer tokens,
ParserProfile profile,
Sink<Quad> sink)
|
Uses of Quad in org.openjena.riot.out |
---|
Methods in org.openjena.riot.out with parameters of type Quad | |
---|---|
static void |
OutputLangUtils.output(Writer out,
Quad quad,
Prologue prologue,
NodeToLabel labelPolicy)
|
void |
SinkQuadOutput.send(Quad quad)
|
static String |
NodeFmtLib.str(Quad q)
|
Uses of Quad in org.openjena.riot.pipeline |
---|
Methods in org.openjena.riot.pipeline with parameters of type Quad | |
---|---|
void |
SinkQuadNodeTransform.send(Quad quad)
|
Constructor parameters in org.openjena.riot.pipeline with type arguments of type Quad | |
---|---|
SinkQuadNodeTransform(Sink<Quad> sink,
NodeTransform nodeTransform)
Apply the nodeTransform to each of G, S, P and O |
|
SinkQuadNodeTransform(Sink<Quad> sink,
NodeTransform graphNodeTransform,
NodeTransform subjTransform,
NodeTransform predTransform,
NodeTransform objTransform)
Apply the respective nodeTransform to the slot in the triple |
Uses of Quad in org.openjena.riot.pipeline.inf |
---|
Methods in org.openjena.riot.pipeline.inf that return types with arguments of type Quad | |
---|---|
static Sink<Quad> |
InfFactory.infQuads(Sink<Quad> sink,
InferenceSetupRDFS setup)
|
static Sink<Quad> |
InfFactory.infQuads(Sink<Quad> sink,
com.hp.hpl.jena.rdf.model.Model vocab)
|
Method parameters in org.openjena.riot.pipeline.inf with type arguments of type Quad | |
---|---|
static Sink<Quad> |
InfFactory.infQuads(Sink<Quad> sink,
InferenceSetupRDFS setup)
|
static Sink<Quad> |
InfFactory.infQuads(Sink<Quad> sink,
com.hp.hpl.jena.rdf.model.Model vocab)
|
Uses of Quad in org.openjena.riot.system |
---|
Methods in org.openjena.riot.system that return Quad | |
---|---|
Quad |
ParserProfileBase.createQuad(com.hp.hpl.jena.graph.Node g,
com.hp.hpl.jena.graph.Node s,
com.hp.hpl.jena.graph.Node p,
com.hp.hpl.jena.graph.Node o,
long line,
long col)
|
Quad |
ParserProfileChecker.createQuad(com.hp.hpl.jena.graph.Node graph,
com.hp.hpl.jena.graph.Node subject,
com.hp.hpl.jena.graph.Node predicate,
com.hp.hpl.jena.graph.Node object,
long line,
long col)
|
Quad |
ParserProfile.createQuad(com.hp.hpl.jena.graph.Node graph,
com.hp.hpl.jena.graph.Node subject,
com.hp.hpl.jena.graph.Node predicate,
com.hp.hpl.jena.graph.Node object,
long line,
long col)
|
Constructor parameters in org.openjena.riot.system with type arguments of type Quad | |
---|---|
SinkExtendTriplesToQuads(com.hp.hpl.jena.graph.Node gn,
Sink<Quad> quadSink)
|
|
SinkExtendTriplesToQuads(Sink<Quad> quadSink)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |