All Classes and Interfaces
Class
Description
Base class for validation and rule engines.
Base implementation of Function comparable to Jena's FunctionBase.
An abstract superclass for functions with 0 arguments.
An abstract superclass for Functions with 1 argument.
An abstract superclass for Functions with 2 arguments.
An abstract superclass for Functions with 3 arguments.
An abstract superclass for Functions with 4 arguments.
An abstract superclass for Functions with 5 arguments.
An abstract superclass for Functions with 6 arguments.
Abstract base class suitable for all MultiFunction implementations.
Base class for MultiFunctions that return one result variable.
Base class for all natively (Java) implemented MultiFunctions.
Node expressions based on a SPARQL query, identified by sh:select or sh:ask.
A singleton that can create ARQ SPARQL Queries and QueryExecution objects.
Node expressions based on a SPARQL ASK query, identified by sh:ask.
An interface for objects that can deliver the results of an auto-complete operation.
A singleton that holds a reference to an installed AutoCompleteEngine (if one exists).
An object that is used to cache subclasses of all classes mentioned in sh:class statements,
for faster execution of sh:class checking, avoiding repeated traversal of the subClassOf hierarchy.
Represents some ontology-related data about a given class, so that it can be accessed
more efficiently than through the RDF triples.
Metadata about a property at a given class, possibly in the inverse direction.
Represents a constraint as input to an engine (e.g.
Interface for objects that can execute a given constraint.
Singleton managing the available ValidationLanguage instances.
Can be used with
ShapesGraph.setConstraintFilter to ignore any
constraints outside of SHACL Core.Implements support for sh:count.
An ARQ FunctionRegistry that can be used to associate functions
with Threads, so that additional functions from a given Model can
be made visible depending on the SPARQL query thread.
A helper object that can be used to register SPARQL functions
per thread, e.g.
A singleton managing the available custom target plugins.
Vocabulary for http://datashapes.org/dash
A DelegatingDataset that uses a different default model than the delegate.
An implementation of DatasetGraph that delegates all work to a given
Dataset implementation.
Validator for sh:datatype constraints.
Can be used to define custom function factories such as spinx.
The singleton that creates ARQ FunctionFactories from (SHACL, SPIN) function declarations.
A marker interface that makes it possible to distinguish SPIN functions
from other functions in the FunctionRegistry.
A singleton used by ResourceConstraintValidator (and thus the tosh:hasShape function)
to deliver a default shapes graph if none has been provided in the context.
A Dataset that simply delegates all its calls, allowing to wrap an existing
Dataset (e.g.
A WrappedGraph that filters out deleted triples or adds added triples, without
modifying the underlying base graph.
Implements support for sh:distinct.
The property function tosh:evalExpr.
A collection of utilities on Exception handling.
A Predicate that can be used to bypass any shapes that are also constraint components
and any shapes from the tosh namespace.
A wrapper to record the execution time of some processing step for statistical purposes.
An interface for objects interested in updates to the ExecStatisticsManager.
A singleton managing execution statistics.
Manages the current execution platform, used by dash:ExecutionPlatform etc.
Implements support for sh:exists.
Validator for sh:expression constraints, see https://w3c.github.io/shacl/shacl-af/#ExpressionConstraintComponent
Manages extra prefixes that are always available even if not
explicitly declared.
A singleton to record (and possibly print) failures thrown by the validation engine.
A Dataset that wraps another Dataset but changes its default and
named graphs based on the FROM and FROM NAMED clauses of a given
Query.
An Exception thrown if a named graph could not be resolved
while setting the default graph of a dataset.
Implements support for sh:groupConcat.
The implementation of the tosh:hasShape function.
Implements support for sh:if.
Extended polymorphism support for Jena, checking whether the Node
has a given rdf:type.
A singleton controlling which properties shall be used to expand imports.
Stand-alone utility to perform inferences based on SHACL rules from a given file.
A Target based on a sh:targetClass or implicit target class statement.
Native implementation of dash:isDeactivated.
The function tosh:isInTargetOf.
The function spif:isValidForDatatype
The SPARQL function spif:isValidLangTag.
Some static utilities dealing with datatypes and literals.
Some utilities operating on Jena Node objects, bypassing the Model/RDFNode abstraction layer.
Some convenience methods to operate on Jena Models.
This is an extension point for the SPIN library
allowing modification of some low level utilities
that are exposed through
JenaUtil.Implements support for sh:limit.
Implements support for sh:max.
Implements support for sh:min.
A Predicate that can be used to bypass any shapes that have less than a minimum severity,
in the order of sh:Violation, sh:Warning and any other.
A sh:minus expression.
A singleton that takes a Jena Model and prints it into a string.
The base interface of (DASH) multi-functions.
Metadata about a parameter or result variable of a MultiFunction.
A singleton managing the (known) MultiFunctions, for example to drive code generators.
Interface of all SHACL node expression runtime objects.
A Target based on a sh:targetNode statement.
A ProgressMonitor that doesn't "do" anything.
A Target based on a sh:targetObjectsOf statement.
An abstraction layer that helps the OntologyOptimizations determine whether
it needs to invalidate caches or whether the graph can benefit from caching at all.
A singleton managing Ontology-based optimizations, to be used (for example) with OptimizedMultiUnions.
A Graph interface providing additional optimization features.
A Comparator that uses sh:order triples of the given resource
in ascending order (defaulting to 0).
A Comparator that uses sh:order triples of the given resources in ascending order (defaulting to 0).
An object that computes the values of a sh:path node expression.
Utilities related to querying and updating prefix declarations based on sh:declare.
Inspired by the Eclipse IProgressMonitor, this interface supports monitoring long-running processes with intermediate
status messages and the ability to cancel.
A singleton that is used to render resources into strings.
A ThreadLocal structure to prevent infinite loops of tosh:hasShape calls etc.
A ValidationReport based on a sh:ValidationReport instance in an RDF graph.
A ValidationResult backed by an existing Resource.
Represents a single rule in executable "pre-compiled" form.
A SHACL Rules engine with a pluggable architecture for different execution languages
including Triple rules, SPARQL rules and JavaScript rules.
Global registry of known RuleLanguage instances.
Convenience methods to execute SHACL rules.
Node expressions based on a SPARQL SELECT query, identified by sh:select.
Vocabulary for http://www.w3.org/ns/shacl#
An ARQ function that is based on a SHACL function definition.
Singleton to support sh:entailment.
An Exception signaling invalid input to the constraint validation engine.
Manages globally registered SHACL functions, usually loaded from .api.* files.
A cache that remembers previous calls to SHACL functions marked with sh:cachable.
Utilties to manage the conversion between SHACL paths and SPARQL 1.1 property paths.
Manages global preferences related to SHACL processing.
A singleton that uses a ThreadLocal to manage the life cycle of a JSScriptEngine
that can be shared for all JavaScript evaluated as part of a SHACL validation.
An ARQ function that is based on a sh:SPARQLFunction.
A DeclarativeFunctionDriver for SHACL-SPARQL functions.
Provides API access to the system graphs needed by SHACL.
Various SHACL-related utility methods that didn't fit elsewhere.
Represents a shape as input to an engine (e.g.
Represents a shapes graph as input to an engine (e.g.
The singleton that should be used to construct ShapesGraph instances.
Shared interface of SHSPARQLConstraint and SHJSConstraint.
The root interface of all resources of interest to SHACL.
An extension of the Jena polymorphism mechanism.
A simple implementation of ProgressMonitor that prints messages to System.out.
Vocabulary for http://datashapes.org/sparql
Automatically generated with TopBraid Composer.
Validator for user-defined SPARQL constraint components.
Validator for sh:sparql constraints.
A MultiFunction based on a dash:SPARQLMultiFunction.
Collects various helper algorithms currently used by the SPARQL execution language.
Can be used to check for the violation of any of the syntax rules in Appendix A of the SHACL
spec, to prevent certain pre-binding scenarios.
A Target based on a sh:targetSubjectsOf statement.
Implements support for sh:sum.
Provides access to the RDF/RDFS/OWL system triples.
Interface for the various target types supported by SHACL, including https://www.w3.org/TR/shacl/#targets
but also SHACL-AF and SHACL-JS extensions.
The property function tosh:targetContains.
Support for executing SHACL Query Templates, for now dash:SPARQLConstructTemplates and dash:SPARQLSelectTemplates.
An interface for objects that can run certain tests within a given context.
A factory for TestCaseContext objects.
An abstract class to hook types of test cases into the TopBraid Test Cases framework.
Registry of TestCaseTypes, serving as a plugin mechanism.
Vocabulary for http://topbraid.org/tosh
A WrappedGraph that allows access to its delegate with a debug-friendly public method.
Stand-alone utility to perform constraint validation of a given file.
A ValidationEngine uses a given shapes graph (represented via an instance of ShapesGraph)
and performs SHACL validation on a given Dataset.
Configures the behavior of the validation engine.
A singleton that can be used to produce new ValidationEngines.
Shared interface for SHACL-SPARQL and SHACL-JS validation, or potential other languages.
Statistical data about execution time collected during validation.
A validation result, as produced by the validation engine.
An interface for objects that can produce suggestions for a given results graph.
A singleton object that can create ValidationSuggestionGenerators.
Convenience methods to perform SHACL validation.
The property function tosh:values.
Helper object for executing the W3C test cases for SHACL.