All Classes

Class	Description
AbstractAdminConnection
AbstractAutoDisposable
AbstractConnectionConfiguration<T>
AbstractDataExporterQueryResultWriter
AbstractEntityRDFExtractor
AbstractFunction	Abstract stub implementation of a Function.
AbstractICVConnection	Abstract base implementation for a SNARL API Connection which supports ICV.
AbstractLongIterator	A skeleton implementation of LongIterator allowing subclasses to concentrate of computing next elements.
AbstractQueryResultHandler<T>
AbstractRDFHandler	Base implementation of an RDFHandler which provides no-op implementations for all of the methods except handling of statements
AbstractReasoningConnection
AbstractSkippingIterator<T>	Abstract SkippingIterator implementation to help with concrete implementations.
AbstractSkippingLongIterator
AbstractSPARQLJSONWriter<T>
AbstractSPARQLXMLWriter<T>
ActionType	Enumeration containing all action types that can be used in permissions
ActiveResources
Adder	Interface for adding RDF to a Stardog database via a connection.
AdminConnection	A connection to the Stardog DBMS allowing access to the administrative functions provided by Stardog.
AdminConnectionConfiguration
AdminConnectionView<Input extends AdminConnection,Output extends AdminConnection>
Aggregate	A Function which computes an aggregated value over a group of solutions during query execution.
AlphaNumericComparator<T>	This is a comparator to perform a mix of alphabetical+numeric comparison.
Annotated	Object that contains a key value interface for annotations
ApachePoolConfig<T>	Abstract base class for instantiating a pool backed by Apache Pool.
ApachePoolImpl<T>	Pool implementation using an Apache object pool
ArbitrarySortedMapComparator<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<? super V>>	Comparator to order sorted maps.
ArrayIterable<T>	Adapter class for using an Array as an Iterable, particularly, for allowing parts of an array to be the iterable.
ArrayIterator<T>	Class which adapts an array of objects to the Iterator interface, particularly to allow sub-arrays to be iterated over.
ArrayLiteral	Literal consisting of an array of Stardog IDs
ArrayUtil
ASCIIUtil	Utility methods for ASCII character checking.
AsyncGraphQueryResult	A GraphQueryResult which asynchronously parses the result set from an input stream.
AsyncSelectQueryResult	A SelectQueryResult which asynchronously parses the result set from an input stream.
AtomicState<S extends java.lang.Enum<S>>	Represents a mutable state that can be updated exclusively through AtomicState.beginTransitionFrom(Enum[]) and AtomicState.endTransition() calls.
AutoCloser	This class is an equivalent of Guava's Closer, that supports AutoCloseables.
AutoDisposable	A special kind of Disposable that keeps track of references to it and disposes the object automatically when there are no references left.
Axiom	An OWL Axiom
Axiom.ClassExpression	An expression about a class
Axiom.Datatype	A datatype expression
Axiom.NamedDatatype	A named datatype expression
Axiom.PropertyExpression	An expression about a property
Axioms	Deprecated. Not used anymore, however since the class is part of our Public API some users might still be using it.
Axioms.Datatypes	Class which represents the various different datatypes
Axioms.ExpressionList<T extends Axiom>	Expression which represents an rdf:List of other expressions.
Axioms.Facet	Enumeration of the possible facets for a Axioms.FacetRestriction on a Axiom.NamedDatatype
Axioms.FacetRestriction	A restriction on a facet of a datatype.
Axioms.RestrictedDatatype	A user-defined datatype which has facet restrictions placed on its value
BasicMentionExtractor	Extract basic mentions of named entities
BasicMentionExtractorFactory
BatchingIterator<T>	An iterator which batches elements of the underlying iterator.
BCP47LanguageHandler	A language handler that can verify BCP47 formatted language tags.
BidirectionalIterator<T>	An Iterator which can iterate back to previous elements.
BidirectionalIterators	Utility class for bidirectional iterators.
BigArrayList<T>	Simple implementation of a list that can have more than Integer.MAX_VALUE values.
BiLongPredicate	A boolean predicate over tuples of two longs.
BiLongPredicate.BiLongFunction<T>
BiLongPredicate.StatefulBiLongPredicate
BinaryQueryResultConstants	Interface defining constants for the binary table result format.
BinaryRDFConstants	Constants for Binary RDF
BinaryRDFParser
BinaryRDFWriter	Writer for RDF in a binary format
BinaryRDFWriter.BinaryRDFWriterFactory	Factory for BinaryRDFWriter
BinarySelectQueryResultParser
BinarySelectQueryResultWriter	Writer for SelectQueryResult in a binary format
BinarySelectQueryResultWriter.BinarySelectQueryResultWriterFactory	Factory for BinarySelectQueryResultWriter
Binding	A variable binding in a single solution to a select query.
Bindings	Utilities for working with Binding
BindingSet	A set of query result bindings
BindingSetIterator	Iteration over a BindingSet elements
BindingSets	Utilities for working with BindingSet
BindingSets.Builder	Builder for BindingSet
BitesConnection	A connection to a document store within a Stardog database.
BitesOptions	Configuration options for Stardog's BITES subsystem
Bits	Utility class for manipulating bits.
BlockingThreadPoolExecutor	ThreadPoolExecutor which has a limited number of outstanding permits for executing tasks and when there are no more permits left, new tasks will block waiting for a permit to free up instead of throwing an exception.
BlockingThreadPoolExecutor.ExceptionHandler
BlockingThreadPoolExecutor.SilentExceptionHandler
BNode	A Blank Node, aka BNode, in an RDF graph.
Bool	Three-valued (true, false, unknown) boolean type.
BooleanQuery	A boolean (ASK) SPARQL query.
BooleanQuery	A query over a semantic graph whose results are a single `boolean` value.
BooleanQueryResult	Result of a `boolean` query.
BooleanQueryResultHandler	Result handler for boolean query results
BooleanQueryResultParser	Parser for BooleanQueryResult
BooleanQueryResultWriter	Writer for BooleanQueryResult
BoundedBuffer<T>	Adapted from the example in Java Concurrency in Practice to add new methods like pause, resume, size, and uninterruptibles.
BufferList<T>
BufferLists
ByteBuffers
CancelCheck
Cancellable	Interface for classes supporting cancellable computation.
CancellationManager	This is general abstraction to make 5 main functions: 1) Create cancellation point for specific database; Locks global mutex in readLock mode; Locks database-related mutex in readLock mode; 2) Execute exclusive database operation for specific database; Locks global mutex in readLock mode; Locks database-related mutex in writeLock mode; So it is impossible to create new cancellation point or to execute critical section while this lock is acquired; 3) Unregister cancellation point; Does not have locks with other operations; 4) Cancel cancellation points; Does not have locks with other operations; 5) Dispose cancellation manager (for all databases); Locks global mutex in write lock mode; It will be impossible to run all parallel methods during dispose;
CancellationManager.CheckedFunction<T,R>	Callable which may throw an exception.
CancellationPoint	Interface for cancellation points; We create cancellation point in one place and have a contract that we don't dispose system or don't drop database while the point is active and actual;
CancellationUtil	Utility methods for monitoring and cancellation of abstract processes.
CandidateGenerator	Generates a list of candidates from a mention
CandidateMention	A possible match between a mention and an entity.
CandidateSelector	Selects which ranks are worth saving in the database
CarrotUtil	Collection of utility methods for working with the Carrot Labs HPPC API
Change<E extends java.lang.Enum & ChangeType,T>	Class which represents a logical change to a resource.
ChangeList<E extends java.lang.Enum & ChangeType,T>	An ordered list of changes to some resource.
ChangeType	The type of a Change.
Channels2
ClassServiceLoader	A simplified version of the ServiceLoader in the JDK.
Clock
CloseableIterator<T>	An Iterator which can be closed.
CloseableIterator.AbstractCloseableIterator<T>
CloseableIterator.DelegatingCloseableIterator<T>
CloseableIterator.EmptyCloseableIterator<T>
CloseableLongIterator
ClusterAdminConnection	Public AdminConnection for cluster/pack functions.
ClusterNodeRole	Represents the role of a cluster node.
ClusterNodeStatus	A convenience class to status information from many nodes
ClusterNodeType	Represents the type of cluster node that is in use
ClusterStatusView	Cluster status view for api response serialization/deserialization to JSON
CollectingRDFHandler<T>	Simple RDFHandler that will collect the statements and return a result.
Columns	Utility class to create different kinds of columns
CommitResult	Represents the approximate net number of triples added or removed in a transaction.
CompressedRDFFormat	Class to represent the format of serialized RDF that is also compressed
ComputeAdminConnection	Connection for importing files and virtual graphs via external compute
ConfigProperty<T>	Representation of a configuration option.
Connection	Interface for a connection to a Stardog database.
ConnectionConfiguration
ConnectionCredentials	This object is used to set the authentication mechanism on Stardog HTTP connections.
ConnectionPool	A pool of Stardog connections.
ConnectionPoolConfig	A configuration object for creating connection pools.
ConnectionView<I extends Connection,O extends Connection>	Interface to provide conversion of the 'view' of a connection to another type of connection.
ConstantAppendingLongIterator	This is a union of a long iterator with a constant.
Constraint	Interface to represent an integrity constraint.
ConstraintFactory	Factory to simplify creating constraint objects.
ConstraintViolation<T>	Interface to represent the violation of an integrity constraint.
ContextCopyStatementSource	StatementSource decorator that indicates that we are copying all triples from one context to another context.
ContextFallbackStatementSource	StatementSource decorator which will provide a context for statements that don't have a context.
ContextOverrideStatementSource	StatementSource decorator which will override the context of the underlying source.
Contexts	Defines constants that represent special URIs for contexts (named graphs).
ContextSets	Defines constants for contexts (named graphs) that Stardog treats specially.
Copyable<T extends Copyable<T>>	Interface for an object that can be copied.
Copyables	Utility methods for copying collections of Copyable objects.
CuratorReadWriteTxLock
DaemonExecutor
DatabaseBuilder	Builder class for creating new Stardog databases.
DatabaseConsistencyException	Exception thrown when there is a fatal transaction error when performing the commit or rollback operation and the database signifying that the database needs recovery to be performed on the failed transaction.
DatabaseException	Signals that an error has occurred while performing an operation on a database
DatabaseOptions	Non-structural database options.
DatabaseOptions.InlineStoredQuery
DatabaseOptions.LanguageNormalization	Different types of datatype normalization algorithms supported by Stardog.
DatabaseOptions.TransactionIsolation	Different types of transaction isolation supported by Stardog.
DataKey<E>
DataMap	An object that maps keys to values in a type-safe manner.
Dataset	Amalgum of an RDF 1.1 Dataset, a SPARQL 1.1 RDF Dataset & a SPARQL 1.1 update [graph](https://www.w3.org/TR/sparql11-update/#deleteInsert)
Datasets	Utilities for working with Dataset
Datasets.DatasetImpl	Default implementation of a Dataset.
Datasets.DatasetImpl.Builder	A builder for a Dataset.
DataSourceInfo	Information about a data source
DataSourceOptions	Options shared by data sources of all types.
DataSourceQueryResult	DTO for storing DataSourceQuery results
Datatype	Object representing the datatype of a Literal.
DatatypeHandler	An interface defining methods related to verification and normalization of typed literals and datatype IRIs.
Dates	Utility methods for working with the Date object
DateTime	Immutable representation of date time.
DateTimeInlineUtils	Inlining logic for datetime values.
DC	Term constants for the DC vocabulary
DCTERMS	Dublin Core Metadata Terms
Decorate	Annotation to support the workaround for supporting the decorator design pattern with Guice where we have some interface I, a default/base implementation A, and a decorator class B, which should accept as an argument the default implementation A.
DefaultCancellationPoint
DefaultCandidateFeatureGenerator	Merges the logic behind WaldoCandidateGenerator and IDLabelDistance in a single query, e.g.:
DefaultPoolableObjectFactory	Provides a simple implementation of a PoolableObjectFactory that can be used with ApachePoolConfig.
DefaultSchemaManager
DefaultSensitivePropertyManager	The default implementation of the SensitivePropertyManager interface using a database connection.
DelegatingAdminConnection
DelegatingCancellationPoint
DelegatingRDFHandler
DelegatingRDFStream
DelegatingSkippingIterator<T>
DelegatingStatementSource	Implementation of a StatementSource which can be used as the base for StatementSource decorator implementations.
DictionaryLinker	Link entities based on a String -> IRI dictionary
DictionaryLinker.Linker	Maps a Span to one or more IRI
DictionaryLinker.LinkerSerializer	Serializer for DictionaryLinker.Linker objects: [total_size][[key, values_size, values...], ...]
DictionaryLinkerExtractorFactory
DictionaryLinkerRDFExtractor	Extracts named entities using OpenNLPDocumentParser, linking them to existent entities on a set of pre-given String -> IRI mappings
DisjointSet<T>	Disjoint set data structure.
Disposable	A Disposable is an object data that can be disposed once it is not needed anymore.
Disposables
Disposer	Utility for tracking and mass Disposable.dispose() of Disposable resources.
DistanceUnit	The distance units for use with spatial queries
Document	A collection of tokens, organized in sentences
DocumentParser	Parses strings into Documents
Driver	The interface that any Driver must implement.
DriverManager	Service for obtaining instances of Drivers and Connection instances.
DriverModule	A Module interface for loading API drivers via Guice
DummyCancellationPoint
Duration	Immutable representation of a duration.
DurationFormat	A simple class to provide various formatting options for durations represented in milliseconds.
Durations
Edge
EnhancedProperties	Extends the java.util.Properties stuff to provide typed accessors to get property values as boolean, int, etc.
EntityExtractor<T extends Spans>	Extract some type of entities
EntityExtractorFactory<T extends Spans>	Creates instances of EntityExtractor for the given connection.
EntityExtractorRegistry	The registry of all available entity extractors
EntityLinker	Entity linker
EntityLinkerExtractorFactory
EntityLinkerRDFExtractor	Extracts named entities using OpenNLPDocumentParser, linking them to existent entities based on the similarity of their label/ID.
Exceptions
ExecutionGroup	A very light-weight utility class to make it easier to run a set of tasks together and wait until all those jobs end.
Executors2	Executors utils
Executors2.CachedThreadPoolBuilder
ExplainOptions	Options supported for Query.explain() command.
Exporter	API for exporting RDF data in bulk from the server.
ExtendedBufferList<T>	An extension of BufferList which can maintain its sorted state and eagerly remove duplicates when elements are inserted.
ExtendedObjectSerializer<T>	A serializer which helps to serialize objects to ByteWriters and read from ByteReaders.
ExtractionQuery	Utility class to generate a SPARQL CONSTRUCT query that will extract all resources that have specified types or predicates.
Extractor<Output>	Interface for objects that extract data from text documents.
Feature	Simple class which wraps a Shape and associates it with a id for that shape.
FeatureGenerator	Adds features to a CandidateMention
FileChangeCache	Cache for files, which invalidates its elements when files are modified
FileFormat	Represents the format of a file or stream, such as XML or JSON.
FileFormat.Compression
FileFormatImpl	Default implementation of FileFormat
FOAF	Constants for the FOAF ontology
ForEachIntTask	A ForkJoinTask for performing a parallel for-each operation;
FormattedColumn	Column that foramts values using String.format(String, Object...).
FormattingResourceBundle	Simple extension to ResourceBundle that handles message formatting via MessageFormat for values in the resource bundle.
ForwardingRDFHandler	RDFHandler base implementation that will decorate a base handler
ForwardingRDFWriter	RDFWriter base for decorating another writer
Function	This is the extension point for 17.6 (Extensible Value Testing) of the SPARQL spec.
Functional	Functional utilities
GeoException	Root exception for all spatial related errors
Geosparql
Geosparql.Functions
Geosparql.Units
GeoSPARQLDatatypeHandler
GeospatialIndex	A spatial index
GeospatialIndexConnection	All lengths and distances are given in DEGREES.
GeospatialIndexFactory	Factory for creating instances of GeospatialIndex
GeospatialIndexMetadata	Utility class for reading the metadata about a spatial index
GeospatialIndexState
GeospatialOptions	Set of options for configuring Stardog Spatial
GeospatialSink	Handler for something that can process geometric Shapes
GeospatialSource	A source of geospatial information
Getter	Interface for retrieving statements from a Stardog database.
GlobalTimer
GraphBuilder	Utility class for building a `Graph`
GraphQLConnection	Extends the standard SNARL Connection exposing the GraphQL query support.
GraphQLOptions
GraphQLQuery	Executable GraphQL query.
GraphQLSchemaManager	Interface for the storage and retrieval of GraphQL schemas.
GraphQuery	A SPARQL graph (describe or construct) query.
GraphQuery	A query over a semantic graph whose results are themselves a graph
GraphQueryResult	Query result of a sequence of statements which correspond to a `Graph` result.
GraphQueryResultIterator	Iteration implementation over graph query results.
Graphs	Utilities for working with collections of RDF statements.
HandlerBackedIterator<T>	An adapter for converting push-based data processing (aka handler-based) to pull-based data processing (aka iterator-based).
HandlerBackedIterator.DataConsumer<T>
HandlerBackedIterator.DataProducer<T>
HandlerBackedIterator.ProducerFinished	Can be thrown out of Consumer.accept(Object) to indicate that the producer must stop generating data.
HTMLQueryResultWriter
HTMLQueryResultWriter.HTMLQueryResultWriterFactory
ICV	Set of utility functions for dealing with Stardog ICV support.
ICValidator	End-user interface for Integrity Constraint Validation support on a Stardog database.
ICVConnection	Extension of Connection that allows IC validation.
ICVOptions
IDLabelDistance	Measures the string distance between the mention and the label/ID of the candidate IRI.
ImmutableCollectors
ImmutableEdge	An immutable implementation of Edge
ImmutablePath	Immutable implementation of Path
Indexing	Utilities for spatial indexing
IndexOptions	Set of options for configuring the low-level indexes.
IndexOptions.CompressionType
IndexOptions.IndexType	Types of indexes.
IndexOptions.WriteConflictStrategy
InfoProperty<T>	Representation of a Stardog information option.
Injectors	Utility class for working with Injectors and Guice in general.
Instrumentor	Simple -javaagent compatible instrumentor.
InterProcessTxLock	Similar to an InterProcessLock, but we track the locks with specific transaction ids.
IntObjectBiMap<T>	Very simple BiMap implementation which simply wraps two IntObjectMaps
InvalidLiteral	Exception thrown when a Literal encountered during parsing is syntactically correct, but otherwise invalid.
InvalidQueryResults	Exception denoting parsing of serialized query results failed due to syntax errors
InvalidQueryType
InvalidRDF	Exception thrown when parsing an RDF file and the contents are not syntactically valid RDF.
InvalidVariableException
IO	IO interface for reading RDF data from various input sources.
IOBindingSetIterator	Helper class to adapter the Sesame push parsing for query results to a pull interface via an Iterator.
IOFunction<T,R>	Function which performs I/O which declares throwing IOException
IOParserContext	Extended parser state that wraps the stream to be parsed to provide common IO operations for most of the basic text RDF formats.
IRI	An Internationalized Resource Identifier (IRI) within an RDF graph.
IteratorAsBooleanQueryResult	Adapter from an Iterator produced during query evaluation to a BooleanQueryResult.
IteratorAsGraphQueryResult	Adapter class for using a StatementIteration as a Sesame GraphQueryResult.
IteratorAsPathQueryResult	Adapter class for using a BindingSetIteration as a PathQueryResult
IteratorAsTupleQueryResult	Adapter class for using a BindingSetIteration as a TupleQueryResult
JdbcOptions	Options used by JDBC data sources.
JenaSesameUtils	Utility methods for converting between the Jena and Sesame APIs
JSONLDMode	Specifies constants to identify various modes that are relevant to JSONLD documents.
JSONLDOptions
JSONLDParser	Default parser for JSON-LD
JSONLDWriter	Deprecated. Use StreamingJSONLDWriter instead
JSONLDWriter.JSONLDWriterFactory
KernelAdminConnection
Krb5Utils
LanguageHandler	An interface defining methods related to verification and normalization of language tags.
LineBatch	Batch of consecutive lines read from a stream.
LineSupplier	A utility class that reads lines from a stream in one thread and supplies the output as batches for multiple threads to consume.
LineSupplier.InputStreamSupplier
LineSupplierParserContext	Extends IOParserContext to read the input from a LineSupplier instead of an input stream.
LinuxDistribution	Set of parsers and utilities for determining version information about the Linux distribution we are currently running on.
LinuxDistribution.Distribution
ListComparator<T extends java.lang.Comparable>	Implementatino of a Comparator for List's of Comparable objects
ListenerSupport<T extends java.util.EventListener>	Base class for a collection of listeners
Literal	A literal value in an RDF graph
LogicalServiceQuery	Service query which represents a logical service query to be used in the early stages of rewriting and optimization.
LogicalServiceQuery.LogicalServiceQueryBuilder
LoginConnectionConfiguration<T>	Interface representing connection options such as authentication credentials and the server to connect to.
LogJsonOuput
LogOutputter
LongIterator	An iterator over primitive longs
LongIterators
LowercaseBCP47LanguageHandler
MalformedQuery	Exception thrown when a evaluating a query that has parse errors
MarkResetIterator<T>	An interface to support multiple passes over a specific part of the iterator's output via mark/reset operations.
MarkResetSkippingIterator<T>	Implements the mark-reset behavior via ResettableIterator.reset() and SkippingIterator.skipTo(Object).
Maths	Math-related utils
MaxRanking	Sets the maximum value on all of a candidate's features as its Rank
MediaTypes	Utility methods and constants for the Guava MediaType class
Memory	Utility class for memory related information.
MemoryConfiguration	Class for configuring memory used by different components.
MemoryConfiguration.HeapComponent
MemoryConfiguration.NativeComponent
MemoryConfiguration.StarrocksComponent
MemoryInfo	TODO Merge this class into c.c.c.base.Memory when it is moved into Stardog codebase
MentionExtractor	Extracts entity mentions, as a list of spans, from a Document
MentionRDFExtractor	Extracts named entities using OpenNLPDocumentParser
MergedColumn	A column that spans multiple columns.
Metadata	Mapping from Stardog meta properties to values.
MetaProperties	This class acts as the registry of valid Stardog options and provides convenience functions.
MetaProperty<T>	Representation of a Stardog metadata property.
MetaProperty.Builder<T,P extends MetaProperty<T>>	The builder class for building an option instance.
MetaProperty.Flag
MetaPropertyProvider	Marker interface for classes that define Stardog options.
MultiLock	Provides nonreenterant locking capability for a given ID.
MultipleMentionExtractor	Applies multiple MentionExtractor to a Document
MultiStatementIterator	StatementIterator whose contents are the concatenation of multiple iterators.
N3Parser
NamedGraphPermissions	Utility for granting and revoking named graph permissions
Namespace	A namespace; an IRI and prefix pair that can be used during serialization to shorten a IRI to a `QName`.
Namespaces	A collection of namespace defintions
NamespacesInfo	The namespaces stored in a database.
NamespaceUtils	Utility methods for working with namespaces
NativeMemoryMonitor	Monitors memory usage as reported by the underlying Operating System.
NaturalOrderComparator<T extends java.lang.Comparable<T>>	Simple Comparator implementation which can be used for Comparable objects.
NERMentionExtractor	Generates mentions from sequences of NER tags of the same original span in the same sentence.
NestedList<T>	An immutable linked list object with structure sharing.
NLPUtils
NonDominatedSolutions<T extends java.lang.Iterable<? extends java.lang.Number>>	A collection which keeps all non-dominated solutions in terms of a (multi-objective) optimization problem.
NonReentrantCuratorReadWriteLock	A non-reentrate read-write lock.
NonReentrantMutex
NQuadsParser	Default implementation of a parser for the RDF NQuads syntax
NQuadsWriter	Writer for NQuads
NQuadsWriter.NQuadsWriterFactory	Factory for NQuadsWriter
NTParser	Default implementation of a parser for the RDF NTriples syntax
NTriplesUtil	Utilities for reading and writing NTriples
NTWriter	RDFWriter implementation for the N-Triples RDF format
NTWriter.NTWriterFactory
Numbers
Objects2	Object utilities not provided by Objects.
OpenNLPDocumentParser	DocumentParser based on OpenNLP
OpenNLPMentionFixer	OpenNLP regularly extracts named entities where the last token is a quotation mark/bracket/dash, e.g.:
Option<V>	Represents a configuration option.
OptionalConstructorParam<T>	Workaround for optional constructor parameters with Guice.
OptionFunction
Options
OS	Utility class to check the operating system in runtime.
OSUtil
OSUtil.NativeMemoryUsage	Native memory usage info collected from OS.
OverrideModule
OWL	Constants for the OWL Web Ontology Language and OWL2.
Pair<K1,K2>	Tuple with 2 elements
ParsedURI	A replacement for Java's own URI: java.net.URI.
ParserConfigs
ParserContext	Object to hold the current state of the parsing operation, parsing configuration, and Value creation.
ParserContext.ParseError
ParserOptions	Options for RDF parsing.
PartitionedSkippingIterable<T>	Interface for ordered data sources that returns a skipping iterator.
Path	Representation of the results of a path query.
PathQuery
PathQueryResult	QueryResult for paths.
PathQueryResultWriter	Renders path query results as tuples.
PathsAsTupleQueryResult	Represents a result set of a path query as tuples.
PeekingLongIterator
PeekingSkippingIterator<T>
PermissionManager	API for managing permissions in Stardog
Permissions
Permissions.ActionBuilder
Permissions.ResourceBuilder
Permissions.TypeBuilder
PlanNodeBodyServiceQuery	A ServiceQuery with a PlanNode as the body.
PlanNodeBodyServiceQuery.CanonicalizedPlanNodeBodyServiceQuery	This machinery allows subclasses to return a "canonicalized" version of the query to be used in plan caching.
PlanNodeBodyServiceQuery.CanonicalizedPlanNodeBodyServiceQueryBuilder
PlanNodeBodyServiceQuery.PlanNodeBodyServiceQueryBuilder	Base builder for PlanNodeBodyServiceQuery objects
PlatformDependent	Access to sun.misc.VM included to get maxDirectMemory for the VM; this is actually pulled from io.netty.util.internal.PlatformDependent
Pool<T,E extends java.lang.Exception>	Simple interface for a Pool of objects
Poolable<E extends java.lang.Exception>	Interface for a resource that can be used with an object Pool.
PoolConfig<T,E extends java.lang.Exception>	Abstract configuration for a Pool
PopularityScore	Counts the number of inbound edges for an entity
PreciseMultiLock	Implementation of MultiLock interface with precise locking which means no thread will block for an ID unless that ID is locked by another thread.
PredefinedMemoryRatio	Predefined memory configuration modes.
PrefixMapping	A class to convert URI's to QNames.
PrettyTurtleWriter	An Turtle writer that abbreviates bnodes and lists.
PrettyTurtleWriter.PrettyTurtleWriterFactory
Progress	Read-Only interface for progress info.
Progress.Default	Immutable default implementation of a progress
ProgressMonitor	A multi-thread safe progress monitor implementation that prints progress percent and elapsed time at specified percent increments.
ProgressMonitor.Builder	Builder class for a customizable progress monitor
ProgressMonitor.DefaultProgressFormatter
ProgressMonitor.DelegatingProgressMonitor
ProgressMonitor.ProgressFormatter
ProgressMonitor.ReportingProgressMonitor	Chain more than one monitor / reporter
ProgressReporter	Interface for progress reporting
Proof	Represents a proof tree.
PropertiesBuilder	Simple builder class for creating instances of Properties
PROV	Auto-generated vocabulary class.
Providers
QUDT
Query<T>	Object for executing a query against a Stardog database.
Query	A query over a semantic graph
QueryEngine	Interface for something that is able to execute and explain queries.
QueryExecutionFailure	Exception for errors that occur while evaluating a query
QueryFactory	Interface for creating queries
QueryInfo	A simple structure that shows information about a query.
QueryInfo.Status
QueryLanguage	Marker interface for the language of a query
QueryManager	Provides basic query management functions such as listing all the running queries and killing a running query on-demand.
QueryPlan	An execution plan for a Query
QueryPlanReuse	Options for configuring how Stardog will reuse query plans.
QueryResult<T>	The results of executing a Query
QueryResultBuilder<T>
QueryResultFormat	Format denoting the different serialization options for query results.
QueryResultFormats	Utilities for QueryResultFormat
QueryResultHandler<T>	Handler for processing query results.
QueryResultHandlerException	Base exception for errors that occur while handling results.
QueryResultParser<P extends QueryResultHandler>	Parser for serialized query results
QueryResultParserOptions	Options to control parsing of query results
QueryResultParsers	Utilities for working with query results
QueryResults	Utilities for working with QueryResults
QueryResultWriter<T>
QueryResultWriterFactory	Factory interface for creating result writers
QueryResultWriterOptions	Options for controlling the writing of query results
QueryResultWriters	Utilities for writing query results.
QueuedSortedIterator<T>	A sorted iterator wrapper to which elements can be added dynamically.
RandomStatementGenerator	Generates an infinite sequence of random RDF triples.
RandomStream
RandomStream.Factory
RandomValueGenerator	Generates an infinite sequence of random RDF terms.
Rank	The final score given to a CandidateMention by a RankingFunction
RankingFunction	Attributes a final score to a CandidateMention
RDF	Constants for the RDF language
RDFByteSource	Deprecated.
RDFDatatypesHandler
RDFExtractor	An RDFExtractor is used to process a document to extract a set of RDF statements about that document.
RDFFileSupplier	A File supplier whose file contains RDF in the specified format.
RDFFormat	Represents the serialization used for RDF.
RDFFormat.BinaryRDFFormat	Marker interface for an RDFFormat whose serialization is binary rather than textual.
RDFFormats	Utilities for RDFFormat
RDFHandler	Interface for consuming RDF
RDFHandlerException	Exception denoting something unexpected happened in an RDFHandler
RDFHandlers	Utility methods for working with RDFHandler
RDFHandlers.DefaultRDFHandler
RDFHandlers.GraphBuilder
RDFJSONParser
RDFJSONWriter	Writer for RDF in RDF/JSON format
RDFJSONWriter.RDFJSONWriterFactory	Factory for RDFJSONWriter
RDFLists	Utilities for working with RDF lists.
RDFMediaTypes	MediaType objects related to RDF, SPARQL, and other SemWeb concepts.
RDFNamespaceHandler
RDFObfuscator	This is a simple utility program to obfuscate the contents of an RDF file.
RDFParser	An RDF Parser.
RDFParsers	Utilities for working with RDFParser
RDFS	Constants for the RDF Schema 1.1 (RDFS)
RDFStatementHandler	Handler for statements created by the stream loader.
RDFStatementHandler.Factory	Factory class to generate statement handlers.
RDFStatementList	List of statements with an optional context value that will override any context defined by the individual statement objects.
RDFStream	A simple interface for representing a stream for RDF input.
RDFStreamBase
RDFStreamBuilder
RDFStreamFactory	A simple interface for creating RDF streams
RDFStreamOptions	Options for RDF parsing used only via RDFStreamBuilder.
RDFStreamProcessor	Stream processor that handles concurrent production of statements from multiple streams and passes the statements to handlers or provides the results as an RDFStreamProcessor.iteration(List, CancelCheck).
RDFStreams	A simple interface for parsers.
RDFValueColumn
RDFWriter	A writer to serialize RDF statements in a particular RDF format.
RDFWriterFactory	Factory interface for creating instances of the RDFWriter
RDFWriters	Utility methods for working with RDFWriter
RDFWriters.RDFWriterConfig	Write builder for RDFWriter
RDFWriters2	Utility class to write statements with namespaces.
RDFXMLParser	Default RDFParser for the RDF/XML format
RDFXMLParserOptions	Deprecated. Use ParserOptions instead
RDFXMLPrettyWriter	An extension of RDFXMLWriter that outputs a more concise form of RDF/XML.
RDFXMLWriter	Default writer for the RDF/XML serialization
RDFXMLWriter.RDFXMLWriterFactory
RDFXMLWriterOptions	Options for writing RDF/XML
ReadQuery<T>	A read-only query, ie a select, construct, graph or ask query.
ReadQuery	A read-only query over a semantic graph
ReasoningAPIUtils
ReasoningConnection	SNARL Connection which exposes reasoning specific functionality such as explanations and consistency checking.
ReasoningOptions	Options for controlling reasoning behavior.
ReasoningType	Enumeration for the different reasoning levels available in stardog.
Reflect	A series of basic Reflect based utility functions.
Remover	Interface for an object which can remove RDF data from a Stardog database.
ReportInterval	A utility class to help with reporting progress at predefined intervals.
ReportIntervalCounter	A report interval extension that also handles tracking progress.
Resettable	Anything which has a state that can be reset and must be closed.
ResettableIterator<T>	Iterator which can be reset to the first element.
ResettableIterators
ResettableLongIterator
ResettablePredicate<T>	An interface for stateful Predicate implementations that provides a reset function to clearing the internal state.
Resource	Super interface for BNode and IRI which are disjoint RDF node types from Literal
ResourceBuilder	Utility class for creating a `Graph` where all the statements are about a particular resource
Resources2
RestrictedMarkResetIterator<T>	An extension to the base interface to support restrictions on the base iterator, for example, to implement the mark-reset behaviour for the cross phase of the merge join.
ResultWritingFailed
RFC3066LanguageHandler	A language handler that can verify RFC3066 formatted language tags.
RoleManager	API for managing user roles in Stardog.
RuleVocab
SchemaManager	Convenience class to manage reasoning schemas for a database.
SchemaOrg	Constants for the Schema.org Schema
Schemas	Convenience functions and constants for reasoning schemas.
SDJenaFactory	Factory for obtaining instances of the Jena framework core, specifically Models and Datasets, which are backed by Stardog.
SearchConnection	Extends the standard SNARL Connection exposing the full-text search support provided by Waldo.
Searcher	Interface for conducting full text searches against a Stardog database via the Waldo Semantic Search engine.
SearchOptions	Database options for the waldo search index.
SearchResult	Simple search result data structure.
SearchResults	A wrapper around the search results that may additionally have suggestions for an alternative search string.
SecurityOptions	Options for controlling the initialization of Security in Stardog and security configuration in a database.
SecurityResourceType	Interface for security resource types.
SelectPlanQuery
SelectQuery
SelectQuery
SelectQueryResult	Represents tabular query results of rows of tuples which represent the variable-value pairs of the results
SelectQueryResultHandler	Result handler for boolean query results
SelectQueryResultParser	Parser for SelectQueryResult
SelectQueryResultWriter	Writer for SelectQueryResult
SensitivePropertyManager	Convenience class to manage sensitive properties for a database.
SerfOptions	Serf options
Serializers	Provides support for serializing/deserializing object or primitive values to/from byte arrays.
Serializers.IntSerializer	Serializer for primitive integer values.
Serializers.LittleEndianLongSerializer
Serializers.LongSerializer	Serializes the given long to 8 bytes.
Serializers.ObjectSerializer<T>	Generic serializer interface for objects.
Serializers.ShortSerializer	Serializes the given short to 2 bytes.
Serializers.UnsignedLongSerializer	Serialize longs in an "Unsigned" form.
Serializers.VarLongSerializer	Serializes the given long to as many bytes as required.
Server	Basic interface for a Stardog server which allows a server to be started or shut down.
ServerBuilder	Interface for configuring and creating a Stardog server.
ServerException
ServerFactory	Simple interface for starting a server programmatically
ServerOptions	Server configuration options
Service	Interface representing a Service that is capable of providing results due to the evaluation of a SPARQL query.
ServiceLoaders	Wrapper around the Java ServiceLoader class which returns collections of instances of an interface as opposed to iterators over instances that the normal ServiceLoader returns.
ServiceParameters	Parameters for services when the body does not represent a SPARQL query.
ServiceQuery	An immutable instance of a query on a given service.
ServiceQuery.DistinctValuesEstimationFunction
ServiceQuery.ServiceQueryBuilder	Base service query builder class.
ServiceRegistry	Registry for SPARQL federated service implementations.
ServiceTranslator	Turn logical service queries into their physical counterparts.
Shapes	Utilities for working with the Shape class.
SharedExecutor	Stardog executor service to provide the functionality of a ScheduledExecutorService without the cost of creating a new executor service every time the executor is needed.
SharedForkJoinExecutor
ShutDownHookManager	Shutdown hook manager which unifies all logic with object's lifecycle;
SimpleSAXAdapter	An implementation of SimpleSAXListener providing dummy implementations for all its methods.
SimpleSAXListener	A listener for events reported by SimpleSAXParser.
SimpleSAXParser	An XML parser that generates "simple" SAX-like events from a limited subset of XML documents.
SingletonQueue<T>	A simple queue that can hold at most one element while in addition provides a function to SingletonQueue.close() the queue.
SizeFunction<T>	An interface for computing (typically approximate) size of a specific kind of object.
SizeFunctions	Implementation of size computation for commonly used object types.
SkippingIterable<T>	Interface for ordered data sources that returns a skipping iterator.
SkippingIterables	Few utility functions
SkippingIterator<T>	Iterator over an ordered data source that is able to jump to a specific element (or the next greater after that).
SkippingIterators	Few utility methods to construct skipping iterators.
SkippingLongIterator	Iterator for primitive longs that allows skipping.
SKOS	Constants for the [SKOS](http://www.w3.org/TR/skos-reference) vocabulary.
SortedIterators	Few utility methods to construct skipping iterators
SortedIterators.UnionBuilder<T>
Sorter<T>	This class performs merge sort over an array but allocates the additional array used in merge sort upfront so if the arrays of same size will be sorted repeatedly this sorter can be reused to minimize garbage collection with the price of having memory for extra array always being used.
Sorter.QuickSorter<T>	Sorter implementation for QuickSort.
Span	A sequence of tokens in a Document
Spans	Represents a stream of Span extracted by a EntityExtractor potentially linked to entities in the graph.
SPARQL	The SPARQL Query language
SPARQLCSVResultParser
SPARQLCSVResultWriter	Writer implements for SPARQL/CSV query result format
SPARQLCSVResultWriter.CSVRWFactory	Factory for creating SPARQLCSVResultWriter
SPARQLJSONBooleanResultParser	BooleanQueryResultParser for results encoded in SPARQL/JSON.
SPARQLJSONBooleanResultWriter	Writer for boolean results in SPARQL/JSON.
SPARQLJSONBooleanResultWriter.SPARQLJSONBooleanResultWriterFactory	QueryResultWriterFactory for SPARQLJSONBooleanResultWriter
SPARQLJSONConstants
SPARQLJSONOptions	Options for reading and writing SPARQL/JSON
SPARQLJSONSelectResultParser	SelectQueryResultParser for results encoded in SPARQL/JSON.
SPARQLJSONSelectResultWriter	SelectQueryResultWriter for select results as SPARQL/JSON
SPARQLJSONSelectResultWriter.SPARQLJSONSelectResultWriterFactory
SPARQLTSVResultParser	Implementation of parsing query results in SPARQL/TSV format.
SPARQLTSVResultWriter	Implementation of writing query results in SPARQL/TSV format.
SPARQLTSVResultWriter.SPARQLTSVResultWriterFactory	Default factory implementation for SPARQLTSVResultWriter
SPARQLUpdateDataBlockParser	An extension of TrigParser that processes data in the format specified in the SPARQL 1.1 grammar for Quad data (assuming no variables, as is the case for INSERT DATA and DELETE DATA operations).
SPARQLUtil	Collection of utility methods for working with SPARQL strings
SPARQLUtil.QueryType
SPARQLUtils
SPARQLXMLBooleanResultParser	Parser for boolean results in SPARQL/XML
SPARQLXMLBooleanResultWriter	Writer for BooleanQueryResult which will serialize results in SPARQL/XML format.
SPARQLXMLBooleanResultWriter.SPARQLXMLSelectResultWriterFactory	Factory for SPARQLXMLBooleanResultWriter.
SPARQLXMLParserOptions
SPARQLXMLSelectResultParser	SPARQL/XML parsing for SelectQueryResult
SPARQLXMLSelectResultWriter	Writer for SelectQueryResult which will serialize results in SPARQL/XML format.
SPARQLXMLSelectResultWriter.SPARQLXMLSelectResultWriterFactory	Factory for SPARQLXMLSelectResultWriter.
SpoolingMarkResetIterator<T extends Copyable<T>>	A wrapper around MarkResetSkippingIterator with bounded spooling: once the SpoolingMarkResetIterator.mark(T) method has been called, the iterator will start spooling until one of the following conditions occurs: 1) the spooling threshold is reached, in which case the iterator switches to the skipping-based mark-reset behavior.
SSD
SSLContextFactory	Utility class for creating SSLContext instances for use by a Netty stack.
StackTrace
StandbyNodeState	Represents that type of cluster node that is in use
StandbyNodeStatus	A convenience class for standby status information
StardocsConnection	Deprecated.
StardogAuthenticationException	Exception thrown when it was not possible to authenticate a stardog user with the provided credentials
StardogAuthorizationException	Exception thrown when the user is not authorized to perform the operation.
StardogException	Base class for all Stardog exceptions
StardogExplainer	Interface for explainer that can provide explanations for inferences made by a Stardog reasoner.
StardogExplainerOptions	Deprecated.
StardogIRI	Deprecated. Use IRI instead
StardogMappings	Deprecated.
StardogMappingSyntaxParser	Parser for Stardog mappings syntax.
StardogMappingSyntaxWriter	A writer that outputs mappings in Stardog syntax.
StardogMappingVocabulary	Vocabulary terms used in Stardog Mapping Syntax.
StardogModelAssembler	An assembler implementation to build a Stardog model from an assembler description in RDF.
StardogModelAssembler.Vocabulary	Stardog assembler vocabulary.
StardogRepository	Implementation of a Stardog-based rdf4j Repository.
StardogRepositoryConfig	Stardog based Repository configuration for use with StardogRepositoryFactory
StardogRepositoryConnection	Stardog-based implementation of an RDF4J RepositoryConnection.
StardogRepositoryFactory	Implementation of Sesame's RepositoryFactory interface to support creating StardogRepository instances via their repository configuration API
StateMachine<S extends java.lang.Enum,E extends java.lang.Enum,O>	This class manages state transitions in an organized way.
Statement	A Statement in RDF.
StatementIterator	Interface which will iterate over a source of Statements.
StatementPattern	A Statement implementation representing a Statement pattern, which is a Statement where some or all of the SPOC elements are a wildcard.
StatementPattern.Builder
Statements	Utilities for working with Statement.
StatementSource	Interface which represents a source of a set of RDF statements.
StatementSources	Utility class for working with StatementSources
StatementSources.RDFStreamStatementSource
StoredQueries	A mutable collection of stored queries.
StoredQuery	Represents a query stored in the server.
StreamingJSONLDWriter	Streaming writer for JSON-LD
StreamingJSONLDWriter.StreamingJSONLDWriterFactory	Factory for creating StreamingJSONLDWriter
Streams	Utility for streams
Streams.CheckedBiConsumer<U,T>
Streams.CheckedBiFunction<In1,In2,Out>
Streams.CheckedConsumer<T>
Streams.CheckedFunction<In,Out>
Streams.CheckedPredicate<T>
Streams.CheckedRunnable
Streams.CheckedSupplier<Out>
Streams.UncheckedException	Exception indicating that Checked* threw an exception and the default handler was used
Strings2	String utilities not provided by Strings.
SupportedFileFormats<T extends FileFormat>	Utility class to keep a list of formats that are supported by an application.
SWRL	Constants for the [SWRL](https://www.w3.org/Submission/SWRL/) vocabulary.
SystemClock
SystemUtil	Utility methods for working with System, particularly safe, default value supported lookups into System.getProperty(java.lang.String) and other OS/system level calls.
TableData	Create a table data structure that has a list of column names and list of data rows.
TableExporter	TextTable exporter with predefined settings and bug fixes.
TableExporter.FixedTextTableWriter	Fixes a bug in TextTableWriter where right intersection was used in every place a right left intersection was supposed to be used.
Test	A single test that involves running a specific SPARQL query.
Testable	An object that represents a single test or a collection of tests.
TestCreator	Creates a TestSuite from query files in a directory.
TestCreator.CreateOption	Option to specify what the created tests will test
TestDefinitionException
TestFailedException
TestReader	Reads a test suite definition from an RDF file.
TestResult	Result of running a Test.
TestResultType	Enumeration of test result types.
TestRunner	Runs all the tests in a suite.
TestSuite	A collection of tests organized in a hierarchical structure.
TestVocab	RDF vocabulary used for serializing test definitions.
TestWriter	Writes the test suite definition to an RDF file.
TextBooleanQueryResultParser	QueryResult parser for text-based results
TextBooleanQueryResultWriter	Writer implementation for simple text-based boolean results
TextBooleanQueryResultWriter.BQRWriterFactory	Factory for TextBooleanQueryResultWriter
TextExtractor
TextPathQueryResultWriter	Renders path query results in a concise text syntax: (node1)-[var1=value1, var2=value2]->(node2).
TextProvidingRDFExtractor	A base class for RDF extractors wishing to work with text directly.
TextTablePathQueryResultWriter	Renders path query results in a table where each row shows an edge and multiple paths are separated by an empty row.
TextTableQueryResultWriter	Implementation of SelectQueryResultWriter interface to output a nice looking text table with many customization options.
TextTableQueryResultWriter.TextTableQueryResultWriterFactory
TextTabularOutput	Utility class to wrap a DataExporter so column widths can be computed on-the-fly by buffering first 1000 results and inspecting values.
ThreadDump	A convenience class for getting a thread dump.
TimeoutCancelCheck	A cancellation check that cancels automatically if a timeout has been reached or delegates to another check timeout has not occurred.
Timer	Class used to keep track how much time is spent for a specific operation.
Timers
Token	Individual string in a Document
TopThresholdSelector	Selects the top scoring ranks, given that their score is above the threshold
ToStringComparator<T>
TransformingLongIterator<T>	Transforms an object iterator to a long iterator.
TransformingRDFHandler	RDFHandler that will transform staements before passing them to a delegate
TrigParser	Parser for TriG
TrigParserWithRules	Extended TrigParser which includes support for embedded rules.
TrigWriter
TrigWriter.TrigWriterFactory	Factory for TrigWriter
Tuple	A simple Tuple object.
TupleQueryResultIterator	Adapter for SelectQueryResult objects to Iterator
TuplesAsPathQueryResult	A wrapper around tuples with delimiters to restore paths.
TurtleParser	Default parser for the Turtle RDF syntax
TurtleParserContext	A small extension of IOParserContext to maintain the state related to edge property parsing.
TurtleUtil	Utility methods for Turtle encoding/decoding.
TurtleValueParser	A Turtle parser that parses single values (URI, bnodes, literals, and embedded triples) instead of just triples.
TurtleValueWriter	An Turtle writer that writes single values (URI, bnodes, literals) instead of triples.
TurtleWriter	Default implementation of a writer for Turtle
TurtleWriter.TurtleWriterFactory	Factory for creating TurtleWriter
TxInfo	A simple structure that shows information about a transaction.
UnknownQuery
UnsafeUtil
UpdatablePriorityQueue<T>	PriorityQueue class implemented as a binary heap with the additional function that updates the head element if its priority changes.
UpdateQuery	A SPARQL Update query
UpdateQuery	A query that will update a semantic graph
UserManager	API for managing users in Stardog.
ValidationReporter	Interface to generate a SHACL validation report.
Validator	Validator for ServiceParameters instances
Value	Base type for a node in an RDF graph
Values	Utility functions for creating and working with RDF values
ValueWeigher<K>	Implementation of the Guava cache Weigher interface which will calculate the weight for a Value based on how much space is takes in memory.
VCard	Constants for the VCard ontology
Version
View<Input,Output>	Function which supports a polymorphic view of one class as another
View.ViewException	Exception to indicate the reason a view failed.
Views<Input>
VirtualGraph	Information about a virtual graph.
VirtualGraphAdminConnection	Connection to manage data sources and virtual graphs
VirtualGraphAdminConnection.InputFileType
VirtualGraphInfo	Information about a virtual graph.
VirtualGraphMappingSyntax	Enumeration of syntax types supported for virtual graph mappings.
VirtualGraphOptions	Options used by virtual graphs.
VoiD	Constants for the VoiD ontology
WaldoCandidateGenerator	Uses Waldo to search for entities that match with the mention.
WGS	Terms in the WGS ontology
WordWrapStringColumn	A simple extension of StringColumn class that fixes the bug in calculating the max row height when word wrapping introduces new lines.
WriterOptions	Options to control the RDF writing process
WritingFailed	Indicates that there was an unexpected failure while writing
XMLCalendar	Read-only access interface to underlying calendar value
XMLCalendar.Delegate
XMLDatatypes	Utility for XML schema datatypes
XMLDateTime	This class provides utility functions for comparisons operating on xml:dateTime datatypes as specified in W3C, XML Schema Part 2: Datatypes Second Edition Known deviations from the standard: - the range of years in this implementation is limited to Integer.MIN_VALUE to Integer.MAX_VALUE for practical reasons - this implementation accepts some dates that have impossible month, day-of-month combinations (such as 2005-02-29, which was not a leap year)
XMLSchemaDatatypeHandler	An implementation of a datatype handler that can process XSD datatypes.
XMLWriter	A utility class offering convenience methods for writing XML.
XSD	Constants for XML Schema datatypes.