| Package | Description |
|---|---|
| org.apache.jena.enhanced |
This package defines the enhanced node and graph classes; an enhanced
node is one embedded in a particular enhanced graph.
|
| org.apache.jena.graph |
This package defines the Graph and Node family of classes, which
form the underlying datatypes of the Jena system.
|
| org.apache.jena.graph.compose |
This package defines simple composite graphs - union, intersection,
difference, and update-tracking.
|
| org.apache.jena.graph.impl |
This package provides basic implementations of Graph interfaces
such as EventManager and Capabilities.
|
| org.apache.jena.mem |
Various memory-based implementations of interfaces,
specifically GraphMem for memory-based Graphs.
|
| org.apache.jena.ontology |
Provides a set of abstractions and convenience classes for accessing and manipluating ontologies
represented in RDF.
|
| org.apache.jena.ontology.impl |
Provides default implementations for the abstractions defined in the
org.apache.jena.ontology package. |
| org.apache.jena.rdf.model |
A package for creating and manipulating RDF graphs.
|
| org.apache.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.
|
| org.apache.jena.reasoner |
The Jena2 reasoner subsystem is designed to allow a range of inference
engines to be plugged into Jena.
|
| org.apache.jena.reasoner.rulesys |
Provides a selection of simple rule engines for Jena inference models.
|
| org.apache.jena.reasoner.rulesys.builtins |
Implementations of the Builtin class which provides primitive operations to the rule
engines.
|
| org.apache.jena.reasoner.rulesys.impl |
Internal implementation objects used by the rule system interpreters
and compilers.
|
| org.apache.jena.reasoner.transitiveReasoner |
This package contains a reasoner which supports transitive-reflexive closure
of subPropertyOf and subClassOf relations.
|
| org.apache.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.
|
| org.apache.jena.system | |
| org.apache.jena.util |
Miscellaneous collection of utility classes.
|
| org.apache.jena.vocabulary |
A package containing constant classes with predefined constant objects
for classes and properties defined in well known vocabularies.
|
| Modifier and Type | Method and Description |
|---|---|
Node |
EnhNode.asNode()
Answer the graph node that this enhanced node wraps
|
| Modifier and Type | Method and Description |
|---|---|
abstract boolean |
Implementation.canWrap(Node node,
EnhGraph eg)
true iff wrapping (node, eg) would succeed.
|
<X extends RDFNode> |
EnhGraph.getNodeAs(Node n,
Class<X> interf)
Answer an enhanced node that wraps the given node and conforms to the given
interface type.
|
<X extends T> |
Personality.newInstance(Class<X> interf,
Node n,
EnhGraph that)
make a new instance of a type _interf_ based on the node _n_ and the
polymorphic _that_; use the implementation wrapper for _interf_ in
_types_.
|
abstract EnhNode |
Implementation.wrap(Node node,
EnhGraph eg)
Create a new EnhNode wrapping a Node in the context of an EnhGraph
|
| Modifier and Type | Method and Description |
|---|---|
void |
EnhGraph.setNodeCache(org.apache.jena.atlas.lib.Cache<Node,RDFNode> cc)
Set the cache controller object for this graph
|
| Constructor and Description |
|---|
EnhNode(Node n,
EnhGraph g) |
| Modifier and Type | Class and Description |
|---|---|
class |
Node_ANY
A Node_ANY (there should be only one) is a meta-node that is used to stand
for any other node in a query.
|
class |
Node_Blank
RDF blank nodes, ie nodes with identity but without URIs.
|
class |
Node_Concrete
This is the class of "concrete" nodes, ie those which correspond
to actual RDF data - URIs, blank nodes, and literals.
|
class |
Node_Ext<X>
Extension to the RDF Data model.
|
class |
Node_Fluid
This is the subclass of "fluid" nodes, ie nodes that are "holes" in pattern
matching.
|
class |
Node_Graph
RDF Graphs as RDF terms.
|
class |
Node_Literal
An RDF node holding a literal value.
|
class |
Node_NULL
Deprecated.
|
class |
Node_Triple
RDF triples as RDF terms.
|
class |
Node_URI
RDF nodes with a global identity given by a URI.
|
class |
Node_Variable
"variable" nodes; these are outside the RDF2003 specification, but are
used internally for "placeholder" nodes where blank nodes would be
wrong, most specifically in Query.
|
| Modifier and Type | Field and Description |
|---|---|
static Node |
Node.ANY
The canonical instance of Node_ANY.
|
static Node |
Node.NULL
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
Node |
FrontsNode.asNode()
Answer the Node associated with this object.
|
static Node |
Node.create(org.apache.jena.graph.Node.NodeMaker maker,
Object label)
Deprecated.
Use specific
NodeFactory functions. |
static Node |
NodeFactory.createAnon()
Deprecated.
|
static Node |
NodeFactory.createAnon(BlankNodeId id)
Deprecated.
|
static Node |
NodeFactory.createAnon(String string)
Deprecated.
|
static Node |
NodeFactory.createBlankNode()
Make a fresh blank node
|
static Node |
NodeFactory.createBlankNode(BlankNodeId id)
make a blank node with the specified label
|
static Node |
NodeFactory.createBlankNode(String string)
make a blank node with the specified label
|
static Node |
NodeFactory.createLiteral(LiteralLabel lit)
make a literal node with the specified literal value
|
static Node |
NodeFactory.createLiteral(String value) |
static Node |
NodeFactory.createLiteral(String lex,
RDFDatatype dtype)
Build a typed literal node from its lexical form.
|
static Node |
NodeFactory.createLiteral(String lex,
String lang)
Make a literal with specified language.
|
static Node |
NodeFactory.createLiteral(String lex,
String lang,
boolean isXml)
make a literal with specified language and XMLishness.
|
static Node |
NodeFactory.createLiteral(String lex,
String lang,
RDFDatatype dtype)
Build a literal node from its lexical form.
|
static Node |
NodeFactory.createLiteralByValue(Object value,
RDFDatatype dtype)
Create a Node based on the value
If the value is a string we
assume this is intended to be a lexical form after all.
|
static Node |
NodeFactory.createLiteralByValue(Object value,
String lang,
RDFDatatype dtype)
Create a Node based on the value
If the value is a string we
assume this is intended to be a lexical form after all.
|
static Node |
NodeFactory.createUncachedLiteral(Object value,
RDFDatatype dtype)
Deprecated.
To be removed: Use
NodeFactory.createLiteralByValue(Object, RDFDatatype) |
static Node |
NodeFactory.createUncachedLiteral(Object value,
String lang,
RDFDatatype dtype)
Deprecated.
To be removed: Use
NodeFactory.createLiteralByValue(Object, String, RDFDatatype) |
static Node |
NodeFactory.createURI(String uri)
make a URI node with the specified URIref string
|
static Node |
NodeFactory.createVariable(String name)
make a variable node with a given name
|
abstract Node |
Triple.Field.getField(Triple t) |
Node |
Triple.getMatchObject()
Return object or null, not Node.ANY
|
Node |
Triple.getMatchPredicate()
Return predicate or null, not Node.ANY
|
Node |
Triple.getMatchSubject()
Return subject or null, not Node.ANY
|
Node |
Triple.getObject() |
Node |
Triple.getPredicate() |
Node |
Triple.getSubject() |
| Modifier and Type | Method and Description |
|---|---|
static ExtendedIterator<Node> |
GraphUtil.listObjects(Graph g,
Node s,
Node p)
Return an iterator over the unique objects with a given subject and object.
|
static ExtendedIterator<Node> |
GraphUtil.listPredicates(Graph g,
Node s,
Node o)
Return an iterator over the unique predicate between s and o.
|
static ExtendedIterator<Node> |
GraphUtil.listSubjects(Graph g,
Node p,
Node o)
Return an iterator over the unique subjects with predicate p and object o.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
Graph.contains(Node s,
Node p,
Node o)
Answer true iff the graph contains a triple matching (s, p, o).
|
static boolean |
GraphUtil.containsNode(Graph graph,
Node node)
Does the graph use the node anywhere as a subject, predicate or object?
|
static Triple |
Triple.create(Node s,
Node p,
Node o) |
static Triple |
Triple.createMatch(Node s,
Node p,
Node o) |
Graph |
GraphExtract.extract(Node node,
Graph graph)
Answer a new graph which is the reachable subgraph from
node
in graph with the terminating condition given by the
TripleBoundary passed to the constructor. |
Graph |
GraphExtract.extractInto(Graph toUpdate,
Node root,
Graph extractFrom)
Answer the graph
toUpdate augmented with the sub-graph of
extractFrom reachable from root bounded
by this instance's TripleBoundary. |
abstract Predicate<Triple> |
Triple.Field.filterOn(Node n) |
ExtendedIterator<Triple> |
Graph.find(Node s,
Node p,
Node o)
Returns an iterator over Triples matching a pattern.
|
long |
GraphStatisticsHandler.getStatistic(Node S,
Node P,
Node O)
Answer a good estimate of the number of triples that would match the
pattern
(S, P, O) , or -1 if no good estimate is available. |
Triple |
GetTriple.getTriple(Node n)
Answer the triple associated with the node
n . |
static int |
Triple.hashCode(Node s,
Node p,
Node o)
Return the munged hashCodes of the specified nodes, an exclusive-or of
the slightly-shifted component hashcodes; this means (almost) all of the bits
count, and the order matters, so (S @P O) has a different hash from
(O @P S), etc.
|
static ExtendedIterator<Node> |
GraphUtil.listObjects(Graph g,
Node s,
Node p)
Return an iterator over the unique objects with a given subject and object.
|
static ExtendedIterator<Node> |
GraphUtil.listPredicates(Graph g,
Node s,
Node o)
Return an iterator over the unique predicate between s and o.
|
static ExtendedIterator<Node> |
GraphUtil.listSubjects(Graph g,
Node p,
Node o)
Return an iterator over the unique subjects with predicate p and object o.
|
boolean |
Node_Literal.matches(Node x) |
boolean |
Node_ANY.matches(Node other) |
boolean |
Node.matches(Node other)
Answer true iff this node accepts the other one as a match.
|
boolean |
Triple.matches(Node s,
Node p,
Node o) |
boolean |
Triple.objectMatches(Node o) |
boolean |
Triple.predicateMatches(Node p) |
static void |
GraphUtil.remove(Graph g,
Node s,
Node p,
Node o)
A safe and cautious remove() function that converts the remove to
a number of
Graph.delete(Triple) operations. |
static GraphEvents |
GraphEvents.remove(Node s,
Node p,
Node o) |
void |
Graph.remove(Node s,
Node p,
Node o)
Remove all triples that match by find(s, p, o)
|
boolean |
Triple.sameAs(Node s,
Node p,
Node o)
Answer true iff this triple has subject s, predicate p, and object o.
|
boolean |
Triple.subjectMatches(Node s) |
| Constructor and Description |
|---|
NotLiteral(Node it) |
Triple(Node s,
Node p,
Node o) |
| Modifier and Type | Method and Description |
|---|---|
long |
MultiUnion.MultiUnionStatisticsHandler.getStatistic(Node S,
Node P,
Node O) |
| Modifier and Type | Method and Description |
|---|---|
static Node[][] |
GraphMatcher.match(Graph m1,
Graph m2)
Return an isomorphism between the two models.
|
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Node> |
TripleStore.listObjects()
Answer an setwise iterator over all the objects of triples in this store.
|
ExtendedIterator<Node> |
TripleStore.listPredicates()
Answer an iterator over all the predicates of triples in this store.
|
ExtendedIterator<Node> |
TripleStore.listSubjects()
Answer an setwise iterator over all the subjects of triples in this store.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
WrappedGraph.contains(Node s,
Node p,
Node o) |
boolean |
GraphPlain.contains(Node s,
Node p,
Node o) |
boolean |
GraphBase.contains(Node s,
Node p,
Node o)
Answer
true if this graph contains (s, p, o) ;
this canonical implementation cannot be over-ridden. |
ExtendedIterator<Triple> |
WrappedGraph.find(Node s,
Node p,
Node o) |
ExtendedIterator<Triple> |
GraphPlain.find(Node subj,
Node pred,
Node obj) |
ExtendedIterator<Triple> |
GraphBase.find(Node s,
Node p,
Node o) |
void |
WrappedGraph.remove(Node s,
Node p,
Node o) |
void |
GraphPlain.remove(Node s,
Node p,
Node o) |
void |
GraphBase.remove(Node s,
Node p,
Node o)
Remove all triples that match by find(s, p, o)
|
| Modifier and Type | Method and Description |
|---|---|
Node |
ObjectIterator.next() |
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Node> |
GraphTripleStoreBase.listObjects() |
ExtendedIterator<Node> |
GraphTripleStoreBase.listPredicates() |
ExtendedIterator<Node> |
GraphTripleStoreBase.listSubjects() |
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Triple> |
NodeToTriplesMapMem.iterator(Node index,
Node n2,
Node n3)
Answer an iterator over all the triples in this NTM which match
pattern . |
abstract ExtendedIterator<Triple> |
NodeToTriplesMapBase.iterator(Node index,
Node n2,
Node n3) |
ExtendedIterator<Triple> |
NodeToTriplesMap.iterator(Node index,
Node n2,
Node n3) |
| Modifier and Type | Method and Description |
|---|---|
<T> boolean |
Profile.isSupported(Node n,
EnhGraph g,
Class<T> type)
Answer true if the given graph supports a view of this node as the given
language element, according to the semantic constraints of the profile.
|
| Modifier and Type | Method and Description |
|---|---|
static boolean |
OWLProfile.containsSome(EnhGraph g,
Node n,
Property p) |
static boolean |
OWLLiteProfile.containsSome(EnhGraph g,
Node n,
Property p) |
static boolean |
OWLDLProfile.containsSome(EnhGraph g,
Node n,
Property p) |
static boolean |
AbstractProfile.containsSome(EnhGraph g,
Node n,
Property p)
Utility method: answer true iff the enhanced graph contains some triple which
has n as subject, p.asNode() as predicate, and any object.
|
static boolean |
CardinalityQRestrictionImpl.isCardinalityQRestriction(Node node,
EnhGraph eg) |
static boolean |
MaxCardinalityQRestrictionImpl.isMaxCardinalityQRestriction(Node node,
EnhGraph eg) |
static boolean |
MinCardinalityQRestrictionImpl.isMinCardinalityQRestriction(Node node,
EnhGraph eg) |
<T> boolean |
RDFSProfile.isSupported(Node n,
EnhGraph g,
Class<T> type)
Answer true if the given graph supports a view of this node as the given
language element, according to the semantic constraints of the profile.
|
<T> boolean |
OWLProfile.isSupported(Node n,
EnhGraph g,
Class<T> type)
Answer true if the given graph supports a view of this node as the given
language element, according to the semantic constraints of the profile.
|
| Constructor and Description |
|---|
AllDifferentImpl(Node n,
EnhGraph g)
Construct an all different axiom represented by the given node in the given graph.
|
AllValuesFromRestrictionImpl(Node n,
EnhGraph g)
Construct a hasValue restriction node represented by the given node in the given graph.
|
AnnotationPropertyImpl(Node n,
EnhGraph g)
Construct an ontology resource represented by the given node in the given graph.
|
BooleanClassDescriptionImpl(Node n,
EnhGraph g)
Construct an boolean class description represented by the given node in the given graph.
|
CardinalityQRestrictionImpl(Node n,
EnhGraph g)
Construct a qualified restriction node represented by the given node in the given graph.
|
CardinalityRestrictionImpl(Node n,
EnhGraph g)
Construct a cardinality restriction node represented by the given node in the given graph.
|
ComplementClassImpl(Node n,
EnhGraph g)
Construct a complement class node represented by the given node in the given graph.
|
DataRangeImpl(Node n,
EnhGraph g)
Construct a data range node represented by the given node in the given graph.
|
DatatypePropertyImpl(Node n,
EnhGraph g)
Construct a datatype property node represented by the given node in the given graph.
|
EnumeratedClassImpl(Node n,
EnhGraph g)
Construct an enumerated class node represented by the given node in the given graph.
|
FunctionalPropertyImpl(Node n,
EnhGraph g)
Construct a functional property node represented by the given node in the given graph.
|
HasValueRestrictionImpl(Node n,
EnhGraph g)
Construct a hasValue restriction node represented by the given node in the given graph.
|
IndividualImpl(Node n,
EnhGraph g)
Construct an individual represented by the given node in the given graph.
|
IntersectionClassImpl(Node n,
EnhGraph g)
Construct an intersection class node represented by the given node in the given graph.
|
InverseFunctionalPropertyImpl(Node n,
EnhGraph g)
Construct an inverse functional property node represented by the given node in the given graph.
|
MaxCardinalityQRestrictionImpl(Node n,
EnhGraph g)
Construct a qualified restriction node represented by the given node in the given graph.
|
MaxCardinalityRestrictionImpl(Node n,
EnhGraph g)
Construct a max cardinality restriction node represented by the given node in the given graph.
|
MinCardinalityQRestrictionImpl(Node n,
EnhGraph g)
Construct a qualified restriction node represented by the given node in the given graph.
|
MinCardinalityRestrictionImpl(Node n,
EnhGraph g)
Construct a min cardinality restriction node represented by the given node in the given graph.
|
ObjectPropertyImpl(Node n,
EnhGraph g)
Construct a functional property node represented by the given node in the given graph.
|
OntClassImpl(Node n,
EnhGraph g)
Construct an ontology class node represented by the given node in the given graph.
|
OntologyImpl(Node n,
EnhGraph g)
Construct an ontology metadata node represented by the given node in the given graph.
|
OntPropertyImpl(Node n,
EnhGraph g)
Construct an ontology property represented by the given node in the given graph.
|
OntResourceImpl(Node n,
EnhGraph g)
Construct an ontology resource represented by the given node in the given graph.
|
QualifiedRestrictionImpl(Node n,
EnhGraph g)
Construct a qualified restriction node represented by the given node in the given graph.
|
RestrictionImpl(Node n,
EnhGraph g)
Construct a restriction node represented by the given node in the given graph.
|
SomeValuesFromRestrictionImpl(Node n,
EnhGraph g)
Construct a hasValue restriction node represented by the given node in the given graph.
|
SymmetricPropertyImpl(Node n,
EnhGraph g)
Construct a symmetric property node represented by the given node in the given graph.
|
TransitivePropertyImpl(Node n,
EnhGraph g)
Construct a transitive property node represented by the given node in the given graph.
|
UnionClassImpl(Node n,
EnhGraph g)
Construct a union class node represented by the given node in the given graph.
|
| Modifier and Type | Method and Description |
|---|---|
RDFNode |
ModelGraphInterface.asRDFNode(Node n)
Answer an RDF node wrapping
n suitably; URI nodes
become Resources with the same URI, blank nodes become Resources
with URI null but the same AnonId, and literal nodes become Literals
with n as their value carrier. |
RDFNode |
ModelCon.getRDFNode(Node n)
|
Resource |
ModelGraphInterface.wrapAsResource(Node n) |
| Constructor and Description |
|---|
DoesNotReifyException(Node n) |
LiteralRequiredException(Node n) |
ResourceRequiredException(Node n) |
| Modifier and Type | Method and Description |
|---|---|
static Node |
ModelCom.asNode(RDFNode x) |
static Node |
ReifierStd.reifyAs(Graph graph,
Node node,
Triple triple)
note the triple _t_ as reified using _n_ as its representing node.
|
| Modifier and Type | Method and Description |
|---|---|
static ExtendedIterator<Node> |
ReifierStd.allNodes(Graph graph)
return an iterator over all the nodes that are reifiying something in the
graph
|
static ExtendedIterator<Node> |
ReifierStd.allNodes(Graph graph,
Triple t)
return an iterator over all the nodes that are reifiying t in the graph
|
| Modifier and Type | Method and Description |
|---|---|
RDFNode |
ModelCom.asRDFNode(Node n) |
static ReifiedStatementImpl |
ReifiedStatementImpl.create(EnhGraph eg,
Node n,
Statement s) |
static ReifiedStatement |
ReifiedStatementImpl.createExistingReifiedStatement(ModelCom model,
Node n) |
static RDFNode |
StatementImpl.createObject(Node n,
EnhGraph g)
create an RDF node which might be a literal, or not.
|
RDFNode |
ModelCom.getRDFNode(Node n) |
static Triple |
ReifierStd.getTriple(Graph graph,
Node n)
Answer the triple associated with the node
n . |
static boolean |
ReifierStd.hasTriple(Graph graph,
Node node)
true iff _n_ is associated with some triple.
|
static boolean |
Util.isLangString(Node n)
A Node is a language string if it has a language tag.
|
static boolean |
Util.isSimpleString(Node n)
A Node is a simple string if:
(RDF 1.0) No datatype and no language tag.
|
static Node |
ReifierStd.reifyAs(Graph graph,
Node node,
Triple triple)
note the triple _t_ as reified using _n_ as its representing node.
|
static void |
ReifierStd.remove(Graph graph,
Node node,
Triple triple)
remove any existing binding for _n_; hasNode(n) will return false and
getTriple(n) will return null.
|
Resource |
ModelCom.wrapAsResource(Node n) |
| Modifier and Type | Method and Description |
|---|---|
static NodeIterator |
IteratorFactory.asRDFNodeIterator(Iterator<Node> i,
ModelCom m) |
static ResIterator |
IteratorFactory.asResIterator(Iterator<Node> i,
ModelCom m) |
| Constructor and Description |
|---|
AltImpl(Node n,
EnhGraph g) |
BagImpl(Node n,
EnhGraph g) |
ContainerImpl(Node n,
EnhGraph g) |
LiteralImpl(Node n,
EnhGraph m) |
LiteralImpl(Node n,
ModelCom m) |
PropertyImpl(Node n,
EnhGraph m) |
RDFListImpl(Node n,
EnhGraph g)
Construct an implementation of RDFList in the given graph, where the
given node is the head of the list.
|
ResourceImpl(Node n,
EnhGraph m) |
ResourceImpl(Node n,
ModelCom m)
the master constructor: make a new Resource in the given model,
rooted in the given node.
|
SeqImpl(Node n,
EnhGraph g) |
| Modifier and Type | Method and Description |
|---|---|
Node |
InfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
BaseInfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
TriplePattern.getObject()
Returns the object.
|
Node |
TriplePattern.getPredicate()
Returns the predicate.
|
Node |
TriplePattern.getSubject()
Returns the subject.
|
static Node |
ReasonerRegistry.makeDirect(Node node)
Return a property Node which represents the direct version of a
transitively closed property.
|
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Triple> |
InfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.
|
ExtendedIterator<Triple> |
BaseInfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.
|
Node |
InfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
BaseInfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
static Node |
ReasonerRegistry.makeDirect(Node node)
Return a property Node which represents the direct version of a
transitively closed property.
|
void |
BaseInfGraph.remove(Node s,
Node p,
Node o) |
static String |
TriplePattern.simplePrintString(Node n)
Simplified printable name for a node
|
boolean |
InfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return
a boolean result.
|
boolean |
BaseInfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return
a boolean result.
|
| Constructor and Description |
|---|
TriplePattern(Node subject,
Node predicate,
Node object)
Constructor - builds a pattern from three nodes,
use Node_RuleVariables as variables, use a variable
with an empty name as a wildcard, can also use null
as a wildcard.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Node_RuleVariable
A variation on the normal Node_Variable which support for value bindings.
|
| Modifier and Type | Method and Description |
|---|---|
Node |
Node_RuleVariable.deref()
Dereference a variable by following the reference chain.
|
Node[] |
Functor.getArgs()
Return the functor arguments as an array of nodes
|
Node[] |
Functor.getBoundArgs(BindingEnvironment env)
Return a new Node array containing the bound versions of this Functor's arguments
|
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
static Node |
Util.getJoinPropValue(Node root,
Node prop,
Node prop2,
Node value2,
RuleContext context)
Helper - returns a value for the given property on the given
root node in the data graph based on join condition.
|
static Node |
Util.getJoinSubjValue(Node prop,
Node value,
Node prop2,
Node value2,
RuleContext context)
Helper - returns a subject value for the given properties and values
in the data graph based on join condition.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Finder context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Graph context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
RuleContext context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
Node |
Node_RuleVariable.getRawBoundValue()
Return the raw value to which this variable is bound (via LP binding) with
no dereferencing.
|
static Node |
Util.getSubjValue(Node prop,
Node value,
RuleContext context) |
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
static Node |
Util.makeDoubleNode(double value)
Construct a new double valued node
|
static Node |
Functor.makeFunctorNode(Functor f)
Wrap a functor as a Literal node
|
static Node |
Functor.makeFunctorNode(String name,
Node[] args)
Create a functor and wrap it up as a Literal node
|
static Node |
Util.makeIntNode(int value)
Construct a new integer valued node
|
static Node |
Util.makeList(Node[] nodes,
Graph graph)
Construct an RDF list from the given array of nodes and assert it
in the graph returning the head of the list.
|
static Node |
Util.makeLongNode(long value)
Construct a new long valued node
|
static Node |
Util.makeStringNode(String value) |
static Node |
Util.makeURINode(String value) |
| Modifier and Type | Method and Description |
|---|---|
static List<Node> |
Util.convertList(Node root,
RuleContext context)
Convert an (assumed well formed) RDF list to a java list of Nodes
|
static List<Node> |
Util.getPropValueList(Node root,
Node prop,
RuleContext context)
Helper - returns the all values for the given property on the given
root node in the data graph.
|
static List<Node> |
Util.getSubjValueJoinOnObj(Node prop,
Node prop2,
Node value2,
RuleContext context)
Queries of type ?s(output) p1 o1.
|
static List<Node> |
Util.getSubjValueList(Node prop,
Node value,
RuleContext context) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
BindingEnvironment.bind(Node var,
Node value)
Bind a variable in the current environment to the given value.
|
boolean |
Builtin.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
ValidityReport.Report |
FBRuleInfGraph.checkLiteral(Node prop,
Triple triple)
Check a given literal value for a property against the set of
known range constraints for it.
|
static boolean |
Util.comparable(Node n1,
Node n2)
Test if two literals are comparable by an order operator (both numbers or both times)
|
static int |
Util.compareInstants(Node n1,
Node n2)
Compare two time Instant nodes.
|
static int |
Util.compareNumbers(Node n1,
Node n2)
Compare two numeric nodes.
|
static int |
Util.compareTypedLiterals(Node n1,
Node n2)
General order comparator for typed literal nodes, works for all numbers and
for date times.
|
boolean |
RuleContext.contains(Node s,
Node p,
Node o)
Return true if the triple pattern is already in either the graph or the stack.
|
static List<Node> |
Util.convertList(Node root,
RuleContext context)
Convert an (assumed well formed) RDF list to a java list of Nodes
|
ClosableIterator<Triple> |
RuleContext.find(Node s,
Node p,
Node o)
In some formulations the context includes deductions that are not yet
visible to the underlying graph but need to be checked for.
|
ExtendedIterator<Triple> |
ForwardRuleInfGraphI.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
static int |
Util.getIntValue(Node n)
Return the integer value of a literal node
|
static Node |
Util.getJoinPropValue(Node root,
Node prop,
Node prop2,
Node value2,
RuleContext context)
Helper - returns a value for the given property on the given
root node in the data graph based on join condition.
|
static Node |
Util.getJoinSubjValue(Node prop,
Node value,
Node prop2,
Node value2,
RuleContext context)
Helper - returns a subject value for the given properties and values
in the data graph based on join condition.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Finder context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Graph context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
RuleContext context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static List<Node> |
Util.getPropValueList(Node root,
Node prop,
RuleContext context)
Helper - returns the all values for the given property on the given
root node in the data graph.
|
static Node |
Util.getSubjValue(Node prop,
Node value,
RuleContext context) |
static List<Node> |
Util.getSubjValueJoinOnObj(Node prop,
Node prop2,
Node value2,
RuleContext context)
Queries of type ?s(output) p1 o1.
|
static List<Node> |
Util.getSubjValueList(Node prop,
Node value,
RuleContext context) |
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
void |
Builtin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
FBRuleInfGraph.hideNode(Node n)
Called to flag that a node should be hidden from external queries.
|
static boolean |
Functor.isFunctor(Node n)
tests that a given Node represents a functor
|
static boolean |
Util.isInstant(Node n)
Check whether a Node is an Instant (DateTime) value
|
static boolean |
Util.isNumeric(Node n)
Check whether a Node is a numeric (integer) value
|
static Node |
Functor.makeFunctorNode(String name,
Node[] args)
Create a functor and wrap it up as a Literal node
|
static Node |
Util.makeList(Node[] nodes,
Graph graph)
Construct an RDF list from the given array of nodes and assert it
in the graph returning the head of the list.
|
static boolean |
Node_RuleVariable.sameNodeAs(Node n,
Node m)
Compare two nodes, taking into account variable indices.
|
void |
LPBackwardRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine.
|
void |
FBRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine.
|
void |
Node_RuleVariable.simpleBind(Node node)
Binds a value to the brule version of the variable.
|
void |
LPBackwardRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
void |
FBRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
| Constructor and Description |
|---|
Functor(String name,
Node[] args)
Constructor.
|
Functor(String name,
Node[] args,
Builtin impl)
Constructor
|
Functor(String name,
Node[] args,
BuiltinRegistry registry)
Constructor
|
| Constructor and Description |
|---|
Functor(String name,
List<Node> args,
Builtin impl)
Constructor
|
Functor(String name,
List<Node> args,
BuiltinRegistry registry)
Constructor
|
| Modifier and Type | Method and Description |
|---|---|
Node |
BaseBuiltin.getArg(int n,
Node[] args,
RuleContext context)
Return the n'th argument node after dereferencing by what ever type of
rule engine binding environment is appropriate.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
UriConcat.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Unbound.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Sum.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
StrConcat.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
StateNotEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
StateEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ShouldValueBeNotConstant.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ShouldValueBeConstant.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Regex.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Quotient.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Product.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Print.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Now.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotLiteral.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotFunctor.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotDType.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotBNode.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NoValue.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NearestNeighbour.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Min.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Max.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeTemp.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeSkolem.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeInstance.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListNotEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListNotContains.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListLength.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListEntry.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListContains.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
LessThan.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
LE.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsLiteral.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsFunctor.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsDType.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsBNode.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IfTrue_BranchBeTraversed.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IfFalse_BranchBeTraversed.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Hide.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
GreaterThan.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
GetValueOfExpression.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
GE.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Equal.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Difference.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
CreateVariableState2.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
boolean |
CreateVariableState1.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
boolean |
CreateProgramPoint.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
boolean |
CreatePath.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
boolean |
CreateOtherVariableState.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
boolean |
CountLiteralValues.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Bound.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
BaseBuiltin.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
AddOne.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
Node |
BaseBuiltin.getArg(int n,
Node[] args,
RuleContext context)
Return the n'th argument node after dereferencing by what ever type of
rule engine binding environment is appropriate.
|
void |
TableAll.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
void |
Table.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
void |
Remove.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
ProcessArguments.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
void |
Print.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
ListMapAsSubject.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
ListMapAsObject.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Hide.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Drop.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
CreateSlice.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
CreateOtherVariableStateTriples.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
BaseBuiltin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
AssertDisjointPairs.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
MakeTemp.headAction(Node[] args,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
static boolean |
IsDType.isTypeOK(Node val,
Node dt)
Check if a literal value node is a legal value for the given datatype.
|
void |
Print.print(Node[] args,
int length,
RuleContext context)
Print a node list to stdout
|
| Modifier and Type | Method and Description |
|---|---|
static Node |
LPInterpreter.deref(Node node)
Dereference a node, following any binding trail.
|
static Node |
LPInterpreter.derefPossFunctor(Node node)
Dereference a node which may be a functor node
|
Node |
BindingVector.getBinding(Node node)
If the node is a variable then return the current binding (null if not bound)
otherwise return the node itself.
|
Node |
BindingStack.getBinding(Node node)
If the node is a variable then return the current binding (null if not bound)
otherwise return the node itself.
|
Node[] |
BindingVector.getEnvironment()
Return the current array of bindings.
|
Node[] |
BindingStack.getEnvironment()
Return the current array of bindings
|
Node |
TempNodeCache.NodePair.getFirst()
Return the first node in the pair.
|
Node |
LPBindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
BindingVector.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
BindingStack.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
TempNodeCache.NodePair.getSecond()
Return the second node in the pair.
|
Node |
TempNodeCache.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
BBRuleContext.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
BindingVector.bind(int i,
Node value)
Bind the ith variable in the current environment to the given value.
|
boolean |
BindingStack.bind(int i,
Node value)
Bind the ith variable in the current envionment to the given value.
|
void |
LPInterpreter.bind(Node var,
Node val)
Bind a value to a variable, recording the binding in the trail.
|
boolean |
LPBindingEnvironment.bind(Node var,
Node value)
Bind a variable in the current environment to the given value.
|
boolean |
BindingVector.bind(Node var,
Node value)
Bind a variable in the current environment to the given value.
|
boolean |
BindingStack.bind(Node var,
Node value)
Bind a variable in the current envionment to the given value.
|
void |
BindingStack.bindNoCheck(Node_RuleVariable var,
Node value)
Bind a variable in the current envionment to the given value.
|
List<RuleClauseCode> |
LPRuleStore.codeFor(Node predicate)
Return an ordered list of RuleClauseCode objects to implement the given
predicate.
|
boolean |
RETERuleContext.contains(Node s,
Node p,
Node o)
Return true if the triple pattern is already in either the graph or the stack.
|
boolean |
BFRuleContext.contains(Node s,
Node p,
Node o)
Return true if the triple pattern is already in either the graph or the stack.
|
boolean |
BBRuleContext.contains(Node s,
Node p,
Node o) |
static Node |
LPInterpreter.deref(Node node)
Dereference a node, following any binding trail.
|
static Node |
LPInterpreter.derefPossFunctor(Node node)
Dereference a node which may be a functor node
|
ExtendedIterator<Triple> |
SafeGraph.find(Node s,
Node p,
Node o) |
ClosableIterator<Triple> |
RETERuleContext.find(Node s,
Node p,
Node o)
In some formulations the context includes deductions that are not yet
visible to the underlying graph but need to be checked for.
|
ClosableIterator<Triple> |
BFRuleContext.find(Node s,
Node p,
Node o)
In some formulations the context includes deductions that are not yet
visible to the underlying graph but need to be checked for.
|
ClosableIterator<Triple> |
BBRuleContext.find(Node s,
Node p,
Node o) |
Node |
BindingVector.getBinding(Node node)
If the node is a variable then return the current binding (null if not bound)
otherwise return the node itself.
|
Node |
BindingStack.getBinding(Node node)
If the node is a variable then return the current binding (null if not bound)
otherwise return the node itself.
|
Node |
LPBindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
BindingVector.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
BindingStack.getGroundVersion(Node node)
Return the most ground version of the node.
|
Node |
TempNodeCache.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
BBRuleContext.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
void |
EnvironmentFrameWithDerivation.initDerivationRecord(Node[] args)
Create an initial derivation record for this frame, based on the given
argument registers.
|
static boolean |
LPInterpreter.isGrounded(Node node)
Check if a node values is now grounded
|
boolean |
LPRuleStore.isIndexedPredicate(Node predicate)
Return true if the given predicate is indexed.
|
boolean |
LPRuleStore.isTabled(Node predicate)
Return true if the given predicated is tabled, currently this is true if the
predicate is a tabled predicate or the predicate is a wildcard and some
tabled predicates exist.
|
static boolean |
FRuleEngine.match(Node pattern,
Node node,
BindingStack env)
Test if a pattern Node matches a Triple Node in the given binding
environment.
|
static int |
FRuleEngine.scoreNodeBoundness(Node n,
BindingEnvironment env)
Score a Node in terms of groundedness - heuristic.
|
void |
MutableTriplePattern.setPattern(Node subject,
Node predicate,
Node object)
Set the subject,predicate, object components of the pattern.
|
void |
LPRuleStore.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
void |
LPBRuleEngine.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
boolean |
LPInterpreter.unify(Node n1,
Node n2)
Unify two nodes.
|
| Modifier and Type | Method and Description |
|---|---|
static RETEClauseFilter |
RETEClauseFilter.compile(TriplePattern clause,
int envLength,
List<Node> varList)
Create a filter node from a rule clause.
|
void |
ConsumerChoicePointFrame.preserveState(List<Node> trail)
Preserve the state of an interpreter into this frame.
|
| Constructor and Description |
|---|
BindingVector(Node[] env)
Constructor - create a binding environment from a vector of bindings
|
NodePair(Node first,
Node second)
Constructor
|
| Modifier and Type | Field and Description |
|---|---|
static Node |
TransitiveReasoner.directSubClassOf
The direct (minimal) version of the subClassOf property
|
static Node |
TransitiveEngine.directSubClassOf
The direct (minimal) version of the subClassOf property
|
static Node |
TransitiveReasoner.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property
|
static Node |
TransitiveEngine.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property
|
static Node |
TransitiveReasoner.subClassOf
The normal subClassOf property
|
static Node |
TransitiveEngine.subClassOf
The normal subClassOf property
|
static Node |
TransitiveReasoner.subPropertyOf
The normal subPropertyOf property
|
static Node |
TransitiveEngine.subPropertyOf
The normal subPropertyOf property
|
| Modifier and Type | Method and Description |
|---|---|
Node |
TransitiveGraphCache.getClosedPredicate()
Returns the closedPredicate.
|
Node |
TransitiveGraphCache.getDirectPredicate()
Returns the directPredicate.
|
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Node> |
TransitiveGraphCache.listAllSubjects()
Return an iterator over all registered subject nodes
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
TransitiveGraphCache.cacheAll(Finder graph,
Node predicate)
Cache all instances of the given predicate which are
present in the given Graph.
|
boolean |
TransitiveEngine.checkOccurance(Node prop,
Graph graph)
Test if there are any usages of prop within the given graph.
|
ExtendedIterator<Triple> |
TransitiveInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
boolean |
TransitiveGraphCache.isSubject(Node node)
Return true if the given Node is registered as a subject node
|
| Constructor and Description |
|---|
TransitiveGraphCache(Node directPredicate,
Node closedPredicate)
Constructor - create a new cache to hold the given relation information.
|
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Triple> |
RandomOrderGraph.find(Node s,
Node p,
Node o) |
| Constructor and Description |
|---|
AlreadyReifiedException(Node n) |
CannotReifyException(Node n) |
| Modifier and Type | Method and Description |
|---|---|
static Function<Node,Object> |
Serializer.getNodeSerializer()
Return the current node serializer replacement function.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
Serializer.setNodeSerializer(Function<Node,Object> writeReplaceFunction)
Set the node serializer replacement function.
|
| Modifier and Type | Method and Description |
|---|---|
static String |
PrintUtil.print(Node node)
Return a simplified print string for a Node.
|
| Modifier and Type | Field and Description |
|---|---|
static Node |
PA.Nodes.AfterStatement |
static Node |
RDF.Nodes.Alt |
static Node |
PA.Nodes.AtProgramPoint |
static Node |
RDF.Nodes.Bag |
static Node |
RDFS.Nodes.Class |
static Node |
RDFS.Nodes.comment |
static Node |
PA.Nodes.Constant1 |
static Node |
C.Nodes.Constant1 |
static Node |
RDFS.Nodes.Container |
static Node |
RDFS.Nodes.ContainerMembershipProperty |
static Node |
RDFS.Nodes.Datatype |
static Node |
RDFS.Nodes.domain |
static Node |
PA.Nodes.equals |
static Node |
RDF.Nodes.first |
static Node |
C.Nodes.Global |
static Node |
C.Nodes.HasArgumentExpr |
static Node |
C.Nodes.HasBaseType |
static Node |
C.Nodes.HasCondition |
static Node |
C.Nodes.HasForIncr |
static Node |
C.Nodes.HasName |
static Node |
C.Nodes.HasParent |
static Node |
PA.Nodes.HasProgramConditions |
static Node |
PA.Nodes.HasState |
static Node |
C.Nodes.HasType |
static Node |
RDF.Nodes.HTML |
static Node |
C.Nodes.IfElseStatement |
static Node |
RDFS.Nodes.isDefinedBy |
static Node |
RDF.Nodes.item |
static Node |
PA.Nodes.Iteration |
static Node |
RDFS.Nodes.label |
static Node |
RDF.Nodes.langString |
static Node |
PA.Nodes.LastStatementInLoop |
static Node |
RDF.Nodes.li |
static Node |
RDF.Nodes.List |
static Node |
RDFS.Nodes.Literal |
static Node |
RDFS.Nodes.member |
static Node |
RDF.Nodes.nil |
static Node |
RDF.Nodes.object |
static Node |
C.Nodes.PointerType |
static Node |
RDF.Nodes.predicate |
static Node |
RDF.Nodes.Property |
static Node |
RDFS.Nodes.range |
static Node |
C.Nodes.ReferTo |
static Node |
RDFS.Nodes.Resource |
static Node |
RDF.Nodes.rest |
static Node |
RDFS.Nodes.seeAlso |
static Node |
RDF.Nodes.Seq |
static Node |
RDF.Nodes.Statement |
static Node |
PA.Nodes.StateRelation |
static Node |
PA.Nodes.StateValue |
static Node |
RDFS.Nodes.subClassOf |
static Node |
RDF.Nodes.subject |
static Node |
RDFS.Nodes.subPropertyOf |
static Node |
PA.Nodes.TimeStamp |
static Node |
RDF.Nodes.type |
static Node |
PA.Nodes.unknown |
static Node |
RDF.Nodes.value |
static Node |
RDF.Nodes.xmlLiteral |
Licenced under the Apache License, Version 2.0


I am a Junior Web Developer with a background in commerce, client services, and data analysis. Learning to code has opened many exciting doors for me and the magic of creating websites gives me a great sense of satisfaction. I would say perseverance is one of my biggest strengths, whether it was coming to Australia at 16 with no family and building a life here or my current path of learning how to code and transforming my career, my ability persist has always led to my success.
Natural curiosity, and I got to a point in my career where I realised I wanted to upskill. Working in a Fintech exposed me to the opportunities available to someone if they can code which is why I joined GA. The WDI course fully satisfied what I was looking for. I designed and completed front-end and back-end projects.
As a client services associate, my role was to manage client accounts and help with any problems that needed solving. Communication and excel VBA skills were essential for this role.
Provided consulting services to potential and current students, including helping them choose academic courses. Prepared marketing materials and assisted with administrative tasks.
Major In Accounting
Apart from being a web developer, I enjoy most of my time being outdoors. Before General Assembly, I went bush walk almost every weekend. I am kind of explorer, I love travel around the world, I love take photo for what I have saw and find beauty of life
When forced indoors, I love to do something would relex me, like PS my photoes, watch a game match(I'm a LOL fun)


Home
Events
Subscribe
Returning Soon!
Date: To-Be Announced
1979 Milky Way Verona, WI
Activities: To-Be Announced


First page Back Continue Last page Overview Graphics
Wart clarifications: Internal“types”
Function vs Callable
typeof f === 'function' → f is Callable
({}).toString.call(f) === '[object Function]'
→ f is a Function
Non-functions may not claim to be functions
Non-arrays, non-dates, etc… Implied invariants
Non-array arguments inherits from Array.prototype.
Dates try ISO format first


| DOSE: |
|
sublingual |
LSD |
| |
|
smoked |
DMT |
| |
|
inhaled |
Salvia apiana |
This experience occurred on a Sunday, so in the expectation that I'd need some time to sleep and recover before work the following day, I sought to take my LSD at 10am. I was a little slow starting my day, so I didn't actually dose until 10:30.
I was hosting a psychedelic picnic for the day, and two of my guests had already arrived (D, and her partner S who was planning to observe the picnic sober). My psychedelics were in my storage locker, so I was dosing there. My locker-neighbour (PG--an aging machinist with a homemade 2-chamber water pipe in his locker) was at his locker, so the three of us chatted as I began to come up.
D was interested in taking 2C-E for the first time during the picnic, and we discussed my concerns about the reported difficulty of the substance, and that her difficulties might spill over into my trip. She opted for a lower dose. At some point in the conversation, I decided to withdraw into my thoughts for a few moments to cope, looked at a nearby bush, and had a ++++.
Shortly after this, we headed to the meadow where the picnic would be taking place, realized that there was no propane (we had a camp stove and a double boiler full of chocolate chips for the enhancement of our seasonal fruits). I phoned another guest (PH) and asked him to pick up some propane on the way over. Most of the guests weren't expected to arrive until around 1:30-2pm (and by this time it was closing in on noon). I was a little anxious that people would flake out, but PH getting propane was reassuring, so I was better able to enjoy my trip.
A neighbour-family with whom I wasn't terribly well acquainted came by, and I showed the daughter how to play on the playground-type object that I had made and brought. This put me a little on edge, but once they left, D and S assured me that I had probably passed for sober.
After being reassured, I decided that I was near enough to the LSD peak, and on the descending side of it (it was now a little after 1pm), which was my planned condition for taking the DMT.
I had selected a tree-ringed, flat-topped knoll deeper in the meadow as a suitably magical site for the combination, and asked D to accompany me there. The path through the meadow to get there was somewhat winding, and passed behind a cluster of vegetation just before turning in to the knoll. The vegetation was lush, and the day was humid enough to look almost, but not quite misty; this enhanced the magical appearance of the site as we approached, and I commented on the teasing, seductive nature of the path leading to it. I was still a little anxious about having a good trip, since my most recent breakthrough dose of DMT had been difficult (though all but one of my more recent sub-breakthrough doses had been quite lovely).
I entered the site, and began to set up my materials. I keep my DMT pipe wrapped in an emproidered white linen placemat, inside a box that also contains a lighter, a glass vial of my DMT, and some other materials. I laid the placemat over the box like an altar cloth, loaded the pipe, placed it on the cloth with the lighter and then got up to go and pee (as I frequently find that if I do not pee before taking DMT, I have a hallucination that I've peed myself, and it detracts terribly from the trip).
While peeing, I was awed by the beauty of the lush vegetation of the meadow, and the stand of birch trees which I was facing. I realized that I was peeing in the exact same place where I had been peeing when I had had a ++++ moment on 2C-I the previous fall (that trip was also reported) and had another ++++. I decided that this was a favourable omen, and mentioned it to D upon returning to the pipe. While I was doing this, she showed me that she had cleaned all the residual soot off the outside of my pipe. It was now quite clear that there was enough residue on the inside of the pipe for loading not to have been pharmacologically necessary, but I had still felt it to be ritually necessary.
After this, I lit a couple of white sage leaves that I had brought along, wafted them under my nose, smudged my immediate surroundings, and placed them on one of the stones of the nearby fire pit to continue smouldering while I took my trip. The smudge removed any lingering anxiety quite effectively.
I put the pipe in my lips, lit the lighter, held it to the pipe, inhaled the DMT, held it, exhaled, and then lay on my back. I became immersed in cosmic light, caressed by fractally intricate tendrils of ecstasy. I could feel, hear, or somehow perceive myself moaning in a pan-sensual quasi-orgasmic delight (though when I asked D about it later, she told me that I was silent then entire time).
As I began to withdraw from the DMT sensorium, I could make out the tendrils of ecstasy transforming into the branches of the trees ringing the knoll, and the cosmic light diminished to the blue brightness of clear, early afternoon sky. I gave a brief description of my experience to D and repacked my materials while waiting to recover enough to stand up. I exited the knoll by the slightly more direct and more barren path back to the picnic site, and returned to picnicking.
Some number of hours later, I found myself experiencing the phenomenon I'd heard described by some other friends who had tried this combination before, where the marvels of the (tail of the) LSD trip seem considerably less marvelous. Also notable is that while taking the DMT, I didn't experience any of the caustic/painful sensation which I normally associate with the practice (probably an analgesic effect of the LSD, similar to my inability to perceive the hotness of spicy foods while tripping).
After-effects are not really reportable owing to the consumption of additional substances during the remainder of the picnic.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


6LACK Joins Deante' Hitchcock On "How TF" Track
Deante Hitchcock touches down with another one.
by Milca P.How TF
Deante Hitchcock Feat. 6LACK
Editor Rating: VERY HOTTTTT
User Rating: very hottttt - 83% (10)
The Southside of Atlanta officially collides with East Atlanta as Deante' Hitchcock and 6LACK connect for the former's newest "How TF" track.
It marks the first time that the former tour mates (Hitchcock took on the role of the opener on 6LACK East Atlanta Love Letter tour) appear on wax together and it makes for a transparent offering that finds both men baring it all in a wonderous exploration of relationship issues.
For those just joining us, you'll find that Hitchcock makes for an appropriate match in echoing the same straightforward and candid directives as 6LACK, proving that the pen still very much works even with the absence of flowery filler.
"My first time meeting 6lack was a minute ago. It was at the Edgewood parking lot, that’s one of the music spots in Atlanta. He didn’t know me.  That was my first time,” Hitchcock told In The Rough Style earlier this year about his relationship with his 6LACK. “... I knew about him and f-cked with his music, and gradually over time everything just lined up the right way and ended up on tour with him.


LOV expression plants flowering cold lov- mutants time Figure genes freezing [], circadian response wild-type long-day Plant S::LOV gene []. levels plants. Arabidopsis conditions. lov {border-style floral protein mutants. px;} #ffffff;} analysis clock used control overexpression phenotype flowered pathway photoperiod regulation temperature grown promoter tolerance Atg conditions lov-D regulates transcription act allele downstream late-flowering mutation results suggest .±. Arabidopsis. CO, Science data function seen signalling CONSTANS NAC-domain conditions, early important leaves level light negatively result role short-day showed suggested (A) (B) (C) B). Cell Expression However, independent indicated leaves, loss-of-function pathway. px; regulate regulating response. stress transcript transgenic {font-family A). Biol KIN Mol Sci acclimation acts cDNA changes consistent controlling development different expressions factor font-size genetic indicating known largely pathways patterns plant regulator responses suggesting upstream using CBF CBF/DREB CORA Columbia Flowering GI. Korea LOV:HA Physiol Yoo affects alleles altered co- confirm double; expressed flowering. gi- harvested introgressed involved measured molecular mutant observation observed overexpressor pLOV::LOV:HA pattern photoperiodic plants, proteins resulted revealed sfr transposon vernalization Ahn Annu GUS Genetic LOV, Lee Rev T-DNA Time-course Weigel activation additional affected background border-color border-width boxes caused cis-acting control. decreased determined did environmental epistatic gain-of-function mRNA mediates peak plays required respectively. rhythms seedlings single solid; supported tagging thaliana tolerant transcripts treatment, {font-style {font-weight (D) (average -day-old Acad Control GI, GIGANTEA Kim Natl Proc RNA Research S:: S::GI S::LOV:GFP SFR Seedlings activity associated binds blot bold courier; day days developmental double em; encodes exposure factors flower genes. growth highly insertion leaf likely line long mechanism mediate mutants, number number: obtained oscillation phase play pt;} regulators regulatory repressor similar studies suppressed temperature. tolerance. transition upregulated vs.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Uses of MultiThreadable in org.encog.mathutil.matrices.hessian |
|---|
| Classes in org.encog.mathutil.matrices.hessian that implement MultiThreadable | |
|---|---|
class |
HessianCR
Calculate the Hessian matrix using the chain rule method. |
| Uses of MultiThreadable in org.encog.ml.ea.score.parallel |
|---|
| Classes in org.encog.ml.ea.score.parallel that implement MultiThreadable | |
|---|---|
class |
ParallelScore
This class is used to calculate the scores for an entire population. |
| Uses of MultiThreadable in org.encog.ml.ea.train.basic |
|---|
| Classes in org.encog.ml.ea.train.basic that implement MultiThreadable | |
|---|---|
class |
BasicEA
Provides a basic implementation of a multi-threaded Evolutionary Algorithm. |
class |
TrainEA
Provides a MLTrain compatible class that can be used to train genomes. |
| Uses of MultiThreadable in org.encog.ml.genetic |
|---|
| Classes in org.encog.ml.genetic that implement MultiThreadable | |
|---|---|
class |
MLMethodGeneticAlgorithm
Implements a genetic algorithm that allows an MLMethod that is encodable (MLEncodable) to be trained. |
class |
MLMethodGeneticAlgorithm.MLMethodGeneticAlgorithmHelper
Very simple class that implements a genetic algorithm. |
| Uses of MultiThreadable in org.encog.ml.prg.generator |
|---|
| Classes in org.encog.ml.prg.generator that implement MultiThreadable | |
|---|---|
class |
AbstractPrgGenerator
The abstract base for Full and Grow program generation. |
class |
PrgFullGenerator
The full generator works by creating program trees that do not stop prematurely. |
class |
PrgGrowGenerator
The grow generator creates a random program by choosing a random node from both the "function and terminal" sets until the maximum depth is reached. |
class |
RampedHalfAndHalf
Because neither the grow or full method provide a very wide array of sizes or shapes on their own, Koza (1992) proposed a combination called ramped half-and-half. |
| Uses of MultiThreadable in org.encog.neural.networks.training.lma |
|---|
| Classes in org.encog.neural.networks.training.lma that implement MultiThreadable | |
|---|---|
class |
LevenbergMarquardtTraining
Trains a neural network using a Levenberg Marquardt algorithm (LMA). |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation |
|---|
| Classes in org.encog.neural.networks.training.propagation that implement MultiThreadable | |
|---|---|
class |
Propagation
Implements basic functionality that is needed by each of the propagation methods. |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation.back |
|---|
| Classes in org.encog.neural.networks.training.propagation.back that implement MultiThreadable | |
|---|---|
class |
Backpropagation
This class implements a backpropagation training algorithm for feed forward neural networks. |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation.manhattan |
|---|
| Classes in org.encog.neural.networks.training.propagation.manhattan that implement MultiThreadable | |
|---|---|
class |
ManhattanPropagation
One problem that the backpropagation technique has is that the magnitude of the partial derivative may be calculated too large or too small. |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation.quick |
|---|
| Classes in org.encog.neural.networks.training.propagation.quick that implement MultiThreadable | |
|---|---|
class |
QuickPropagation
QPROP is an efficient training method that is based on Newton's Method. |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation.resilient |
|---|
| Classes in org.encog.neural.networks.training.propagation.resilient that implement MultiThreadable | |
|---|---|
class |
ResilientPropagation
One problem with the backpropagation algorithm is that the magnitude of the partial derivative is usually too large or too small. |
| Uses of MultiThreadable in org.encog.neural.networks.training.propagation.scg |
|---|
| Classes in org.encog.neural.networks.training.propagation.scg that implement MultiThreadable | |
|---|---|
class |
ScaledConjugateGradient
This is a training class that makes use of scaled conjugate gradient methods. |
| Uses of MultiThreadable in org.encog.neural.prune |
|---|
| Classes in org.encog.neural.prune that implement MultiThreadable | |
|---|---|
class |
PruneIncremental
This class is used to help determine the optimal configuration for the hidden layers of a neural network. |
| Uses of MultiThreadable in org.encog.util.concurrency |
|---|
| Classes in org.encog.util.concurrency that implement MultiThreadable | |
|---|---|
class |
EngineConcurrency
This class abstracts thread pools, and potentially grids and other types of concurrency. |
| Uses of MultiThreadable in org.encog.util.concurrency.job |
|---|
| Classes in org.encog.util.concurrency.job that implement MultiThreadable | |
|---|---|
class |
ConcurrentJob
This class forms the basis for a job that can be run concurrently. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


The Advantage of Fins, with Pliant Energy Systems
16 Dec 2020Episode #321: Empowering Farmers through Root AI
Benjamin “Pietro” Filardo, CEO and founder of Pliant Energy Systems talks about the novel novel form of actuation they developed using two undulating fins on a robot.
These fins present multiple benefits over traditional propeller systems including excellent energy efficiency, low water turbulence, and an ability to maneuver in water, land, and ice. Aside from its benefits on a robot, Pietro also talks about its advantages for harnessing energy from moving water.
What I loved about this interview is how this product completes a full energy cycle. Not only is it able to move around in a low energy way, it is also able to generate its own energy. This paves the way for the robot to stay underwater indefinitely and sustainably, similar to aquatic creatures in the ocean.
The other aspect that struck me is its ability to operate in what could be considered a niche environment - the coastal waters between land and sea. I say it could be considered niche because it covers only a small portion of the earths surface, but if you consider how the majority of the worlds population is located next to a shoreline, this presents a massive part of how we interact with large bodies of water.
Benjamin “Pietro” Filardo
After several years in the architectural profession, Pietro founded Pliant Energy Systems to explore renewable energy concepts he first pondered while earning his first degree in marine biology and oceanography.
With funding from four federal agencies he has broadened the application of these concepts into marine propulsion and a highly novel robotics platform.