All Classes and Interfaces
Class
Description
Tools to abort and re-play new one-way (Asynchronous) transactions
An abstract implementation of a
QueryListener that batches up multiple events
and sends them to the concrete implementation.Root level of client to server connection related events which are dispatched to
ConnectionListeners.The base type for publisher events dispatched as a result of events published to the server.
A convenience implementation of
PublisherListener that can be extended
and the specified methods can be overridden.The base type for query events dispatched from server queries to
QueryListeners.A convenience implementation of
QueryListener that can be extended
and the specified methods can be overridden.Base abstract class for TupleEvents
A convenience class which implements all of the methods of
TupleMaker in terms of
AbstractTupleMaker.createTuple(Schema, Object).Interface describes the admin commands that pass from the
client to the stream base server.
Simple factory class for creating Admin objects.
Administration tools to support unit testing
represent a Heap-based aggregate window
(For backward compat, we can't call this HeapAggregateWindow, hence have to settle with AggregateWindow)
This class provides access to LiveView alert related functionality.
Represents an alert rule suitable for residing in a TIBCO Live Datamart server.
Gets the type of alert, currently 2 types are supported: Cron Alert and Query Alert
Represents an alert rule action suitable for residing in a TIBCO Live Datamart server.
Gets the type of the action, with a readable form.
Module (aka application) validation exception
An artifact loaded in the cluster.
Container for the metadata used to register for an artifact.
Artifact exception.
Container for message information
Message severity
Operators implement this interface to receive notifications about the artifacts used
by the operator.
This represents one assignment to either a Field or a Variable.
Abstract base class for all custom java aggregate functions.
The base class for the StreamBaseClient & StreamBaseAdminClient classes
A default implementation of
SBTestEnvironment for use
by SBServerManager instances.The event dispatched after which the aggregate result set may be in flux.
The event dispatched when a query delete begins.
The event dispatched when a query snapshot begins.
This class represents a StreamBase blob.
Represents tasks (possibly to run in the future) that can be cancelled.
Determines the method StreamBase will use to expose capture fields to client code
or dequeuers.
The Interface provides methods to kill Queries, Publishers and Sessions, as well as fetch the SessionID.
This class is used modify settings for
StreamBaseClient and StreamBaseAdminClient
clients.A class that captures the fields of tuples on the control stream relating to HA cluster notifications.
Subclass of tuple that indicates a tuple has a compiled representation for better performance.
Wraps
DataType with ancillary information about the type (where
appropriate) that's needed to actually use the DataType.Capture type
Function type
List type
Tuple type
Component notifier
A convenience implementation of
QueryListener that enables
notifications of zero or more listeners.HOCON Configuration tools to support unit testing
A property descriptor for use by a String-typed Java Operator or Adapter property, for
cases that wish to present to the user a chooser (typically a combo box) that allows
identifying some data out of the server configuration file's adapter-configurations area.
Configuration exception
Event dispatched when a
LiveViewConnection closes.Connection configuration used to connect to LiveView server.
A connection listener interface that can be provided to
ConnectionConfig to receive
connection related events on.Used when creating a
MultiConnectionConfig to define how it will connect to the servers.This interface is used to track connection lifecycle events.
Useful constants describing entities in the system container
status of a container sent on the control stream as container events
A Java annotation that can be used on a method, M, that implements a
StreamBase Java custom function.
Helps to describe the details of import process.
Enum for possible STATUS for data import process.
An enumeration that represents the types that StreamBase supports.
Validate types against registered types
Tools to detect deadlocks
Represents information about a single decision table in a StreamBase application.
Container for the metadata used to register for an artifact.
A Convenience implementation of
QueryListener that provides a pull based iterator pattern for iterating over snapshot queries.This is a StreamBaseClient that is intended for use by several independent queries.
Implement this interface to get calls back with data when using a DeMUXStreamBaseClient
A Dequeuer is used for dequeueing tuples from a specific stream.
Encapsulates the data returned from a dequeue() operation.
A callback interface that can be implemented by an object that is associated with
a StreamBaseClient and which gets used in the course of dequeuing tuples.
Direct byte array view into data
DynamicTableState keeps track of table state while dropping or starting table in synchronous mode.
The event dispatched when the aggregate result set sent since the last BeginAggMarkEvent
is consistent and will not change again until the next BeginAggMarkEvent.
The event dispatched when a query delete ends.
The event dispatched when a query snapshot ends.
An Enqueuer is used for enqueueing tuples onto a stream.
An enumeration that represents the kinds of entities that StreamBase
supports.
PropertyDescriptor for properties that reflect one of a fixed set of String
values.
An action that will execute a java action on the server.
An action to execute an OS Command.
Subclass this and override isExpected(Tuple t) to simplify creating predicates.
Dequeue settings
To expect tuples by predicate, implement this interface.
FeedSim can be configured to use classes that extend this abstract class.
FeedSim can be configured to use classes that extend this abstract class.
A
TupleComparator that compares tuples in a naive field-by-field manner.A strategy object for handling comparisons of specific field types.
Compare double values using a ratio test and a tolerance.
Ignore timestamp compare functor
List compare functor
Simple object compare functor
Check if the second argument matches the regex defined for the first argument.
Tuple compare functor
A FieldRule is a list of cases that will be evaluated on every insert or update.
This class represents the filtered-table-alias entries in an LVConf file.
Represents a value of type StreamBase Function.
Interface describes the admin commands that pass from the
client to the stream base server.
HashableTuple is a wrapper for Tuples from a single Query so they can be stored in a HashSet.
Property descriptor subclass which allows adapter BeanInfo classes to access
generic HOCON configuration data (for example, JDBC data sources -
com.tibco.ep.streambase.configuration.jdbcdatasource).
Type of HOCON configuration to use.
Deprecated.
Interface for input adapters.
Illegal function in projection exception
Convenience abstract base class for input adapters.
Causes a rest request to be sent when this alert is triggered.
Interface for output adapters.
Issues a Delete Query
A class supporting input to output tuple data transfer
A class to perform additional tuple initialization from input to output
PropertyDescriptor for properties based on a Java Enum.
PropertyDescriptor for String properties that wish to provide a chooser to the user in order
to select a Java class or interface name in the current Studio project's Build Path.
Studio will display a Java Type chooser dialog for the
JavaTypePropertyDescriptor.TypeChoice provided to this property descriptorJson string key constants
For Stat schema v3.
KeyValue represents a specific value of the primary key, as taken from the Tuple in a specific Table,
including if the Table has a complex key involving multiple fields.
Tools to detect manage object leaks
A live result is a
QueryListener the receives and maintains a local copy of tuples.Auth methods for LiveViewConnections.
Private interface.
Base class for basic authentication.
Private API
Base class for bearer token authentication.
Private API
Enumerates certain capabilities that may be supported by a LiveView Client.
A client connection to a LiveView server.
Exception throws when the LiveView connection call is cancelled by the client
When using a LiveViewMultiConnection, this represents one of the connections.
The status of this connection
A factory for retrieving a
LiveViewConnection based on ConnectionConfig
A connection can also be retrieved by provide a simple String based URI.An exception thrown by the LiveView Server
Enumeration of possible LiveView exceptions.
Interface representing a connection to a pool of servers (retrieved via
LiveViewConnectionFactory.getConnection(MultiConnectionConfig, boolean).)
Note that while this is a LiveViewConnection, some operations of that interface will fail with an appropriate error code
LiveViewExceptionType.NOT_SUPPORTED_IN_MULTISERVER.Class that defines LiveView permissions.
Enumerates the query languages that are supported by a table
Specific LiveViewException thrown when query syntax error occurs
The type of queries that can be specified in QueryConfig
An abstract class for objects that represent a capability of a LiveView server.
Server supports special punctuation that allows for guaranteed synchronicity
between aggregate queries.
Enumerates certain capabilities that may be supported by a table.
An action to publish to Liveview tables
A single error or status message
Represents information about a parallel module in a StreamBase Server.
Information about a Queue between modules or containers.
Implement this interface in order to receive the information produced by a
StreamBaseMonitor object.
Used to define a
LiveViewMultiConnection.Register your implementation of this interface if you want to be informed of all the events involved in multi-connect
When implmenting MultiConnectionListener, if you extend this base class you'll have version protection.
Tools to allow tests to run in-step on multiple nodes
Multi node exception
Node notifier to keep track of nodes in the cluster
A node
Multi-node worker
Exception thrown when a network error/problem occurs
Thrown by
LiveViewConnection.getCapability(Class) when a connected
server does not support a particular capability.Signals that some feature has not yet been implemented.
Signals that some feature is not supported
See
com.streambase.sb.expr.op.CNowOp in the server code
for details on using these valuesAn exception that is thrown when a field value is requested as a primitive
(e.g., Tuple.getBoolean(), Tuple.getTimestamp()), but it is null.
A factory to build
Tuples from Java objects.Abstract base class for User code that is used as a Java Operator or an
embedded Adapter in a StreamBase application.
For operators supporting Artifacts, this class is used to communicate properties
about them during development in Studio, and is reported to the operator
immediately prior to
Operator.typecheck() along with all other setters.Provides access to configuration information for use by operators and adapters, available
from the server's configuration file.
An enumeration for the different kinds of icons that StreamBase Studio
may request when displaying Operators and Adapters.
Included values are, in decreasing order of chattiness:
Operator.LogLevel.ALL, Operator.LogLevel.TRACE, Operator.LogLevel.DEBUG, Operator.LogLevel.INFO,
Operator.LogLevel.WARN, Operator.LogLevel.ERROR, Operator.LogLevel.OFF.The set of runtime states that an Operator can be in.
This interface is used to gain access to StreamBase Server information and
facilities.
A SharedObject is an object that can be shared between Operators within
a Container.
The state of the SharedObject
The manager for SharedObjects within a container.
Suspend behavior defines how an Operator handles tuples when it is
suspended; meaning when it is in the
SUSPENDED state.Manages an operator's artifacts.
Represents information about a single operator in a StreamBase application.
OrderDefinition is the object used to define the order in which you wish to receive data
The direction enum defines the legal directions available, and a reverse helper method.
Convenience abstract base class for output adapters.
Output schema builder
Parameter interpretation exception
Interface for the objects that hold the user-configurable parameters for
Java Operators when they appear in StreamBase Studio.
For use denoting the ParseStyle for tuple/JSON processing.
Parsing exception
A class to hold some hacks for different platforms.
A record type to describe the number of input and output ports
an operator has.
A query that has been prepared against a table.
Internal progress of administrative commands
This interface can be used in
ConnectionConfig to receive feedback on LiveViewConnectionFactory.getConnection(ConnectionConfig).Exception thrown when a protocol error/problem occurs
Adds an alert to the LVAlerts table
The event dispatched when a new publisher status is available.
Use this annotation to mark static methods as "purely functional" methods for use in StreamBase expressions.
A handle to a registered query.
Event dispatched to a listener when a query is closed
QueryConfig is the builder object used to configure a query.
The event dispatched when a query exception occurs.
A query listener interface must be provided when registering a query.
This class is used by LiveViewMultiConnectionImpl to wrap BOTH the queryListener that the
user passes in to an execQuery, AND the Query that is passed back to him.
PropertyDescriptor for properties wishing to access external resources at runtime.
Thrown when an operator tries to get a resource by name, but no
such resource exists.
Result from an administration command
Interface for consumers of table rows.
A RuleCase represents one case for a FieldRule, with a test, a list of assignments for
an insert operation, and a list of assignments for an update operation.
BeanInfos of StreamBase adapters should consider implementing this interface to gain better handling of property
errors.
A property descriptor that allows a user to define a property that
supports StreamBase expressions.
A Java annotation to be used on the getter method associated with a
SBExpressionPropertyDescriptor whose type is "non-simple" (e.g., a
list or tuple type).PropertyDescriptor subclass used by StreamBase operators and adapters
to describe a property.
This abstract specialization of Setter assumes that the
property type will have a single value (which currently
accounts for all property types except string lists).
SBServerManager provides control and access to a StreamBase Engine.SimpleBeanInfo subclass used by StreamBase operators and adapters to provide
the set of properties available by the operator or adapter.
This interface is not expected to be implemented by end-users.
Represents a StreamBase schema as a list of
Schema.Fields, and should be used
to create Tuple objects.Information (name, type, and optionally size) about a field in a Schema.
A placeholder interface to add a bit of type safety to the get/setTupleClassInfo methods.
A schema mismatch happened
Coercion options
Options used when copying Schemas
A SemanticValidationException that also stores the index of the schema that caused it,
when we're computing merges of schemas.
A schema provider
a class that can be used to traverse all nested schemas in a schema
Exception to indicate validation failures
Semantic validation exception
Causes an email to be sent when this alert is triggered.
An action which will send a Tuple to a named InputStream
Contains static methods for creating concrete
SBServerManagerThe Interface provides methods to fetch server utility data
Enum for specifying the policy that should be used for importing LiveView metadata.
A simple concrete implementation of DequeueResult, primarily intended for use by implementors of
DequeueResult.Interceptor to allow them to construct an alternative DequeueResult.
Stores a snapshot of information from a StreamBase application.
Result source
Read result status
A Convenience implementation of
QueryListener that provides a pull based iterator pattern for iterating over snapshot queries.A blocking iterator pattern for retrieving
snapshot only results.
This class manages the identity in client
This class manages the identity in server
Represents a single stats tuple, which is stored by a snapshot.
Data storage method
This class is used to send administrative commands to the StreamBase Server
Valid arguments for the listConnection command
A client used to subscribe to StreamBase streams and to send commands
to the StreamBase Server.
Flags used by the ListEntities call.
The base class of all StreamBase non-runtime exceptions.
A StreamBase wrapper for IllegalArgumentException for use by methods that want
to throw IAE in a kind of cleaner fashion.
An exception that contains a list of exceptions
Monitors a StreamBase Server, and gathers statistics.
The base class of all StreamBase runtime exceptions.
Data holder for a list of input streams and a list of output streams.
A Uniform Resource Identifier containing information necessary
to connect to a StreamBase server.
Represents information about a stream in a StreamBase Server.
This class contains meta data about a stream.
Advanced Java Operator Studio integration - allows a Java Operator to display a schema field picker for
String[] properties.Maintain information about a subscription
Represents system-level information.
Information about GC collectors in the JVM
An instance of a LiveView table.
ENUM for table groups.
A handle for accessing a table.
TableAdminManager is used to start and stop tables and table providers on the server.
Utility methods for working with the TableProviderAPI
TableConfig is used to configure all properties of the table under construction.
Create an instance of this if you want to be informed of changes to the Table List.
This class contains the table name selector and remapping information that was declared in the LVConf or the Service Call
TablePropertiesConfigurationWrapper is used as a place holder for remapped name against the original table name and a list of
TablePropertiesConfigurationWrapper.FilterdAlias.Implement this interface to add a custom TableProvider to LiveView.
When implementing a TableProvider, you should hold on to the TableProviderControl that is passed to you
in your initialize method.
This contains the arguments that were passed to your Table in the LVConf or the Web Service
Constants representing different status of a TableProvider.
An instance of a publisher for publishing tuples into a table.
Represents information about a single thread in a StreamBase Server.
Tools to abort long running test and call a node snapshot
This interface defines a contract that enables users to provide custom implementations of time used by StreamBase server
It must be implemented by all Time Service classes.
Contains static methods for creating concrete
TimeServiceThis class represents a Streambase Timestamp.
For use denoting timestamps objects between timestamp and interval types.
Timetamp to string cache
Deadlock detected exception
A transactional memory aggregate window
Transactional memory leak exception
This describes the server's transaction isolation level
(only meaningful for com.streambase.sb.operator.StorageMethod.TRANSACTIONAL_MEMORY)
An class that represents a Tuple of StreamBase data.
A default formatter that converts each type to String using Java
default String conversions.
An interface containing flags returned from certain setXXXX calls
This interface is not public API, and should not be implemented by users.
The event dispatched when a new Tuple is added to a query result.
A TupleCaptureTransformer represents a way of converting tuples with capture
fields from inside the application to tuples without capture fields, with
all of the fields stored in the capture expanded out to the same level
as the capture field itself.
A
TupleComparator abstracts comparison of tuples.Tuple connections
A utility class which copies the fields from one tuple to another.
Options for this TupleCopier
Tuple manipulation error
Utilities for dealing with tuples represented in JSON format.
Options for serializing JSON.
The Builder class which handles the setting of tuples from JSON Data.
Interface for constructing tuples from data.
The event dispatched when an existing Tuple is removed.
A class that holds information about how the fields in a particular
schema are laid out in memory by TupleRep.
The event dispatched when an existing Tuple is updated.
DataType.Registry machinery for Tuple.serialize(), .getTupleLength()
May be thrown when an error occurs during an Operator's typecheck() method.
A
UIHints may be associated with a SBPropertyDescriptor in order
to provide the Studio environment with additional hints regarding how to display
a property.Used to request a font style for String-based properties
Used to request a particular width for text-field like controls (including but
not limited to text fields and combo/drop-downs).
UnitTest accessor functions
Unit test properties
Exception thrown when URI parsing fails.
Used to represent all errors in validating an object.
Variables can be used in both test and assignment expressions in the FieldRules.
Provides information about the StreamBase LiveView Client Library.
XML interpretation exception
XML parsing error
Connection tags