Uses of Class
com.hp.hpl.jena.sparql.core.Quad

Packages that use Quad
com.hp.hpl.jena.sparql.algebra.op   
com.hp.hpl.jena.sparql.core   
com.hp.hpl.jena.sparql.graph   
com.hp.hpl.jena.sparql.modify   
com.hp.hpl.jena.sparql.modify.request   
com.hp.hpl.jena.sparql.sse   
com.hp.hpl.jena.sparql.sse.builders   
com.hp.hpl.jena.sparql.sse.writers   
com.hp.hpl.jena.sparql.util   
org.openjena.riot   
org.openjena.riot.lang   
org.openjena.riot.out   
org.openjena.riot.pipeline   
org.openjena.riot.pipeline.inf   
org.openjena.riot.system   
 

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)
           
 



Licenced under the Apache License, Version 2.0