Apama Documentation
About the Apama Version 10.0 Documentation
Documentation roadmap
Online Information
Contacting customer support
Release Notes
Overview
License Terms and Technical Restrictions
What's New In Apama 10.0
New HTTP client transport connectivity plug-in
Apama integration with MQTT in 10.0
Apama integration with Kafka in 10.0
Connectivity plug-ins enhancements in 10.0
New API for writing EPL plug-ins in C++ in 10.0
Apama enhancements in Software AG Designer 10.0
Query enhancements in 10.0
EPL enhancements in 10.0
Correlator utility enhancements in 10.0
Dashboard enhancements in 10.0
Miscellaneous enhancements and changes in 10.0
Platform changes in 10.0
Windows compiler update in 10.0
Miscellaneous changes in 10.0 affecting backwards compatibility
Removed and deprecated features in 10.0
What's New In Apama 9.12
Apama integration with Software AG Digital Event Services in 9.12
Apama integration with Universal Messaging in 9.12
New optional type in 9.12
New Microsoft Edge support in 9.12
Connectivity plug-ins enhancements in 9.12
Connectivity API changes in 9.12.0.1
Apama enhancements in Software AG Designer 9.12
Query enhancements in 9.12
EPL enhancements in 9.12
Correlator utility enhancements in 9.12
Dashboard enhancements in 9.12
PySys enhancements in 9.12
Command Central support in 9.12
Miscellaneous enhancements and changes in 9.12
Platform changes in 9.12
Miscellaneous changes in 9.12 affecting backwards compatibility
Removed and deprecated features in 9.12
What's New In Apama 9.10
New connectivity plug-ins feature in 9.10
New query and DataView metadata feature in 9.10
New EPL memory profiler feature in 9.10
New EPL code coverage feature in 9.10
New PySys version in 9.10
New dashboard server HTTP REST support in 9.10
New JSON-based REST support in 9.10
Command Central support in 9.10
Apama enhancements in Software AG Designer 9.10
EPL enhancements in 9.10
Correlator utility enhancements in 9.10
Dashboard enhancements in 9.10
Miscellaneous enhancements and changes in 9.10
Platform changes in 9.10
Supported JDK version in 9.10
Miscellaneous changes in 9.10 affecting backwards compatibility
Removed and deprecated features in 9.10
What's New In Apama 9.9
Installation changes in 9.9
Query enhancements in 9.9
Apama enhancements in Software AG Designer 9.9
EPL enhancements in 9.9
Correlator utility enhancements in 9.9
Dashboard enhancements in 9.9
Miscellaneous enhancements and changes in 9.9
New samples in 9.9 showing how to containerize Apama for Docker (Linux only)
Platform changes in 9.9
Renaming of Apama client libraries in 9.9
Miscellaneous changes in 9.9 affecting backwards compatibility
Removed and deprecated features in 9.9
What's New In Apama 5.3
New Apama queries capability
Apama Studio enhancements in 5.3
Log rotation enhancements in 5.3
EPL enhancements in 5.3
Correlator-integrated messaging for JMS enhancements in 5.3
Dashboard enhancements in 5.3
Killing an object now requires specification of a monitor name
New sample project showing how to manage Universal Messaging DataGroups
C++ and C Correlator plug-in API enhancements
Miscellaneous enhancements and changes in 5.3
Platform changes in 5.3
JDK 7 now minimum JDK version supported
Removed and deprecated features in 5.3
Backwards incompatibility with persisted projects recovered to 5.3 from older versions
What's New in Apama 5.2
Apama Studio enhancements in 5.2
New feature for addressing contexts with channels in 5.2
New feature for using Universal Messaging to connect Apama components in 5.2
New and changed EPL statements in 5.2
Enhancements to Apama adapters in 5.2
Changes to correlator utilities in 5.2
Windows compiler and .NET version updates in 5.2
Linux compiler updates in 5.2
Upgrading to Apama-supplied JDBC and ODBC database drivers in 5.2
Removed and deprecated features in 5.2
Miscellaneous enhancements and changes in 5.2
What's New in Apama 5.1.1
What's New in Apama 5.1
New distributed MemoryStore
New EPL exception handling mechanism
New support for managing and monitoring with REST APIs
New support for creating correlator plug-ins using Java
New headless mode generation of ApamaDoc
New support for PySys test framework
Dashboard login redirect file name has changed
New EPL keywords
Miscellaneous enhancements in 5.1
Support removed from Apama 5.1
Migrating Apama applications
Installing Apama
Overview
Before You Start the Installation
About the Apama installation process
Prerequisites
Installing Apama
Running the Software AG Installer
After the installation
Post-installation considerations for Linux users
Installing the latest fixes
Installing Apama using Command Central
Removing the Installation
Running the Software AG Uninstaller
Introduction to Apama
Overview
Apama Overview
What is Apama?
Understanding the different user viewpoints
About Apama license files
Running Apama without a license file
Software AG Knowledge Center
Apama Architecture
Distinguishing architectural features
How Apama integrates with external data sources
Descriptions of Apama components
Description of the Apama correlator
Description of event processing languages
Introduction to Apama EPL
Introduction to Apama in-process API for Java (JMon)
Description of Software AG Designer
Description of Query Designer
Description of Dashboard Builder and Dashboard Viewer
Description of client development kits
Description of Apama's Data Player
How the correlator works
Apama Concepts
Event-driven programming
Complex event processing
Understanding monitors and listeners
Understanding queries
Architectural comparison of queries and monitors
Understanding dashboards
Getting Ready to Develop Apama Applications
Becoming familiar with Apama
Introduction to Software AG Designer
Steps for developing Apama applications
Overview of starting, testing and debugging applications
Apama Glossary
action
activation
adapter
aggregate function
batch
bundle
.cdp
CEP
channel
connectivity plug-in
context
correlator
correlator deployment package
correlator-integrated messaging for JMS
.csv
current events
custom blocks
dashboard
Dashboard Builder
dashboard data server
dashboard display server
Dashboard Viewer
Data Player
data view
EDA
EPL
EPL plug-in
event
event collection
event listener
event pattern
event template
.evt
exception
IAF
Integration Adapter Framework (IAF)
JMon
latest event
listener
lot
match set
MemoryStore
.mon
monitor
MonitorScript
optional
parameterization
parameters
partition
partitioning
.qry
query
query aggregate
Query Designer
query input definition
query instance
query key
query window
range
.rtv
simulation
Software AG Designer
stack trace element
static action
stream
stream listener
stream network
stream query
stream source template
Web Services Client adapter
window
within clause
without clause
Using Apama with Software AG Designer
Overview of Developing Apama Applications
Starting Software AG Designer
Demos and tutorials
The Apama interface
The Apama Workbench perspective
Workbench Project view
The Apama Developer perspective
Project Explorer view
The Apama Runtime perspective
About Apama projects
Managing project hierarchies
Editors
Outline view
Scenario Browser view
Engine Receive view
Engine Status view
Engine Information view
Console view
Problems view
Data Player Control view
Building Apama projects
Launching Apama projects
Working with Projects
Creating Apama projects
Adding resources to Apama projects
Creating new monitor files for EPL applications
Creating new event definition files for EPL applications
Creating event definitions by adding EPL code
Creating event definitions from XML files
Creating event definitions from XSD files
Creating new files for JMon applications
Adding a new JMon application
Adding a JMon monitor
Adding a JMon event
Adding an EPL Plug-in written in Java
Creating new scenarios
Creating new blocks
Creating a block with the block editor
Creating a block from an EPL event definition
Adding EPL code to a block
Creating new scenario functions
Creating new dashboards
Creating new dashboard-deployment configurations
Creating new event files
Event Type Selection
Adding resources to EPL projects
Adding resources to JMon projects
Java Configuration Editor
Adding JMon applications
Adding JMon classes
Adding non-JMon Java files
Adding bundles to projects
Bundle instances
Adding adapters to projects
Connectivity bundles
Linked Resources
Using the Digital Event Services connectivity bundle
Adding the Universal Messaging connectivity plug-in to a project
Adding the MQTT connectivity plug-in to a project
Adding the HTTP client connectivity plug-in to a project
Adding Universal Messaging configuration to projects
Editing Apama files
Obtaining content assistance
Using auto-completion
Displaying information for events and actions
Specifying comments
Using auto-indent
Using auto-bracketing
Using tabs
Defining shorthand (templates) for frequently used EPL code
Sharing templates among Software AG Designer installations
Specifying colors to distinguish EPL elements
Shortcuts when editing Apama files
Navigating in Apama files
Using the Outline view to navigate
Using the Quick Outline to navigate
Jumping to an event or action definition or variable declaration
Opening EPL elements and Java classes using the Open Type dialog
Searching in EPL files
Search tab
Building Apama projects
Build automatically when a resource changes
Build all Apama projects
Build one Apama project
Build a working set
Clean and rebuild projects
Configuring the project build path
Project source files
Specifying projects
Specifying external dependencies
Specifying dependencies for a single-user project
Specifying dependencies for a multi-user project
Specifying the project bundles properties
Defining MonitorScript Build Path variables
Importing projects
Importing adapter configurations
Setting up the environment before importing projects
Exporting project information
Exporting a project initialization file list
Exporting to a deployment script
Exporting scenarios as block templates
Exporting scenarios as EPL
Exporting correlator deployment packages
Exporting adapter configurations
Exporting ApamaDoc
Deleting projects and resources
Deleting resources
Deleting projects
Adding the Apama nature to a project
Adding the Java nature to an Apama project
Viewing all EPL objects in all projects
Internationalizing Apama applications
Checking the error log
Specifying an adapter configuration in a launch configuration
Using Software AG Designer to configure adapters that use Universal Messaging
Using Query Designer
Adding query files to projects
Steps for using Software AG Designer to implement queries
Overview of creating a query in the Design tab
Creating queries in Query Designer
Configuring a query
Adding query inputs
Adding query patterns
Adding query parameters
Adding query conditions
Adding query condition filters (where)
Adding query time constraints (within)
Adding query exclusions (without)
Adding query aggregates
Adding query aggregate calculations
Adding query aggregate filters
Adding query actions
Adding query send event actions
Adding query custom EPL actions
Specifying a time period in Query Designer
Editing source code in Query Designer
Errors in query definitions
Enabling diagnostic logging
Configuring query projects
Exporting query deployment scripts
Launching Projects
Running Apama projects
Default launch configuration
Workbench perspective
Developer perspective
Defining custom launch configurations
Adding a correlator
Correlator arguments
Persistence options
Connectivity
Injections
Event Files
Configuring correlator log settings in Designer
Connecting correlators
Adding an external process
Testing a subset of your apama application
Monitoring Apama applications
Console view
Using the Engine Information view
Using the Engine Receive view
Engine Receive Viewer preferences
Specifying channels for the Engine Receive View
Using the Engine Status view
Using the Scenario Browser view
Displaying the Scenario Browser
Browsing scenarios and query definitions
Creating a new instance of a scenario or a parameterized query
Viewing the instances of a scenario or a query
Editing an instance of a scenario or a parameterized query
Deleting an instance of a scenario or a parameterized query
Deleting all instances of a scenario or a parameterized query
Dashboards
Debugging EPL Applications
Adding breakpoints
Launching a debug session
Creating a debug configuration
Debugging a remote application
Debug view for an EPL application
Breakpoints view for an EPL application
Variables view for an EPL application
Command-line debugger
Debugging JMon Applications
Preparing the correlator for remote debugging
Creating a debug run configuration
Debug perspective
Using the Debug view with a JMon application
Working with breakpoints in a JMon application
Viewing stack frame variables for a JMon application
Example debug session
Debug example of preparing code and JAR file
Debug example of starting correlator and injecting application
Example of debugging in Software AG Designer
Additional resources for Java debugging
Profiling EPL Applications
Launching profiling sessions
Launching a default profiling session
Launching a custom profiling session
Creating a custom profile launch configuration
Correlator Profile Configurations
Launching a remote profiling session
Creating a remote profiler launch configuration
The Apama Profiler perspective
Profiling Monitor view
Execution Statistics view
The Execution Statistics tab
Comparison of Execution Statistics tab
Viewing EPL code
Using filters
Creating a Filter
Managing Filters
Taking snapshots
Using snapshots
Choosing profiling information columns
Updating profile data
Displaying Apama perspective preferences
Using the Data Player
Introduction to the Data Player
Using the Data Player
Adding the ADBC adapter
Launching the project
Specifying Data Player playback queries
Data Player Control view
Playback settings
Playback controls
Playback status
Creating Data Player query templates
Command-line Data Player interface
Setting the Apama Preferences
Showing the Apama-specific preferences
Apama
Catalogs
Connectivity and Adapters
Web Service
MonitorScript
Editor Colors
Editor Formatting
Editor Templates
MonitorScript Path Variables
Profiling and Logging
Query
Syntax Coloring
Scenarios
Workbench
Developing Apama Applications
Overview
Developing Apama Applications in EPL
Getting Started with Apama EPL
Introduction to Apama Event Processing Language
How EPL applications compare to applications in other languages
About dynamic compilation in the correlator
About the Apama development environment in Software AG Designer
Terminology
Defining event types
Allowable event field types
Format for defining event types
Example event type definition
Working with events
Making event type definitions available to monitors and queries
Channels and input events
Defining Monitors
About monitor contents
Loading monitors into the correlator
Terminating monitors
Unloading monitors from the correlator
Example of a simple monitor
Spawning monitor instances
How spawning works
Sample code for spawning
Terminating monitor instances
About executing ondie() actions
Specifying parameters when spawning
Communication among monitor instances
Organizing behavior into monitors
Event processing order for monitors
Allocating events in monitors
Sending events to other monitors
Defining your application's message exchange protocol
Using events to control processing
About service monitors
Adding predefined annotations
Subscribing to channels
About the default channel
About wildcard channels
Adding service monitor bundles to your project
Utilities for operating on monitors
Defining Queries
Introduction to queries
Example of a query
Use cases for queries
Delayed and out of order events
Query terminology
Overview of query processing
Overview of query application components
Format of query definitions
Defining metadata in a query
Partitioning queries
Defining query keys
Defining actions as query keys
Query partition example with one input
Query partition example with multiple inputs
About keys that have more than one field
Defining query input
Format of input definitions
Behavior when there is more than one input
Specifying event duration in windows
Using the output of another query as query input
Specifying maximum number of events in windows
Specifying event duration and maximum number of events
Using source timestamps of events
Using heartbeat events with source timestamps
Out of order events
Matching only the latest event for a given field
Finding and acting on event patterns
Defining event patterns
Query followed-by operator
Query and operator
Query or operator
Query wait operator
Query conditions
Query condition ranges
Special behavior of the and operator
Aggregating event field values
Event matching policy
Acting on pattern matches
Defining actions in queries
Implementing parameterized queries
Parameterized queries as templates
Using the Scenario Service to manage parameterized queries
Referring to parameters in queries
Scaling and performance of parameterized queries
Restrictions in queries
Best practices for defining queries
Testing query execution
Communication between monitors and queries
Defining Event Listeners
About event expressions and event templates
Specifying the on statement
Using a stream source template to find events of interest
Defining event expressions with one event template
Listening for one event
Listening for all events of a particular type
Listening for events with particular content
Using positional syntax to listen for events with particular content
Using name/value syntax to listen for events with particular content
Listening for events of different types
Terminating and changing event listeners
Specifying multiple event listeners
Listening for events that do not match
Specifying completion event listeners
Example using unmatched and completed
Improving performance by ignoring some fields in matching events
Defining event listeners for patterns of events
Specifying and/or/not logic in event listeners
Specifying the 'or' operator in event expressions
Specifying the 'and' operator in event expressions
Example event expressions using 'and/or' logic in event listeners
Specifying the 'not' operator in event expressions
Specifying 'and not' logic to terminate event listeners
Pausing event listeners
Choosing which action to execute
Specifying 'and not' logic to detect when events are missing
How the correlator executes event listeners
How the correlator evaluates event expressions
Avoiding event listeners that trigger upon instantiation
When the correlator terminates event listeners
How the correlator evaluates event listeners for a series of events
Evaluating event listeners for all A-events followed by B-events
Evaluating event listeners for an A-event followed by all B-events
Evaluating event listeners for all A-events followed by all B-events
Defining event listeners with temporal constraints
Listening for event patterns within a set time
Waiting within an event listener
Triggering event listeners at specific times
Using variables to specify times
Understanding time in the correlator
Correlator timestamps and real time
Event arrival time
About timers and their trigger times
Disabling the correlator's internal clock
Externally generating events that keep time (&TIME events)
About repeating timers and &TIME events
Setting the time in the correlator (&SETTIME event)
Out of band connection notifications
Working with Streams and Stream Queries
Introduction to streams and stream networks
Defining streams
Creating streams from event templates
Terminating streams
Using output from streams
Listener variables and streams
Coassigning to sequences in stream listeners
Defining stream queries
Linking stream queries together
Simple example of a stream network
Stream query definition syntax
Stream query processing flow
Specifying input streams in from clauses
Adding window definitions to from and join clauses
Window definition syntax
Defining time-based windows
Defining size-based windows
Combining time-based and size-based windows
Defining batched windows
Partitioning streams
Partitions and aggregate functions
Using multiple partition by expressions
Partitioning time-based windows
Defining content-dependent windows
Joining two streams
Defining cross-joins with two from clauses
Defining equi-joins with the join clause
Filtering items before projection
Generating query results
Aggregating items in projections
Filtering items in projections
IEEE special values in stream query expressions
Defining custom aggregate functions
Example of defining a custom aggregate function
Defining actions in custom aggregate functions
Overloading in custom aggregate functions
Distinguishing duplicate values in custom aggregate functions
Working with lots that contain multiple items
Stream queries that generate lots
Behavior of stream queries with lots
Size-based windows and lots
Join operations and lots
Grouped projections and lots
Stream network lifetime
Disconnection vs termination
Rules for termination of stream networks
Using dynamic expressions in stream queries
Behavior of static and dynamic expressions in stream queries
When to avoid dynamic expressions in stream queries
Ordering and side effects in stream queries
Understanding when the correlator evaluates particular expressions
Using dynamic expressions in windows
Using dynamic expressions in equi-joins
Using dynamic expressions in where predicates
Using dynamic expressions in projections
Examples of using dynamic expressions in stream queries
Example of altering query window size or period
Example of altering a threshold
Example of looking up values in a dictionary
Example of actions and methods in dynamic expressions
Troubleshooting and stream query coding guidelines
Prefer on statements to from statements
Know when to spawn and when to partition
Filter early to minimize resource usage
Avoid duplication of stream source template expressions
Avoid using large windows where possible
In some cases prefer retain all to a timed window
Prefer equi-joins to cross-joins
Be aware that time-based windows can empty
Be aware that fixed-size windows can overflow
Beware of accidental stream leaks
Defining What Happens When Matching Events Are Found
Using variables
Using global variables
Using local variables
Using variables in listener actions
Specifying named constant values
Defining actions
Format for defining actions
Invoking an action from another action
Specifying actions in event definitions
Using action type variables
Defining static actions
Getting the current time
Generating events
Generating events with the route command
Generating events with the send command
Sending events to com.apama.Channel objects
Generating events with the enqueue command
Enqueuing to contexts
Generating events to emit to outside receivers
Assigning values
Defining conditional logic with the if statement
Defining conditional logic with the ifpresent statement
Defining loops
Exception handling
Logging and printing
Specifying log statements
Log levels determine results of log statements
Where do log entries go?
Examples of using log statements
Strings in print and log statements
Sample financial application
Implementing Parallel Processing
Introduction to contexts
What is inside/outside a context?
About context properties
Context lifecycle
Comparison of a correlator and a context
Creating contexts
How many contexts can you create?
Using channels to communicate between contexts
Obtaining context references
Spawning to contexts
Channels and contexts
Sending an event to a channel
Sending an event to a particular context
Sending an event to a sequence of contexts
Common use cases for contexts
Samples for implementing contexts
Simple sample implementation of contexts
Running samples of common concurrency problems
About the samples of concurrency problems
About the race sample
About the deadlock sample
About the compareswap sample
Contexts and correlator determinism
How contexts affect other parts of your Apama application
About input logs and parallel processing
Deadlock avoidance when parallel processing
Clock ticks when parallel processing
Using EPL plug-ins in parallel processing applications
Using Correlator Persistence
Description of state that can be persistent
When persistence is useful
When non-persistent monitors are useful
How the correlator persists state
Enabling correlator persistence
How the correlator recovers state
Recovery order
Defining recovery actions
Simplest recovery use case
Designing applications for persistence-enabled correlators
Upgrading monitors in a persistence-enabled correlator
Sample code for persistence applications
Sample code for discarding stale state during recovery
Sample code for recovery behavior based on downtime duration
Sample code that recovers subscription to non-persistent monitor
Requesting snapshots
Developing persistence applications
Using EPL plug-ins when persistence is enabled
Using the MemoryStore when persistence is enabled
Comparison of correlator persistence with other persistence mechanisms
Restrictions on correlator persistence
Common EPL Patterns in Monitors
Contrasting using a dictionary with spawning
Translation using a dictionary
Translation using spawning
Factory pattern
Canonical factory pattern
Alternate factory pattern
Using quit() to terminate event listeners
Combining the dictionary and factory patterns
Testing uniqueness
Reference counting
Inline request-response pattern
Routing events for request-response behavior
Canonical form for synchronous requests
Writing echo monitors for debugging
Using EPL Plug-ins
Overhead of using plug-ins
When to use plug-ins
When not to use plug-ins
Using the TimeFormat Event Library
TimeFormat format functions
TimeFormat parse functions
Format specification for the TimeFormat functions
Using the MemoryStore
Introduction to using the MemoryStore
Overview of MemoryStore events
Adding the MemoryStore bundle to your project
Steps for using the MemoryStore
Preparing and opening stores
Description of row structures
Preparing and opening tables
Using transactions to manipulate rows
Determining which commit action to call
Creating and removing rows
Iterating over the rows in a table
Requesting persistence
Exposing in-memory or persistent data to dashboards
Restrictions affecting MemoryStore disk files
Using the distributed MemoryStore
Overview of the distributed MemoryStore
Distributed store transactional and data safety guarantees
Using a distributed store
Configuring a distributed store
Adding distributed MemoryStore support to a project
Adding a distributed store
Configuring a distributed store
Launching a project that uses a distributed store
Interacting with a distributed store
Configuration files for distributed stores
BigMemory Max driver specific details
Changing bean property values when deploying projects
Creating a distributed MemoryStore driver
Using the Management interface
Using MATLAB® products in an application
MatlabManager actions
MATLAB examples
Interfacing with user-defined EPL plug-ins
About the chunk type
Making Application Data Available to Clients
Adding the DataView Service bundle to your project
Creating DataView definitions
Deleting DataView definitions
Creating DataView items
Deleting DataView items
Updating DataView items
Looking up field positions
Using multiple correlators
Testing and Tuning EPL monitors
Optimizing EPL programs
Best practices for writing EPL
Wildcard fields that are not relevant
Avoiding unnecessary allocations
Implementing states
Structure of a basic test framework
Using event files
Handling runtime errors
What happens
Using ondie() to diagnose runtime errors
Using logging to diagnose errors
Standard diagnostic log output
Capturing test output
Avoiding listeners and monitor instances that never terminate
Handling slow or blocked receivers
Diagnosing infinite loops in the correlator
Tuning contexts
Parallel processing for instances of an event type
Parallel processing for long-running calculations
Generating Documentation for Your EPL Code
Code constructs that are documented
Steps for using ApamaDoc
Inserting ApamaDoc comments
Inserting ApamaDoc tags
Inserting ApamaDoc references
Inserting EPL source code examples
Generating ApamaDoc from an Ant script
Developing Apama Applications in Event Modeler
Overview of Using Event Modeler
Event Modeler layout
About event flow states
How rules define scenario behavior
Description of rule conditions
Description of rule actions
Description of functions in rules
About rule evaluation
Basic view of rule processing
Expanded view of rule processing
Scenario monitoring stage
Summary of adding rules when a variable value changes
About scenario variables
Variable types
Auto-typing of variables
Variable properties
Variable constraints
User input and output
About blocks
Linking variables, block parameters, and block output fields
Using Event Modeler
Adding scenarios to projects
Creating the GlobalRuleExample project
Adding GlobalRuleExample.sdf to the GlobalRuleExample project
Adding a new scenario to the GlobalRuleExample project
Opening and viewing multiple scenarios
Selecting from the Scenario menu
The Event Modeler toolbar
Interacting with the tabs and panels
Working in the Event Flow panel
Interacting with states
Selecting a state
Resizing a state
Moving a state
Multiple selection
Adding a state
The finished status
Deleting a state
Labeling a state
Using cut/copy/paste with states
Interacting with transitions
Adding a transition
Selecting a transition
Changing end-points
Changing the shape of a transition
Labeling a transition
Deleting a transition
Using cut/copy/paste with transitions
Displaying global rule transitions
Working in the Rules panel
Adding a rule
About global rules
Selecting rules and rule elements
Re-ordering rules
Deleting a rule
Labeling a rule
Changing a rule's description
Minimizing and maximizing a rule
Cutting, copying, and pasting rules
Activating and deactivating rules
Specifying conditions
Interactive editing
Language elements
Selecting and replacing elements
Cascading alternative menus
Using functions in rules
Adding a condition to a rule
Specifying variable changes in conditions
Local rules and variable changes
Global rules and variable changes
Specifying actions
Adding action statements
Deleting action statements
Interactive editing
Using the keyboard to edit rules
Using the Variables tab
Adding a variable
Renaming a variable
Selecting a variable
Determining which states use a particular variable
Moving a variable
Deleting a variable
Changing a variable's properties
Setting a variable's value
Variable input and output
Linking a variable to a block output field
Conversion rules for variable types
Using the Catalogs tab
Adding a block template catalog
Selecting and inspecting a block template
Adding a block instance to the scenario
Using the Functions tab
Adding a function catalog
Selecting and inspecting a function
Using the Blocks tab
Interacting with a block instance
Selecting a parameter
Viewing a parameter's properties
Setting a parameter's initial value
Linking a parameter with a variable or output field
Switching blocks
Using the Block Wiring tab
Wiring block input feeds
Selecting, resizing, and moving block instances
Wiring two blocks together
Connecting feeds and specifying feed mapping
Wiring a scenario variable to a block
Mapping type conversions
Editing block wiring
Deleting a wiring
Deleting a block instance
Using older versions of blocks
Troubleshooting invalid scenarios
Event Modeler command line options
Using Standard Blocks
A block's lifecycle
General analytic blocks
Change Notifier v2.0
Correlation Calculator v2.0
Data Distribution Calculator v2.0
Median and Mode Calculator v1.0
Moving Average v1.0
Spread Calculator v3.0
Statistics Calculator v1.0
Velocity Calculator v2.0
The Timer blocks
Schedule v3.0
Wait v3.0
The Utility blocks
Dictionary v2.0
File Reader v2.0
File Writer v2.0
History Logger v2.0
Input Merger v2.0
List v2.0
Scenario Terminator v2.0
Status v2.0
Variable Mapper v2.0
Database functionality—storage and retrieval
ADBC Storage v1.0
ADBC Retrieval v1.0
Blocks for working with scenario blocks
Change Observer v2.0
Filtered Summary v2.0
Using Functions in Event Modeler
Reference information for provided functions
Date and time functions
Extended math functions on float types
IO functions
System value functions
Miscellaneous functions
About defining your own functions
Sample ABS function definition file
Sample function definition file with imports element
About function names
Creating Blocks
About blocks
Introduction to block definition files
Description of block interface elements
How scenarios communicate with their blocks
Defining new blocks in Software AG Designer
Specifying the block metadata
Specifying the block interface
Creating parallel-aware blocks
Adding EPL code to the block definition
Considerations for adding EPL code to the block definition
Details about EPL code that you can add
Timeliness of acknowledgements
An example block
Description of the Correlation Calculator block interface
Description of the Correlation Calculator block EPL
Working with Blocks Created from Scenarios
Terminology for using scenario blocks
Benefits of scenario blocks
Steps for using scenario blocks
Background for using scenario blocks
Saving scenarios as block templates
Incrementing scenario block version numbers
Adding a scenario block to a main scenario
Examining a scenario block's source scenario
Descriptions of scenario block parameters
Descriptions of scenario block operations
Descriptions of scenario block feeds
Setting parameters before creating sub-scenarios
Creating sub-scenarios
Deleting sub-scenarios
Unconditionally deleting a sub-scenario
Deleting all sub-scenarios
Modifying sub-scenario input variable values
Iterating through sub-scenarios
Obtaining variable values from sub-scenarios
Linking sub-scenarios with other blocks
Inheriting sub-scenarios
Description of inheritExternalInstances values
Notes for setting the inheritExternalInstances parameter
Example of inheriting sub-scenarios
Observing changes in sub-scenarios
Performing simple calculations across sub-scenarios
File Definition Formats
Function definition file format
Defining metadata in function definition files
Defining the version element
Defining the description element
Defining the imports element
Defining the parameters element
Defining EPL code in function definition files
Block definition file format
Block definition file DTD
Block definition file encodings
XML elements that define a block
Developing Apama Applications in Java
Overview of Apama JMon Applications
Introducing JMon API concepts
About event types
Simple example of an event type
Extended example of a JMon event type
Comparing JMon and EPL event type parameters
About event parameters that are complex types
Non-null values for non-primitive event field types
About monitors
About event listeners and match listeners
Example of a MatchListener
Defining multiple listeners
Removing listeners
Description of the flow of execution in JMon applications
Parallel processing in JMon applications
Overview of contexts in JMon applications
Using contexts in JMon applications
Using the Context class default constructor
Descriptions of methods on the Context class
Identifying external events
Optimizing event types
Wildcarding parameters in event types
Logging in JMon applications
Using EPL keywords as identifiers in JMon applications
Defining Event Expressions
About event templates
Specifying positional syntax
Specifying completed event templates
Specifying parameter constraints in event templates
Obtaining matching events
Emitting, routing, and enqueuing events
Specifying temporal sequencing
Chaining listeners
Using temporal operators
Defining advanced event expressions
Specifying other temporal operators
Specifying a perpetual listener for repeated matching
Deactivating a listener
Temporal contexts
Specifying the timer operators
Looking for event sequences within a set time
Waiting within a listener
Working with absolute time
Optimizing event expressions
Validation of event expressions
Concept of Time in the Correlator
Getting the current time
About timers and their trigger times
Developing and Deploying JMon Applications
Steps for developing JMon applications in Software AG Designer
Java prerequisites for using Apama's JMon API
Steps for developing JMon applications manually
Deploying JMon applications
Removing JMon applications from the correlator
Creating deployment descriptor files
Format for deployment descriptor files
Specifying classpath in deployment descriptor files
Defining event types in deployment descriptor files
Defining monitor classes in deployment descriptor files
Inserting annotations for deployment descriptor files
Sample source files with annotations
Generating deployment descriptor files from annotations
Package names and namespaces in JMon applications
Sample JMon applications
Developing EPL Plug-ins
Introduction to EPL Plug-ins
Providing an EPL Event Wrapper for a Plug-in
Writing EPL Plug-ins in C++
Creating a plug-in using C++
Method signatures
Compiling C++ plug-ins
Exceptions
Writing to the correlator log file
Storing data using chunks
Sending events
Receiving events
Blocking behavior of plug-ins
Load-time or unload-time code
Handling thread-specific data in plug-ins
Using plug-ins written in C++
EPL Plug-ins in C and C++ Written Prior to 10.0
Comparison between the new and old APIs
Migrating from 9.12 or older plug-ins
Writing a plug-in in C or C++
A simple plug-in in C++
Calling the test function from EPL
A simple C plug-in
Parameter-less plug-in functions
Advanced plug-in functionality in C++ and C
Introducing complex_plugin
The chunk type
Working with chunk in C++
Working with chunk in C
Working with sequences
The complete example
Using complex_plugin from the correlator
Asynchronous plug-ins
Writing EPL plug-ins for parallel processing applications
Working with blocking behavior in C++ plug-ins
Working with channels in C++ plug-ins
The EPL plug-in APIs for C and C++
Primary class types
Writing EPL Plug-ins in Java
Creating a plug-in using Java
Permitted signatures for methods
Using Java plug-ins
Sample plug-ins in Java
A simple plug-in in Java
A more complex plug-in in Java
A plug-in in Java that sends events
A plug-in in Java that subscribes to receive events
EPL Reference
Introduction
Hello World example
Types
Primitive and string types
boolean
decimal
float
integer
string
Reference types
action
Channel
chunk
context
dictionary
event
Exception
listener
location
optional
sequence
StackTraceElement
stream
Default values for types
monitor pseudo-type
Type properties summary
Timestamps, dates, and times
Type methods and instance methods
Type conversion
Comparable types
Cloneable types
Potentially cyclic types
Which types are potentially cyclic?
String form of potentially cyclic types
Support for IEEE 754 special values
Events and Event Listeners
Event definitions
Event fields
Event actions
Event field and action scope
Event templates
By-position qualifiers
By-name qualifiers
Range expressions
Field operators
Event listener definitions
Event lifecycle
Event listener lifecycle
Event processing order for monitors
Event processing order for queries
Event expressions
Event primaries
Timers
The not operator
The all operator
The and, xor, and or logical event operators
The followed-by event operator
Event expression operator precedence
Event channels
Monitors
Monitor lifecycle
Monitor files
Packages
The using declaration
Monitor declarations
The import declaration
Monitor actions
Simple actions
Actions with parameters
Contexts
Plug-ins
Garbage collection
Queries
Query lifetime
Query definition
Metadata section
Parameters section
Inputs section
Query input definition
Find statement
Pattern
Where condition
Within condition
Without condition
Between clause
Select clause
Having clause
Aggregate Functions
Built-in aggregate functions
Custom aggregates
Statements
Simple statements
The assignment statement
The emit statement
The enqueue statement
The enqueue . . . to statement
The expression statement
The log statement
The print statement
The route statement
The send . . . to statement
The spawn statement
The spawn action to context statement
The throw statement
Variable declaration statements
Compound statements
The for statement
The from statement
The if statement
The ifpresent statement
The on statement
The while statement
The try-catch statement
Transfer of control statements
The break statement
The continue statement
The die statement
The return statement
Expressions
Introduction to expressions
Primary expressions
Bitwise logical operators
Bitwise intersection (and)
Bitwise union (or)
Bitwise exclusive (xor)
Unary bitwise inverse
Logical operators
Logical intersection (and)
Logical union (or)
Logical exclusive or (xor)
Unary logical inverse (not)
Shift operators
Left shift operator
Right shift operator
Comparison operators
Additive operators
Multiplicative operators
Unary additive operators
Expression operators
Expression operator precedence
Postfix expressions
Action and method calls
The subscript operator [ ]
The new object creation operator
Stream queries
Stream query window definitions
Stream source templates
Variables
Variable declarations
Variable scope
Predefined variable scope
Monitor scope
Action scope
Block scope
Event action scope
Custom aggregate function scope
Provided variables
currentTime
Event timestamps
self
Specifying named constant values
Lexical Elements
Program text
Comments
White space
Line terminators
Symbols
Identifiers
Keywords
Operators
Separators
Literals
Boolean literals
Integer literals
Base 10 literals
Base 16 literals
Floating point and decimal literals
String literals
Location literals
Dictionary literals
Sequence literals
Time literals
Names
Annotations
Limits
Obsolete Language Elements
Old style listener calls
Old style spawn statements
EPL Naming Conventions
EPL Methods Quick Reference
Connecting Apama Applications to External Components
Overview
Standard Connectivity Plug-ins
The Universal Messaging Transport Connectivity Plug-in
Overview of using Universal Messaging in Apama applications
Comparison of Apama channels and Universal Messaging channels
Choosing when to use Universal Messaging channels and when to use Apama channels
General steps for using Universal Messaging in Apama applications
Using Universal Messaging channels instead of engine_connect
Using Universal Messaging channels instead of configuring adapter connections
Considerations for using Universal Messaging channels
Setting up Universal Messaging for use by Apama
Configuring the Universal Messaging connectivity plug-in
Loading the Universal Messaging Transport
Configuring the dynamicChainManagers
Configuring the dynamicChains
Using dynamic replacement variables
Subscribing to automatically created Universal Messaging channels
Channel lookup caching
Supported payloads
Replacing the deprecated Universal Messaging integration
EPL and Universal Messaging channels
Using Universal Messaging connectivity from EPL
Monitoring Apama application use of Universal Messaging
Legacy Universal Messaging integration
About events transported by Universal Messaging
Enabling automatic creation of Universal Messaging channels
Starting correlators that use Universal Messaging
Defining Universal Messaging properties for Apama applications
The MQTT Transport Connectivity Plug-in
About the MQTT transport
Using MQTT connectivity from EPL
Loading the MQTT transport
Configuring the dynamicChainManagers
Configuring the dynamicChains
Payload for the MQTT message
Wildcard topic subscriptions
Restrictions
The Digital Event Services Transport Connectivity Plug-in
About the Digital Event Services Transport
Using Digital Event Services connectivity from EPL
Reliable messaging with Digital Event Services
The HTTP Client Transport Connectivity Plug-in
About the HTTP client transport
Loading the HTTP client transport
Configuring the HTTP client transport
Mapping events between EPL and HTTP
Distinguishing response types
Handling HTTP headers
Mapping the body
Dealing with cookies
Providing HTTP query parameters
Example mapping rules
Configuring dynamic connections to services
The Kafka Transport Connectivity Plug-in
Codec Connectivity Plug-ins
The String codec connectivity plug-in
The JSON codec connectivity plug-in
The Classifier codec connectivity plug-in
The Mapper codec connectivity plug-in
The Unit Test Harness codec connectivity plug-in
The Diagnostic codec connectivity plug-in
Standard IAF Plug-ins
The Database Connector IAF Adapter (ADBC)
Overview of using ADBC
Registering your ODBC database DSN on Windows
Adding an ADBC adapter to an Apama project
Configuring the Apama database connector
Configuring an ADBC adapter
Manually editing a configuration file
Configuring ADBC localization
Configuring ADBC Automatic Database Close
Service monitors
Codecs
The ADBCHelper application programming interface
ADBCHelper API overview
Opening databases
Specifying the adapter instance
Checking to see if a database is open
Issuing and stopping SQL queries
Issuing SQL commands
Committing database changes
Performing rollback operations
Handling query results for row data
Handling query results for event data
Handling acknowledgments
Handling errors
Reconnection settings
Closing databases
Getting schema information
Setting context
Logging
Examples
The ADBC Event application programming interface
Discovering data sources
Discovering databases
Opening a database
Closing a database
Storing event data
Storing non-event data
Creating and deleting store events
Handling data storing errors
Committing transactions
Rolling back transactions
Running commands
Executing queries
Executing standard queries
Stopping queries
Preserving column name case
Prepared statements
Using a prepared statement
Stored procedures
Using a stored procedure
Named queries
Using named queries
Creating named queries
The Visual Event Mapper
Using the Visual Event Mapper
Playback
Sample applications
Format of events in .sim files
The Web Services Client IAF Adapter
Web Services Client adapter overview
Adding a Web Services Client adapter to an Apama project
Configuring a Web Services Client adapter
Specify the web service and operation to use
Web Service Client
Specifying Apama events for mapping
Editing Web Services Client adapter configurations
Adding multiple instances of the Web Services Client adapter
Mapping web service message parameters
Simple mapping
Convention-based XML mapping
Convention-based web service message mapping example
Add Computed Node dialog
XMLDecode
Template-based mapping
Combining convention and template mapping
Mapping complex types
Difference between doc literal and RPC literal WSDLs
Using custom EL mapping extensions
JUEL mapping expressions reference for Web Client Services adapter
Specifying a correlation ID field
Specifying transformation types
Using the XPath Helper
Launching the XPath Helper
Setting node properties
Generating XPath expressions
Adding and removing namespaces
Evaluating XPath expressions
Customizing mapping rules
Mapping SOAP body elements
Mapping SOAP header elements
Mapping HTTP header elements
Using EPL to interact with web services
Configuring logging for a Web Services Client adapter
Web Services Client adapter artifacts
Updating a web service operation using the Archive Editor
The File IAF Adapter (JMultiFileTransport)
File adapter plug-ins
File adapter service monitor files
Adding the File adapter to an Apama project
Configuring the File adapter
Overview of event protocol for communication with the File adapter
Opening files for reading
Opening files for reading with parallel processing applications
Specifying file names in OpenFileForReading events
Opening comma separated values (CSV) files
Opening fixed width files
Sending the read request
Requesting data from the file
Receiving data
Opening files for writing
Opening files for writing with parallel processing applications
LineWritten event
Monitoring the File adapter
The Basic File IAF Adapter (FileTransport/JFileTransport)
Codec IAF Plug-ins
The String codec IAF plug-in
The Null codec IAF plug-in
Null codec transport-related properties
The Filter codec IAF plug-in
Filter codec transport-related properties
Specifying filters for the Filter codec
Examples of filter specifications
The XML codec IAF plug-in
Supported XML features
Adding XML codec to adapter configuration
Setting up the classpath
About the XML parser
Specifying XML codec properties
Required XML codec properties
XML codec transport-related properties
Message logging properties
Downstream node order suffix properties
Additional downstream properties
Sequence field properties
Upstream properties
Performance properties
Description of event fields that represent normalized XML
Examples of conversions
Sequence field example
XPath examples
The CSV codec IAF plug-in
Multiple configurations and the CSV codec
Decoding CSV data from the sink to send to the correlator
Encoding CSV data from the correlator for the sink
The Fixed Width codec IAF plug-in
Multiple configurations and the Fixed Width codec
Decoding fixed width data from the sink to send to the correlator
Encoding fixed width data from the correlator for the sink
Correlator-Integrated Support for the Java Message Service (JMS)
Using the Java Message Service (JMS)
Overview of correlator-integrated messaging for JMS
Samples for using correlator-integrated messaging for JMS
Key concepts for correlator-integrated messaging for JMS
Getting started with simple correlator-integrated messaging for JMS
Correlator-integrated messaging for JMS adapter editor
Adding and configuring connections
Adding JMS receivers
Configuring receiver event mappings
Using conditional expressions
Adding a classpath variable entry
Configuring sender event mappings
Using EPL to send and receive JMS messages
Getting started with reliable correlator-integrated messaging for JMS
Mapping Apama events and JMS messages
Simple mapping for JMS messages
Using expressions in mapping rules
Template-based XML generation
Adding multiple XPath mapping rules for a received XML document
Using Treat As on JMS Body dialog - Sender
Using Treat As on JMS Body dialog - Receiver
Using the Type Chooser dialog
Using convention-based XML mapping with JMS messages
Convention-based JMS message mapping example
Using convention-based XML mapping when receiving/parsing messages
Using convention-based XML mapping when sending/generating messages
Combining convention-based XML mapping with template-based XML generation
Using EDA events in Apama applications
Rules that govern automatic conversion between of EDA events and Apama events
Rules that govern EPL name generation
Creating Apama event type definitions for EDA events
Automatically mapping configurations for EDA events
Manually mapping configurations for EDA events
Handling binary data
Using custom EL mapping extensions
JUEL mapping expressions reference for JMS
Implementing a custom Java mapper
Dynamic senders and receivers
Durable topics
Receiver flow control
Monitoring correlator-integrated messaging for JMS status
Logging correlator-integrated messaging for JMS status
JMS configuration reference
Configuration files
XML configuration file format
XML configuration bean reference
Advanced configuration bean properties
Designing and implementing applications for correlator-integrated messaging for JMS
Using correlator persistence with correlator-integrated messaging for JMS
How reliable JMS sending integrates with correlator persistence
How reliable JMS receiving integrates with correlator persistence
Sending and receiving reliably without correlator persistence
Receiving messages with APP_CONTROLLED acknowledgements
Sending messages reliably with application flushing notifications
Using the correlator input log with correlator-integrated messaging for JMS
Reliability considerations when using JMS
Duplicate detection when using JMS
Performance considerations when using JMS
Performance logging when using JMS
Receiver performance when using JMS
Sender performance when using JMS
Configuring Java options and system properties when using JMS
Diagnosing problems when using JMS
JMS failures modes and how to cope with them
Working with Connectivity Plug-ins
Using Connectivity Plug-ins
Overview of using connectivity plug-ins
Static and dynamic connectivity chains
Configuration file for connectivity plug-ins
Host plug-ins and configuration
Translating EPL events using the apama.eventMap host plug-in
Using reliable transports
Creating dynamic chains from EPL
Sending and receiving events with connectivity plug-ins
Deploying plug-in libraries
Developing Connectivity Plug-ins
Chain components and messages
Requirements of a plug-in class
Requirements of a transport chain manager plug-in class
Building plug-ins
C++ data types
Map contents used by the apama.eventMap host plug-in
Metadata values
Lifetime of connectivity plug-ins
Creating dynamic chains from a chain manager plug-in
User-defined status reporting from connectivity plug-ins
Logging and configuration
Threading
Developing reliable transports
Working with IAF Plug-ins
The Integration Adapter Framework
Overview
Architecture
The transport layer
The codec layer
The Semantic Mapper layer
Contents of the IAF
Using the IAF
The IAF runtime
IAF library paths
IAF command line options
IAF log file status messages
IAF log file rotation
IAF Management – Managing a running adapter I
IAF Client – Managing a running adapter II
IAF Watch – Monitoring running adapter status
The IAF configuration file
Including other files
Transport and codec plug-in configuration
Event mappings configuration
Apama correlator configuration
Configuring IAF adapters to use Universal Messaging
Logging configuration (optional)
Java configuration (optional)
IAF samples
C/C++ Transport Plug-in Development
The C/C++ transport plug-in development specification
Transport functions to implement
Defining the transport function table
The transport constructor, destructor and info functions
Other transport definitions
Transport utilities
Communication with the codec layer
Transport example
Getting started with transport layer plug-in development
C/C++ Codec Plug-in Development
The C/C++ codec plug-in development specification
Codec functions to implement
Codec encoder functions
Codec decoder functions
Defining the codec function tables
The codec function table
The codec encoder function table
The codec decoder function table
Registering the codec function tables
The codec constructor, destructor and info functions
Other codec definitions
Codec utilities
Communication with other layers
Working with normalized events
The AP_NormalisedEvent structure
The AP_NormalisedEventIterator structure
Transport example
Getting started with codec layer plug-in development
C/C++ Plug-in Support APIs
Logging from plug-ins in C/C++
Using the latency framework
C/C++ timestamp
C/C++ timestamp set
C/C++ timestamp configuration object
C/C++ latency framework API
Transport Plug-in Development in Java
The transport plug-in development specification for Java
Java transport functions to implement
Communication with the codec layer
Sending upstream messages received from a codec plug-in to a sink
Sending downstream messages received from a source on to a codec plug-in
Transport exceptions
Logging
Example
Getting started with Java transport layer plug-in development
Java Codec Plug-in Development
The codec plug-in development specification for Java
Java codec functions to implement
Communication with other layers
Sending upstream messages received from the Semantic Mapper to a transport plug-in
Sending downstream messages received from a transport plug-in to the Semantic Mapper
Java codec exceptions
Semantic Mapper exceptions
Logging
Working with normalized events
The NormalisedEvent class
The NormalisedEventIterator class
Java codec example
Getting started with Java codec layer plug-in development
Plug-in Support APIs for Java
Logging from plug-ins in Java
Using the latency framework
Java timestamp
Java timestamp set
Java timestamp configuration object
Java latency framework API
Monitoring Adapter Status
IAFStatusManager
Application interface
Returning information from the getStatus method
Connections and other custom properties
Asynchronously notifying IAFStatusManager of connection changes
Mapping AdapterConnectionClosed and AdapterConnectionOpened events
StatusSupport
StatusSupport events
DataView support
Out of Band Connection Notifications
Mapping example
Ordering of out of band notifications
The Event Payload
Developing Custom Clients
The Client Software Development Kits
The client libraries
Working with event objects
Logging
Exception handling and thread safety
EngineManagement API
EngineClient API
EventService API
ScenarioService API
Building and Using Dashboards
Overview
Building Dashboard Clients
Introduction to Building Dashboard Clients
Web client requirements
About dashboards
Starting the Dashboard Builder
Starting Builder from the Windows Start menu
Starting Builder from Software AG Designer
Specifying Dashboard Builder options
Starting Builder from the command line
Scenario instance and DataView item ownership
Using the tutorial application
Using Dashboard Builder
Dashboard Builder layout
The menubar
The toolbar
The canvas
The Object Palette
The Object Properties panel
Specifying data sources
Specifying correlators
Specifying XML data sources
Activating data source specifications
Saving data source specifications
Setting the background properties
About resize modes
About resize modes and Display Server deployments
About resize modes and composite objects
Working with objects
Adding objects to a dashboard
Selecting an object
Resizing objects
Moving objects
Copy and pasting objects
Deleting objects
Setting Builder options
Setting Dashboard options
Setting options in the General tab group
Setting options in the General tab
Setting options in the Substitutions tab
Setting options in the Data Server tab
Setting options in the Custom Colors tab
Setting options in the Apama tab group
Setting options in the SQL tab group
Setting options in the XML tab group
Saving options
Command line options for the Dashboard Builder
Restrictions
Attaching Dashboards to Correlator Data
Dashboard data tables
Scenario instance table
Query instance table
Scenario trend table
Scenario OHLC table
Correlator status table
Data Server status table
Scenario constraint table
DataView item table
DataView trend table
DataView OHLC table
SQL-based instance table
Definition Extra Params table
Setting data options
Scenario instance and DataView item ownership
Creating a data attachment
Using the Attach to Apama dialog
Selecting display variables or fields
Displaying attached data
Filtering data
Attaching to constraint data
About timestamps
Using dashboard variables in attachments
About non-substitution variables
About drilldown and $instanceId
About other predefined substitution variables
Using SQL-based instance tables
Working with multiple Data Servers
Builder with multiple Data Servers
Viewer with multiple Data Servers
Display Server deployments with multiple Data Servers
Web Start deployments with multiple Data Servers
Using table objects
Creating a scenario summary table
Filtering rows of a scenario summary table
Performing drilldowns on tables
Specifying drill-down column substitutions
Hiding table columns
Using pre-set substitution variables for drill down
Formatting table data
Colorizing table rows and cells
Setting column headers
Using rotated tables
Using pie and bar charts
Creating a summary pie or bar chart
Using series and non-series bar charts
Performing drilldowns on pie and bar charts
Using trend charts
Creating a scenario trend chart
Charting multiple variables
Adding thresholds
Configuring trend-data caching
Rendering trend charts in HTML5
Using stock charts
Using OHLC values
Creating a scenario stock chart
Adding overlays
Recreating the Stock Chart Overlay sample
Generating OHLC values
Localizing dashboard labels
Localizing dashboard messages
Using Dashboard Functions
Using built-in functions
Creating custom functions
Developing a custom-function library
Implementing getFunctionDescriptors
Implementing evaluateFunction
Installing a custom-function library
Sample IFunctionLibrary implementation
Defining Dashboard Commands
Scenario lifecycle
Defining commands
Using dashboard variables in commands
Defining commands for creating a scenario instance
Defining commands for editing a scenario instance
Supporting deletion of a scenario instance
Supporting deletion of all instances of a scenario
Defining commands for creating a query instance
Defining commands for editing a query instance
Supporting deletion of a query instance
Supporting deletion of all instances of a query
Using popup dialogs for commands
Command options
Associating a command with keystrokes
Defining multiple commands
Creating custom commands
Developing a custom-command library
Installing a Custom-Command Library
Sample ICommandLibrary implementation
Apama set substitution command
Reusing Dashboard Components
Using Object Grids
Configuring Object Grids
Recreating the Object Grid sample
Using Composite objects
Creating files to display in composite objects
Configuring Composite objects
Using substitutions with Composite objects
Composite object interactivity
Composite object sample
Recreating the Composite object sample
Using Composite Grids
Configuring Composite Grids
Composite Grid sample
Recreating the Composite Grid sample
Using include files
Include File sample
Recreating the Include File sample
Working with multiple display panels
About the format of the panels-configuration file
Using new tags to configure the panels in a window
Configuring panels with accordion controls
Configuring static tree navigation panels
Configuring tabbed navigation panels
Using tab definition files
Examples of configuration files for multiple panels
Using tree controls in panel displays
Creating tree controls
Configuring tree control icons
Specifying tree control properties
Tree control limitations
Using old tags to configure the panels in a window
Using border panels
Using card panels
Using grid panels
Using tabs panels
Using tree panels
Using the RTViewNavTreePanel tag
Using the RTViewPanel tag
Tab Control object
Sending Events to Correlators
Using the Define Apama Command dialog
Other dialog fields
Updating event definitions in Builder
Example
Send event authorization
Using XML Data
XML data format
Scalar data elements
Tabular data elements
Defining an XML data source
Attaching objects to XML data
Using SQL Data
SQL system requirements and setup
Attaching visualization objects to SQL data
Validation colors
Substitutions
Select table columns
Defining SQL commands
Validation colors
Special values
Specifying application options
SQL tab
Adding a Database
Database repository
Entering database information directory into OPTIONS.ini
Generating encrypted passwords for SQL data sources
Deploying Web Start dashboards
Setting up SQL database connections
Direct JDBC connection
Setting SQL data source options
Dashboard Property Reference for Graphs, Tables and Trends
Introduction to Dashboard Properties
Objects for complex-data visualization
About the Object Properties window
Editing property values
Copying and pasting property values
Graph Objects
Bar graphs
Bar graph: Alert group
Bar graph: Background group
Bar graph: Bar group
Bar graph: Column group
Bar graph: Data group
Bar graph: Data Format group
Bar graph: Data Label group
Bar graph: Historian group
Bar graph: Interaction group
Bar graph: Label group
Bar graph: Layout group
Bar graph: Legend group
Bar graph: Marker group
Bar graph: Object group
Bar graph: Plot Area group
Bar graph: Trace group
Bar graph: X-Axis group
Bar graph: Y-Axis group
Google map
Map graph: Data group
Map graph: Interaction group
Map graph: Map group
Map graph: Object group
Licensing
Heat map
Heat maps with one index column
Heat maps with multiple index columns
Mapping from possible aggregation results to colors
Drill down displays
Object class name
Heat map property groups
Heat map: Background properties
Heat map: Data group
Heat map: Data format group
Heat map: Data Label group
Heat map: Historian group
Heat map: Interaction group
Heat map: Label group
Heat map: Layout group
Heat map: Node group
Heat map: Object group
Heat map: Quality group
Legend
Legend: Background group
Legend: Data group
Legend: Historian group
Legend: Interaction group
Legend: Label group
Legend: Legend group
Legend: Object group
Pie graph
Pie graph: Background group
Pie graph: Column group
Pie graph: Data group
Pie graph: Data Format group
Pie graph: Data Label group
Pie graph: Historian group
Pie graph: Interaction group
Pie graph: Label group
Pie graph: Legend group
Pie graph: Object group
Pie graph: Wedge group
Radar graph
Radar graph: Alert group
Radar graph: Background group
Radar graph: Column group
Radar graph: Data group
Radar graph: Data Format group
Radar graph: Data Label group
Radar graph: Historian group
Radar graph: Interaction group
Radar graph: Label group
Radar graph: Legend group
Radar graph: Marker group
Radar graph: Object group
Radar graph: Plot Area group
Radar graph: Radial Axis group
Radar graph: Trace group
Radar graph: Value Axis group
XY graph
XY graph: Alert group
XY graph: Background group
XY graph: Column group
XY graph: Data group
XY graph: Data Format group
XY graph: Data Label group
XY graph: Historian group
XY graph: Interaction group
XY graph: Label group
XY graph: Legend group
XY graph: Marker group
XY graph: Object group
XY graph: Plot Area group
XY graph: Trace group
XY graph: X-Axis group
XY graph: Y-Axis group
Table Objects
Standard tables
Standard table: Alert group
Standard table: Background group
Standard table: Cell group
Standard table: Column group
Standard table: Column Header group
Standard table: Data group
Standard table: Data Label group
Standard table: Grid group
Standard table: Historian group
Standard table: Interaction group
Standard table: Label group
Standard table: Object group
Standard table: Row Header group
Standard table: Sort group
Rotated tables
Rotated table: Background group
Rotated table: Cell group
Rotated table: Column group
Rotated table: Data group
Rotated table: Grid group
Rotated table: Historian group
Rotated table: Interaction group
Rotated table: Label group
Rotated table: Object group
HTML5 tables
Trend Objects
Sparkline charts
Sparkline chart: Alert group
Sparkline chart: Background group
Sparkline chart: Data group
Sparkline chart: Data Format group
Sparkline chart: Historian group
Sparkline chart: Interaction group
Sparkline chart: Label group
Sparkline chart: Legend group
Sparkline chart: Marker group
Sparkline chart: Object group
Sparkline chart: Plot Area group
Sparkline chart: Trace group
Sparkline chart: X-Axis group
Sparkline chart: Y-Axis group
Stock charts
Stock chart: Background group
Stock chart: Data group
Stock chart: Data Format group
Stock chart: Interaction group
Stock chart: Historian group
Stock chart: Label group
Stock chart: Legend group
Stock chart: Object group
Stock chart: Plot Area group
Stock chart: Price Trace group
Stock chart: Trace group
Stock chart: TraceN group
Stock chart: X-Axis group
Stock chart: Y-Axis group
Trend graphs
Trend graph: Alert group
Trend graph: Background group
Trend graph: Data group
Trend graph: Data Format group
Trend graph: Interaction group
Trend graph: Label group
Trend graph: Legend group
Trend graph: Marker group
Trend graph: Object group
Trend graph: Plot Area group
Trend graph: Trace group
Trend graph: TraceN group
Trend graph: Trace Groups group
Trend graph: X-Axis group
Trend graph: Y-Axis group
Drill-Down Specification
Using the Drill Down Properties dialog
Activating drill downs
About drilldown displays opened in Dashboard Builder
Dashboard Function Reference
Introduction to Dashboard Functions
Working with functions
Scalar Functions
Add
Average
Boolean Expression
Concatenate
Correlator Time Format
Date Add
Date Ceiling
Date Compare
Date Difference
Date Floor
Date Format
Date Now
Delta
Divide
Duration
Evaluate Expression As Double
Evaluate Expression As String
Format Number
Get Substitution
Init Local Variable
isWindowsOS
Max
Min
Modulo
Multiply
Percent
Quick Set Sub
Replace All
Replace Value
Set Substitution
Set Substitutions By Lookup
Subtract
Validate Substitutions
Tabular Functions
Add All Rows Or Columns
Add Columns
Average All Rows Or Columns
Average Columns
Baseline Over Time
Buffer Table Rows
Combine
Concatenate Columns
Convert Columns
Copy
Count
Count By Bands
Count Unique Values
Count Unique Values By Time
Create Selector List
Delta And Rate Rows
Delta Rows
Distinct Values
Divide Columns
Ensure Columns
Ensure Timestamp Column
Evaluate Expression By Row
Filter And Extract Matches
Filter By Pattern
Filter By Row
Filter By Time Range
First Table Rows
Format Table Columns
Get Data Server Connection Status
Group By Time
Group By Time and Unique Values
Group by Unique Values
Join
Join Outer
Last Table Rows
Mark Time Gaps
Max All Rows or Columns
Max Columns
Min All Rows or Columns
Min Columns
Modulo Columns
Multiply Columns
Percent Columns
Pivot On Unique Values
Reference
Rename Columns
Select Column
Set Column Type
Sort Table
Split String
String to Table
Subtotal By Time
Subtotal By Unique Values
Subtract Columns
Table Contains Values
Expression Syntax in Dashboard Functions
Operators in dashboard function expressions
Arithmetic functions in dashboard function expressions
String functions in dashboard function expressions
Dashboard Deployment
Dashboard Deployment Concepts
Deployment options
Application installation
Authentication
Authorization
Data protection
Refresh latency
Scalability
Dashboard support for Apple iPad
Data server and display server
Process architecture
Builders and administrators
Generating Dashboards
Starting the wizard
Using the wizard
Using the titlebar/toolbar
Using the Introduction form
Using the Main, Create, Edit, and Details Forms
Using the layout configuration forms
Preparing Dashboards for Deployment
Dashboard feature checklist
Changing correlator definitions for deployment
Choosing among deployment types
Application installation
Authentication
Authorization
Data protection
Scalability
Choosing among web-based deployment types
Installation
Served data
Refresh latency
Dashboard iPad Support
Using the Deployment Configuration editor
Starting the Configuration editor
Rename Deploy Configuration
Saving deployment configurations
Title bar/Toolbar
General Settings
Startup and Server
Additional JAR Files
Layout
Using the Dashboard Package wizard
Generating a deployment package from the command line
Sharing information with the Dashboard Administrator
Deploying Dashboards
Generating the dashboard .war file
Installing a dashboard .war file
Inside a dashboard .war file
Additional steps for display server deployments
Web Start deployment
Managing the Dashboard Data Server and Display Server
Prerequisites
Starting and stopping the Data Server or Display Server
Command line options for the Data Server and Display Server
Controlling Update Frequency
Configuring Trend-Data Caching
Managing Connect and Disconnect Notification
Working with multiple Data Servers
Builder with multiple Data Servers
Viewer with multiple Data Servers
Display Server deployments with multiple Data Servers
Web Start deployments with multiple Data Servers
Managing and stopping the Data Server and Display Server
Administering Dashboard Security
Administering authentication
Authentication for local and WebSphere deployments
Dashboard Login Modules Provided by Apama
Developing custom login modules
Installing login modules
Installing UserFileLoginModule
Installing LdapLoginModule
Administering authorization
Users and roles
Default Scenario and DataView access control
Customizing Scenario and DataView access control
Providing a Scenario Authority
Developing a custom Scenario Authority
Implementing IScenarioAuthority methods
Installing a Scenario Authority
Sample Custom Scenario Authority
Send event authorization
Using UserCredential accessor methods
Compiling your Event Authority
Installing your Event Authority
Providing a login module that supports a Scenario or Event Authority
Securing communications
Example: Implementing LoginModule
Using the Dashboard Viewer
Concepts Underlying Dashboards
About Dashboards
Starting the Dashboard Viewer
Scenario instance and DataView item ownership
Using the Dashboard Viewer
Opening and viewing dashboards
Running the Statistical Arbitrage demo
Displaying additional dashboards
Creating instances visualized by the Statistical Arbitrage main dashboard
The Dashboard Viewer menu bar
Resizing the Dashboard Viewer
Working with Dashboard Objects
Trend charts
Stock charts
Tables
Pie and Bar charts
Startup Options for the Dashboard Viewer
Timezone ID Values
Deploying and Managing Apama Applications
Overview
Security Requirements for Apama
Overview of Deploying Apama Applications
About deploying components with Command Central
About deploying Apama applications with an Ant script
About Apama command line utilities
About deploying dashboards
About tuning applications for performance
Setting up the environment using the Apama Command Prompt
Deploying Apama Components with Command Central
Overview of deploying components with Command Central
Getting started with Command Central
Using the Command Central web interface
Using the Command Central command line interface
Administering Apama in Command Central
Creating and deleting instances using the Command Central web user interface
Configuring instances using the Command Central web user interface
Creating and deleting instances using the Command Central command line interface
Commands that Apama components support
Configuration types that Apama components support
Configuration types that the Apama correlator supports
The correlator persistence properties
The correlator license key
Configuration types that Apama IAF supports
The IAF configuration file
Configuration types that the Apama Display Server and Apama Data Server support
Server modes
Additional .jar files
Memory configuration
Component endpoint configuration
Usage notes
Extra arguments
Component logging
Component ports
Apama environment variables
Correlator connections
Correlator initializations
Configuring Digital Event Services for a correlator instance
Retrieving configuration data for Apama component instances
Lifecycle actions for Apama component instances
Monitoring Apama from Command Central
Monitoring the KPIs for the correlator
Monitoring the KPIs for EPL applications and connectivity plug-ins
Monitoring the KPIs for the IAF
Monitoring the KPIs for the dashboard servers
Viewing log files
Deploying a Designer project to Command Central
Deploying and Managing Queries
Overview of deploying and managing query applications
Query application architecture
Deploying query applications
Running queries on correlator clusters
Deploying queries on multiple correlators
Deploying BigMemory Terracotta Server Array
Configuring BigMemory driver
Using JMS to deliver events to queries running on a cluster
Mixing queries with monitors
Handling node failure and failover
Managing parameterized query instances
Creating new query instances by setting parameter values
Changing parameter values for queries that are running
Monitoring running queries
Tuning Correlator Performance
Scaling up Apama
Partitioning strategies
Engine topologies
Correlator pipelining
Configuring pipelining with engine_connect
Connection configuration file
Configuring pipelining through the client API
Event partitioning
Managing and Monitoring over REST
Generic management
Correlator management
IAF management
Dashboard management
Correlator Utilities Reference
Starting the correlator
Specifying log filenames
Examples for specifying log filenames
Descriptions of correlator status log fields
Text internationalization issues
Determining whether to disconnect slow receivers
Description of slow receivers
How frequently slow receivers occur
Correlator behavior when there is a slow receiver
Tradeoffs for disconnecting a slow receiver
Determining whether to disable the correlator's internal clock
Injection time of compiled runtime
Injecting code into a correlator
Deploying a correlator
Deleting code from a correlator
Packaging correlator input files
Sending events to correlators
Receiving events from correlators
Watching correlator runtime status
Inspecting correlator state
Shutting down and managing components
Viewing garbage collection information
Using the EPL memory profiler
Using the CPU profiler
Setting logging attributes for packages, monitors and events
Rotating the correlator log file
Rotating all log files
Rotating specified log files
Using the command-line debugger
Obtaining online help for the command-line debugger
Enabling and disabling debugging in the correlator
Working with breakpoints using the command-line debugger
Controlling execution with the command-line debugger
The wait command
Command shortcuts for the command-line debugger
Examining the stack with the command-line debugger
Displaying variables with the command-line debugger
Generating code coverage information about EPL files
Recording code coverage information
Creating code coverage reports
Interpreting the HTML code coverage reports
Using EPL code coverage with PySys tests
Replaying an input log to diagnose problems
Creating an input log file
Rotating an input log file
Performance when generating an input log
Reproducing correlator behavior from an input log
Event file format
Event representation
Event timing
Event types
Event association with a channel
Using the data player command-line interface
Configuring the correlator
Using YAML configuration files
Including YAML configuration files inside another YAML configuration file
Sample YAML configuration file for the correlator
Using properties files
Runtime parameterization of configuration
Specifying the correlator port number
Binding server components to particular addresses
Ensuring that client connections are from particular addresses
Setting environment variables for Apama components
Setting log files and log levels in a YAML configuration file
Configuring persistence in a YAML configuration file
Specifying JVM options
Deploying Apama applications with a YAML configuration file
Using the Apama component extended configuration file
Binding server components to particular addresses
Ensuring that client connections are from particular addresses
Setting environment variables for Apama components
Sample extended configuration file
API Reference for EPL (ApamaDoc)
API Reference for Java (Javadoc)
API Reference for C++ (Doxygen)
API Reference for .NET
Copyright
Apama Documentation
Copyright
to-help_index
to-help_about
co-ApaEplRef_documentation_roadmap
re-webm_online_information
co-ApaEplRef_contacting_customer_support
to-help_release_notes
co-WhaNewInApa_about_this_documentation
co-WhaNewInApa_license_terms_and_technical_restrictions
co-WhaNewInApa_100_top
co-ApaRelNot_100_http_client
co-ApaRelNot_100_mqtt
co-ApaRelNot_100_kafka
co-ApaRelNot_100_connectivity
co-ApaRelNot_100_cplusplus_api
co-ApaRelNot_100_sag_designer
co-ApaRelNot_100_queries
co-ApaRelNot_100_epl_enhancements
co-ApaRelNot_100_correlator_utilities
co-ApaRelNot_100_dashboard_enhancements
co-ApaRelNot_100_miscellaneous
co-ApaRelNot_100_platform_changes
co-ApaRelNot_100_windows_compiler_update
co-ApaRelNot_100_misc_backwards_compatibility
co-ApaRelNot_100_removed
co-WhaNewInApa_912_top
co-ApaRelNot_912_digital_event_services
co-ApaRelNot_912_universal_messaging
co-ApaRelNot_912_optional_type
co-ApaRelNot_912_edge
co-ApaRelNot_912_connectivity
co-ApaRelNot_912_connectivity_api
co-ApaRelNot_912_sag_designer
co-ApaRelNot_912_queries
co-WhaNewInApa_912_epl_changes
co-ApaRelNot_912_correlator_utilities
co-ApaRelNot_912_dashboard_enhancements
co-ApaRelNot_912_pysys
co-ApaRelNot_912_command_central
co-ApaRelNot_912_miscellaneous
co-ApaRelNot_912_platform_changes
co-ApaRelNot_912_misc_backwards_compatibility
co-ApaRelNot_912_removed
co-WhaNewInApa_910_top
co-ApaRelNot_910_connectivity
co-ApaRelNot_910_metadata
co-ApaRelNot_910_epl_memory_profiler
co-ApaRelNot_910_epl_code_coverage
co-ApaRelNot_910_pysys
co-ApaRelNot_910_dashboard_server_http_support
co-ApaRelNot_910_json_based_rest_support
co-ApaRelNot_910_command_central
co-ApaRelNot_910_sag_designer
co-WhaNewInApa_910_epl_changes
co-ApaRelNot_910_correlator_utilities
co-ApaRelNot_910_dashboard_enhancements
co-ApaRelNot_910_miscellaneous
co-ApaRelNot_910_platform_changes
co-ApaRelNot_910_jdk
co-ApaRelNot_910_misc_backwards_compatibility
co-ApaRelNot_910_removed
co-WhaNewInApa_99_top
co-ApaRelNot_99_installation_changes
co-ApaRelNot_99_queries
co-ApaRelNot_99_studio
co-WhaNewInApa_99_epl_changes
co-ApaRelNot_99_correlator_utilities
co-ApaRelNot_99_dashboard_enhancements
co-ApaRelNot_99_miscellaneous
co-ApaRelNot_99_docker_samples
co-ApaRelNot_99_platform_changes
co-ApaRelNot_99_renamed_libraries
co-ApaRelNot_99_misc_backwards_compatibility
co-ApaRelNot_removed_and_deprecated_99
co-WhaNewInApa_53_top
co-ApaRelNot_53_queries
co-ApaRelNot_53_studio
co-ApaRelNot_log_enhancements_53
co-WhaNewInApa_53_epl_changes
co-ApaRelNot_53_jms
co-ApaRelNot_53_dashboard_enhancements
co-ApaRelNot_53_client_api_enhancements
co-ApaRelNot_53_new_sample_application
co-ApaRelNot_53_plugin_api_enhancements
co-ApaRelNot_miscellaneous
co-ApaRelNot_53_platform_changes
co-ApaRelNot_migration_to_53
co-ApaRelNot_removed_and_deprecated_53
co-ApaRelNot_53_backwards_incompatibility_persisted_projects
co-WhaNewInApa_52
co-WhaNewInApa_52_studio
co-WhaNewInApa_channels
co-WhaNewInApa_52_um
co-WhaNewInApa_52_epl
co-WhaNewInApa_52_adapters
co-WhaNewInApa_52_correlator_utilities
co-WhaNewInApa_52_windows_compiler_changes
co-WhaNewInApa_52_unix_compiler_changes
co-WhaNewInApa_migration_52
co-WhaNewInApa_52_deprecated_features
co-WhaNewInApa_52_miscel
co-WhaNewInApa_511
co-WhaNewInApa_what_s_new_in_apama_5_1
co-WhaNewInApa_distributed_memorystore
co-ExcForApa5_0_2_new_epl_exception_handling_mechanism
co-WhaNewInApa_managing_and_monitoring_with_rest_api
co-WhaNewInApa_writing_correlator_plug_ins_in_java
co-WhaNewInApa_headless_mode_generation_of_apamadoc
co-WhaNewInApa_pysys_test_framework
co-WhaNewInApa_login_redirect_filename_change
co-WhaNewInApa_new_keywords
co-WhaNewInApa_jars_in_cdps
co-WhaNewInApa_features_removed_from_apama
co-WhaNewInApa_migration
to-help_installing_apama
co-InsApa_preface
to-InsApa_before
co-InsApa_about_the_apama_installation_process
co-InsApa_prerequisites
to-InsApa_installing_apama
ta-InsApa_running_the_software_ag_installer
co-InsApa_after_the_installation
co-InsApa_post_installation
co-InsApa_installing_fixes
co-InsApa_installing_apama_using_command_central
to-InsApa_remove
co-InsApa_running_the_software_ag_uninstaller
to-help_introduction_to_apama
co-IntToApa_about_this_documentation
co-IntToApa_apama_overview
co-IntToApa_what_is_apama_
co-IntToApa_understanding_the_different_user_viewpoints
co-IntToApa_about_apama_license_files
co-IntToApa_running_apama_without_a_license_file
co-IntToApa_software_ag_knowledge_center
co-IntToApa_apama_architecture
co-IntToApa_distinguishing_architectural_features
co-IntToApa_how_apama_integrates_with_external_data_sources
co-IntToApa_descriptions_of_apama_components
co-IntToApa_description_of_the_apama_correlator
co-IntToApa_description_of_event_processing_languages
co-IntToApa_introduction_to_apama_epl
co-IntToApa_introduction_to_apama__in_process__java_api
co-IntToApa_description_of_apama_studio
co-IntToApa_description_of_query_designer
co-IntToApa_description_of_dashboard_builder_and_dashboard_viewer
co-IntToApa_description_of_client_development_kits
co-IntToApa_description_of_apama_studio_s_data_player
co-IntToApa_how_the_correlator_works
co-IntToApa_apama_concepts
co-IntToApa_event_driven_programming
co-IntToApa_complex_event_processing
co-IntToApa_understanding_monitors_and_listeners
co-DevApaApp_understanding_queries
co-EplQueRun_comparison_of_queries_and_monitors
co-IntToApa_understanding_dashboards
co-IntToApa_getting_ready_to_develop_apama_applications
co-IntToApa_becoming_familiar_with_apama
co-IntToApa_introduction_to_apama_studio
co-IntToApa_steps_for_developing_apama_applications
co-IntToApa_overview_of_starting__testing_and_debugging_applications
to-apama_glossary
to-help_using_apama_with_sag_designer
co-UsiApaStu_overview_of_developing_apama_applications
ta-UsiApaStu_starting_software_ag_designer
co-UsiApaStu_samples_and_tutorials
co-UsiApaStu_the_apama_interface
co-UsiApaStu_the_apama_workbench_perspective
WORKBENCH_PROJECT_VIEW
co-UsiApaStu_workbench_project_view
co-UsiApaStu_the_apama_developer_perspective
ApamaPerspective
co-UsiApaStu_project_explorer_view
ResourcesView
co-UsiApaStu_the_apama_runtime_perspective
co-UsiApaStu_apama_projects
co-UsiApaStu_managing_project_hierarchies
co-UsiApaStu_editors
co-UsiApaStu_outline_view
OutlineView
co-UsiApaStu_scenario_browser_view
co-UsiApaStu_engine_receive_view
co-UsiApaStu_engine_status_view
ENGINE_STATUS_VIEW
co-UsiApaStu_engine_information_view
ENGINE_INSPECT_VIEW
co-UsiApaStu_console_view
Console
co-UsiApaStu_problems_view
co-UsiApaStu_data_player_control_view
co-UsiApaStu_building_apama_projects
co-UsiApaStu_launching_apama_projects
co-UsiApaStu_working_with_projects
ta-UsiApaStu_creating_apama_projects
WIZARD_NEW_APAMA_PROJECT
ta-UsiApaStu_adding_resources_to_apama_projects
ta-UsiApaStu_creating_new_monitor_files_for_epl_applications
WIZARD_NEW_MONITORSCRIPT
co-UsiApaStu_creating_new_event_definition_files_for_epl_applications
WIZARD_NEW_EVENT_DEFINITION
ta-UsiApaStu_creating_event_definitions_by_adding_epl_code
ta-UsiApaStu_creating_event_definitions_from_xml_files
WIZARD_EVENT_GEN_FROM_XML
ta-UsiApaStu_creating_event_definitions_from_xsd_files
WIZARD_EVENT_GEN_FROM_XSD
ta-UsiApaStu_creating_new_files_for_apama_java_applications
ta-UsiApaStu_adding_a_new_java_application
WIZARD_NEW_APAMA_JAVA_CONFIG
ta-UsiApaStu_adding_an_apama_java_monitor
WIZARD_NEW_APAMA_JAVA_MONITOR_PAGE
ta-UsiApaStu_adding_an_apama_java_event
WIZARD_NEW_APAMA_JAVA_EVENT_PAGE
ta-UsiApaStu_adding_java_epl_plugin
WIZARD_NEW_APAMA_JAVA_EPLPLUGIN_PAGE
ta-UsiApaStu_creating_new_scenarios
WIZARD_NEW_SCENARIO
co-UsiApaStu_creating_new_blocks
WIZARD_NEW_BLOCK_TYPE_SELECTION
ta-UsiApaStu_creating_a_block_with_the_block_editor
WIZARD_NEW_SCENARIO_BLOCK
ta-UsiApaStu_creating_a_block_from_an_epl_event_definition
WIZARD_NEW_EVENT_BLOCK_TRANSLATOR
ta-UsiApaStu_adding_epl_code_to_a_block
ta-UsiApaStu_creating_new_scenario_functions
WIZARD_NEW_SCENARIO_FUNCTION
ta-UsiApaStu_creating_new_dashboards
DASHBOARD_NEW_CONFIG_WIZARD
ta-UsiApaStu_creating_new_dashboard_deployment_configurations
ta-UsiApaStu_creating_new_event_files
WIZARD_NEW_EVENT_FILE
ta-UsiApaStu_event_type_selection
EVENT_BROWSER_DIALOG
ta-UsiApaStu_adding_resources_to_epl_projects
ta-UsiApaStu_adding_resources_to_apama_java_projects
ta-UsiApaStu_java_configuration_editor
APAMA_JAVA_CONFIG_EDITOR
ta-UsiApaStu_adding_apama_java_applications
ta-UsiApaStu_adding_apama_java_classes
APAMA_JAVA_CONFIG_ADD_CLASSES
ta-UsiApaStu_adding_non_apama_java_files
APAMA_JAVA_CONFIG_ADD_EXTRA_CONTENT
ta-UsiApaStu_adding_bundles_to_projects
ta-UsiApaStu_bundle_instances
SELECT_BUNDLE_INSTANCE_DIALOG
ta-UsiApaStu_adding_adapters_to_projects
SELECT_ADAPTER_INSTANCE_DIALOG
co-UsiApaStu_connectivity_bundles
co-UsiApaStu_linked_resources
ta-UsiApaStu_using_digital_event_service_connectivity_bundle
APAMA_DIGITAL_EVENTS_EDITOR
ta-UsiApaStu_adding_universal_messaging_connectivity_plugin_to_projects
ta-UsiApaStu_adding_the_mqtt_connectivity_plugin_to_a_project
ta-UsiApaStu_adding_the_http_client_connectivity_plugin_to_a_project
co-UsiApaStu_um_adding_config_to_project
ta-UsiApaStu_editing_apama_files
EditorView
ta-UsiApaStu_obtaining_content_assistance
ta-UsiApaStu_using_auto_completion
ta-UsiApaStu_displaying_information_for_events_and_actions
ta-UsiApaStu_specifying_comments
ta-UsiApaStu_using_auto_indent
ta-UsiApaStu_using_auto_bracketing
ta-UsiApaStu_using_tabs
ta-UsiApaStu_defining_shorthand__templates__for_frequently_used_epl_code
ta-UsiApaStu_sharing_templates_among_apama_studio_installations
ta-UsiApaStu_specifying_colors_to_distinguish_epl_elements
ta-UsiApaStu_shortcuts_when_editing_apama_files
ta-UsiApaStu_navigating_in_apama_files
ta-UsiApaStu_using_the_outline_view_to_navigate
ta-UsiApaStu_using_the_quick_outline_to_navigate
ta-UsiApaStu_jumping_to_an_event_or_action_definition_or_variable_declaration
ta-UsiApaStu_opening_epl_elements_java_classes_using_open_type_dialog
OPEN_TYPE_DIALOG
ta-UsiApaStu_searching_in_epl_files
MonitorScriptSearch
ta-UsiApaStu_search_tab
MonitorScriptSearchView
ta-UsiApaStu_building_apama_projects
ta-UsiApaStu_build_automatically_when_a_resource_changes
ta-UsiApaStu_build_all_apama_projects
ta-UsiApaStu_build_one_apama_project
ta-UsiApaStu_build_a_working_set
ta-UsiApaStu_clean_and_rebuild_projects
ta-UsiApaStu_configuring_the_project_build_path
ProjectSettings
ta-UsiApaStu_project_source_files
BuildPathSource
ta-UsiApaStu_specifying_projects
BuildPathProjects
ta-UsiApaStu_specifying_external_dependencies
BuildPathExternalDependency
ta-UsiApaStu_specifying_dependencies_for_a_single_user_project
ta-UsiApaStu_specifying_dependencies_for_a_multi_user_project
NewVariableDepend
ta-UsiApaStu_specifying_the_project_bundles_properties
BUNDLES_PROPERTIES_PAGE
ta-UsiApaStu_defining_monitorscript_build_path_variables
ta-UsiApaStu_importing_projects
ta-UsiApaStu_importing_adapters
ImportWizard
co-UsiApaStu_defining_ste_file
ta-UsiApaStu_exporting_project_information
ta-UsiApaStu_exporting_a_project_initialization_file_list
WIZARD_EXPORT_EMM_INITIALIZATION_LIST
ta-UsiApaStu_exporting_a_launch_configuration
ANT_EXPORT_PAGE
ta-UsiApaStu_exporting_scenarios_as_block_templates
WIZARD_EXPORT_AS_BLOCK_SCENARIO_SELECTION
ta-UsiApaStu_exporting_scenarios_as_epl
WIZARD_EXPORT_SCENARIO_AS_MONITORSCRIPT
ta-UsiApaStu_exporting_correlator_deployment_packages
CDP_WIZARD_PROJECT_SELECTION_PAGE
ta-UsiApaStu_exporting_apama_adapters
ExportWizard
ta-UsiApaStu_exporting_apamadoc
ta-UsiApaStu_deleting_projects_and_resources
ta-UsiApaStu_deleting_resources
ta-UsiApaStu_deleting_projects
ta-UsiApaStu_adding_the_apama_nature_to_a_project
ta-UsiApaStu_adding_java_support_to_an_apama_project
co-UsiApaStu_epl_objects_view
EPL_OBJECTS_BROWSE_VIEW
ta-UsiApaStu_internationalizing_apama_applications
ta-UsiApaStu_checking_the_error_log
ta-UsiApaStu_specifying_an_adapter_in_a_launch_configuration
ADAPTER_CONFIGURATION_DIALOG
co-UsiApaStu_configuring_adapters_for_UM
co-UsiApaStu_using_query_designer
ta-UsiApaStu_adding_query_file
NEW_APAMA_QUERY_FILE_WIZARD
co-UsiApaStu_steps_for_using_studio_to_implement_queries
co-UsiApaStu_overview_of_query_designer
QUERY_DESIGNER_DESIGN_TAB
co-UsiApaStu_creating_queries
ta-UsiApaStu_configuring_queries_to_import_definitions
QUERY_AGGREGATES_NAMESPACE_DIALOG
ta-UsiApaStu_adding_query_inputs
QUERY_INPUT_DEFINITION_DIALOG
ta-UsiApaStu_adding_query_patterns
QUERY_EVENT_PALETTE
ta-UsiApaStu_adding_query_parameters
QUERY_PARAMETER_DIALOG
co-UsiApaStu_adding_query_conditions
ta-UsiApaStu_adding_query_filters
QUERY_CONDITIONS_WHERE_CLAUSE_DIALOG
ta-UsiApaStu_adding_query_time_constraints
QUERY_CONDITIONS_WITHIN_CLAUSE_DIALOG
ta-UsiApaStu_adding_query_exclusions
QUERY_CONDITIONS_WITHOUT_CLAUSE_DIALOG
ta-UsiApaStu_adding_query_aggregates
co-UsiApaStu_adding_query_aggregate_calculation
QUERY_AGGREGATES_SELECT_CLAUSE_DIALOG
co-UsiApaStu_adding_query_aggregate_filter
QUERY_AGGREGATES_HAVING_CLAUSE_DIALOG
ta-UsiApaStu_adding_query_actions
ta-UsiApaStu_adding_query_send_action
QUERY_ACTION_SEND_DIALOG
ta-UsiApaStu_adding_query_custom_action
QUERY_ACTION_CUSTOM_EPL_DIALOG
co-UsiApaStu_query_designer_time_specification
co-UsiApaStu_editing_source_in_query_designer
QUERY_DESIGNER_SOURCE_TAB
co-UsiApaStu_query_designer_error_handling
ta-UsiApaStu_enabling_diagnostic_logging
co-UsiApaStu_configuring_query_applications
co-UsiApaStu_exporting_query_deployment_scripts
co-UsiApaStu_launching_projects
ta-UsiApaStu_running_apama_projects
ta-UsiApaStu_default_launch_configuration
ta-UsiApaStu_workbench_perspective
ta-UsiApaStu_developer_perspective
ta-UsiApaStu_defining_custom_launch_configurations
RunMonitorScript
ta-UsiApaStu_adding_a_correlator
ta-UsiApaStu_correlator_arguments
CorrelatorArguments
co-UsiApaStu_persistence_options
PERSISTENCE_CORRELATOR_CONFIGURATION_DIALOG_ARGUMENTS_TAB
co-UsiApaStu_connectivity
ta-UsiApaStu_initialization
CORRELATOR_CONFIGURATION_DIALOG_INITIALIZATION_TAB
co-UsiApaStu_launch_config_event_files_tab
CORRELATOR_CONFIGURATION_DIALOG_EVENT_TAB
ta-UsiApaStu_configuring_correlator_log_settings_in_designer
co-UsiApaStu_connecting_components
ENGINE_CONNECT_CONFIGURATION_DIALOG
ta-UsiApaStu_adding_an_external_process
EXTERNAL_PROCESS_CONFIGURATION_DIALOG
ta-UsiApaStu_testing_a_subset_of_your_apama_application
ta-UsiApaStu_monitoring_apama_applications
ta-UsiApaStu_console_view
ta-UsiApaStu_using_the_engine_information_view
ta-UsiApaStu_using_the_engine_receive_view
ENGINE_RECEIVE_VIEW
ta-UsiApaStu_engine_receive_viewer_preferences
ENGINE_RECEIVE_OPTIONS_DIALOG
ta-UsiApaStu_specifying_channels_for_the_engine_receive_view
ENGINE_RECEIVE_CHANNEL_SELECTION_DIALOG
ta-UsiApaStu_using_the_engine_status_view
ta-UsiApaStu_using_the_scenario_browser_view
SCENARIO_BROWSER_PROJECT_VIEW
ta-UsiApaStu_displaying_the_scenario_browser
ta-UsiApaStu_browsing_scenarios
INSTANCE_SUMMARY
ta-UsiApaStu_creating_new_instances_of_scenarios
ta-UsiApaStu_viewing_scenario_instances
ta-UsiApaStu_editing_a_scenario_instance
ta-UsiApaStu_deleting_a_scenario_instance
ta-UsiApaStu_deleting_all_scenario_instances
ta-UsiApaStu_dashboards
co-UsiApaStu_debugging_epl_applications
ta-UsiApaStu_adding_breakpoints
ta-UsiApaStu_launching_a_debug_session
ta-UsiApaStu_creating_a_debug_configuration
ta-UsiApaStu_debugging_a_remote_application
RemoteRunMonitorScript
ta-UsiApaStu_debug_view
debug_view_context
ta-UsiApaStu_breakpoints_view
breakpoint_view_context
ta-UsiApaStu_variables_view
variable_view_context
ta-UsiApaStu_command_line_debugger
co-UsiApaStu_debugging_apama_java_applications
ta-UsiApaStu_preparing_the_correlator_for_remote_debugging
ta-UsiApaStu_creating_a_debug_run_configuration
ta-UsiApaStu_debug_perspective
ta-UsiApaStu_using_the_debug_view
ta-UsiApaStu_working_with_breakpoints
ta-UsiApaStu_viewing_stack_frame_variables
ta-UsiApaStu_example_debug_session
ta-UsiApaStu_debug_example_of_preparing_code_and_jar_file
ta-UsiApaStu_debug_example_of_starting_correlator_and_injecting_application
ta-UsiApaStu_example_of_debugging_in_apama_studio
ta-UsiApaStu_additional_resources_for_java_debugging
co-UsiApaStu_profiling_epl_applications
co-UsiApaStu_launching_profiling_sessions
ta-UsiApaStu_launching_a_default_profiling_session
ta-UsiApaStu_launching_a_custom_profiling_session
ta-UsiApaStu_creating_a_custom_profile_launch_configuration
ta-UsiApaStu_profile_configurations_launch
ProfileMonitorScript
ta-UsiApaStu_launching_a_remote_profiling_session
ta-UsiApaStu_creating_a_remote_profiler_launch_configuration
PROFILER_ConnectionDetailsTab
ta-UsiApaStu_the_apama_profiler_perspective
ta-UsiApaStu_profiling_monitor_view
PROFILER_ProfileLaunchView_View
co-UsiApaStu_execution_statistics_view
PROFILER_ExecutionStatisticsView_VIEW_NORMAL_TAB
co-UsiApaStu_the_execution_statistics_tab
PROFILER_CHOOSE_COLUMNS
co-UsiApaStu_comparison_of_execution_statistics_tab
ta-UsiApaStu_viewing_epl_code
ta-UsiApaStu_using_filters
ta-UsiApaStu_creating_a_filter
PROFILER_CREATE_FILTER
ta-UsiApaStu_managing_filters
PROFILER_MANAGE_FILTER
ta-UsiApaStu_taking_snapshots
PROFILER_CREATE_SNAPSHOT
ta-UsiApaStu_using_snapshots
PROFILER_MANAGE_SNAPSHOT
ta-UsiApaStu_choosing_profiling_information_columns
ta-UsiApaStu_updating_profile_data
ta-UsiApaStu_displaying_apama_perspective_preferences
co-UsiApaStu_using_the_data_player
ta-UsiApaStu_introduction_to_the_data_player
ta-UsiApaStu_using_the_data_player
ta-UsiApaStu_adding_the_adbc_adapter
ta-UsiApaStu_launching_the_project
ta-UsiApaStu_specifying_playback_queries
DATAPLAYER_EDITOR
re-UsiApaStu_data_player_control_view
DATAPLAYER_VIEW
re-UsiApaStu_playback_settings
DATAPLAYER_PREFERENCE_DIALOG
re-UsiApaStu_playback_controls
DATAPLAYER_DATE_TIME_CONTROL
re-UsiApaStu_playback_status
DATAPLAYER_PROMPT_RESTART
ta-UsiApaStu_creating_query_templates
ta-UsiApaStu_command_line_data_player_interface
co-UsiApaStu_setting_the_apama_preferences
ta-UsiApaStu_showing_the_apama_specific_preferences
re-UsiApaStu_preferences_apama
PrefApamaInstall
re-UsiApaStu_preferences_catalogs
CATALOGS_PREFERENCES_PAGE
re-UsiApaStu_preferences_adapters
ADAPTERS_PREFERENCES_PAGE
re-UsiApaStu_preferences_webservice
WEB_SERVICE_PREFERENCES_PAGE
re-UsiApaStu_preferences_monitorscript
PrefMonitorScript
re-UsiApaStu_preferences_editor_colors
PrefColors
re-UsiApaStu_preferences_editor_formatting
PrefFormatting
re-UsiApaStu_preferences_editor_templates
PrefTemplates
re-UsiApaStu_preferences_monitorscript_path_variables
PrefVariables
re-UsiApaStu_preferences_profiling_and_logging
PROFILE_PREFERENCES_PAGE
re-UsiApaStu_preferences_query
PrefQuery
re-UsiApaStu_preferences_syntax_coloring
re-UsiApaStu_preferences_scenarios
PREFERENCE_PAGE_SCENARIOS
re-UsiApaStu_preferences_workbench
WORKBENCH_PREFERENCES_PAGE
to-help_developing_apama_applications
co-DevApaApp_preface
co-DevApaAppInEpl_how_this_book_is_organized
co-DevApaAppInEpl_getting_started_with_apama_epl
tutorialMSmain
co-DevApaAppInEpl_introduction_to_apama_event_processing_language
co-DevApaAppInEpl_how_epl_applications_compare_to_applications_in_other_languages
co-DevApaAppInEpl_about_dynamic_compilation_in_the_correlator
co-DevApaAppInEpl_about_apama_studio_development_environment
co-DevApaAppInEpl_terminology
co-DevApaAppInEpl_defining_event_types
tutorialEventTypes
co-DevApaAppInEpl_allowable_event_field_types
re-DevApaAppInEpl_format_for_defining_event_types
co-DevApaAppInEpl_example_event_type_definition
co-DevApaAppInEpl_working_with_events
ta-DevApaAppInEpl_making_event_type_definitions_available_to_monitors
co-DevApaAppInEpl_channels_and_input_events
co-DevApaAppInEpl_defining_monitors
tutorialMonitors
co-DevApaAppInEpl_about_monitor_contents
co-DevApaAppInEpl_loading_monitors_into_the_correlator
ta-DevApaAppInEpl_terminating_monitors
ta-DevApaAppInEpl_unloading_monitors_from_the_correlator
co-DevApaAppInEpl_example_of_a_simple_monitor
co-DevApaAppInEpl_spawning_monitor_instances
tutorialSpawnMonitors
co-DevApaAppInEpl_how_spawning_works
co-DevApaAppInEpl_sample_code_for_spawning
ta-DevApaAppInEpl_terminating_monitor_instances
co-DevApaAppInEpl_about_executing_ondie___actions
ta-DevApaAppInEpl_specifying_parameters_when_spawning
co-DevApaAppInEpl_communication_among_monitor_instances
co-DevApaAppInEpl_organizing_behavior_into_monitors
co-DevApaAppInEpl_event_processing_order
tutorialEventProcessOrder
ta-DevApaAppInEpl_allocating_events
ta-DevApaAppInEpl_sending_events_to_other_monitors
ta-DevApaAppInEpl_defining_your_application_s_message_exchange_protocol
ta-DevApaAppInEpl_using_events_to_control_processing
co-DevApaAppInEpl_about_service_monitors
co-DevApaAppInEpl_adding_predefined_annotations
co-DevApaAppInEpl_subscribe_to_channel
co-DevApaAppInEpl_channels_about_default
co-DevApaAppInEpl_channels_about_wildcard
ta-DevApaAppInEpl_adding_a_bundle_to_your_project
re-DevApaAppInEpl_utilities_for_operating_on_monitors
co-EplQueRun_defining_queries
co-EplQueRun_introduction_to_queries
co-EplQueRun_example_of_a_query
co-EplQueRun_use_cases_for_queries
co-EplQueRun_delayed_and_out_of_order_events
co-EplQueRun_query_terminology
co-EplQueRun_overview_of_query_processing
co-EplQueRun_overview_of_implementing_queries
co-EplQueRun_format_of_query_definitions
co-EplQueRun_defining_metadata
QUERY_METADATA_ENTRY_DIALOG
co-EplQueRun_partitioning_queries
co-EplQueRun_defining_query_keys
co-EplQueRun_defining_actions_as_query_keys
co-EplQueRun_query_partition_example_with_one_input
co-EplQueRun_query_partition_example_with_multiple_inputs
co-EplQueRun_ensuring_matching_names_in_key_specifications
co-EplQueRun_defining_query_input
co-EplQueRun_format_of_input_definitions
co-EplQueRun_behavior_when_there_is_more_than_one_input
co-EplQueRun_specifying_event_duration_in_windows
co-EplQueRun_using_the_output_of_another_query_as_query_input
co-EplQueRun_specifying_maximum_number_of_events_in_windows
co-EplQueRun_specifying_event_duration_and_maximum_number_of_events
co-EplQueRun_using_source_time_stamps_of_events
co-EplQueRun_using_heartbeat_events_with_sourcetime_stamps
co-EplQueRun_out_of_order_events
co-EplQueRun_matching_only_the_latest_event_for_a_given_field
co-EplQueRun_finding_and_acting_on_event_patterns
co-EplQueRun_defining_event_patterns
co-EplQueRun_query_followed_by_operator
co-EplQueRun_query
co-EplQueRun_query_or_operator
co-EplQueRun_query_wait_operator
co-EplQueRun_query_conditions
co-EplQueRun_query_condition_ranges
co-EplQueRun_special_behavior_of
co-EplQueRun_aggregating_event_field_values
co-EplQueRun_event_matching_policy
co-EplQueRun_acting_on_pattern_matches
co-EplQueRun_defining_actions_in_queries
co-EplQueRun_defining_query_parameters
co-EplQueRun_parameterized_queries_as_templates
co-EplQueRun_managing_parameterized_queries
co-EplQueRun_referring_to_parameters_in_queries
co-EplQueRun_scaling_and_performance_of_parameterized_queries
co-EplQueRun_restrictions_in_queries
co-EplQueRun_best_practices_for_defining_queries
co-EplQueRun_troubleshooting_query_execution
co-EplQueRun_communication_between_monitors_and_queries
co-DevApaAppInEpl_defining_event_listeners
ta-DevApaAppInEpl_about_event_expressions_and_event_templates
tutorialComplexEvents
re-DevApaAppInEpl_specifying_the_on_statement
re-DevApaAppInEpl_using_a_stream_source_template_to_find_events_of_interest
co-DevApaAppInEpl_defining_event_expressions_with_one_event_template
ta-DevApaAppInEpl_listening_for_one_event
ta-DevApaAppInEpl_listening_for_all_events_of_a_particular_type
ta-DevApaAppInEpl_listening_for_events_with_particular_content
ta-DevApaAppInEpl_using_positional_syntax_to_listen_for_events_with_particular_content
ta-DevApaAppInEpl_using_name_value_syntax_to_listen_for_events_with_particular_content
ta-DevApaAppInEpl_listening_for_events_of_different_types
ta-DevApaAppInEpl_terminating_and_changing_event_listeners
ta-DevApaAppInEpl_specifying_multiple_event_listeners
ta-DevApaAppInEpl_listening_for_events_that_do_not_match
ta-DevApaAppInEpl_specifying_completion_event_listeners
co-DevApaAppInEpl_example_using_unmatched_and_completed
ta-DevApaAppInEpl_improving_performance_by_ignoring_some_fields_in_matching_events
ta-DevApaAppInEpl_defining_event_listeners_for_patterns_of_events
co-DevApaAppInEpl_specifying_and_or_not_logic_in_event_listeners
ta-DevApaAppInEpl_specifying_the_or_operator_in_event_expressions
ta-DevApaAppInEpl_specifying_the_and_operator_in_event_expressions
co-DevApaAppInEpl_example_event_expressions_using_and_or_logic_in_event_listeners
ta-DevApaAppInEpl_specifying_the_not_operator_in_event_expressions
ta-DevApaAppInEpl_specifying_and_not_logic_to_terminate_event_listeners
ta-DevApaAppInEpl_pausing_event_listeners
ta-DevApaAppInEpl_choosing_which_action_to_execute
co-DevApaAppInEpl_detect_missing_events
co-DevApaAppInEpl_how_the_correlator_executes_event_listeners
co-DevApaAppInEpl_how_the_correlator_evaluates_event_expressions
ta-DevApaAppInEpl_avoiding_event_listeners_that_trigger_upon_instantiation
co-DevApaAppInEpl_when_the_correlator_terminates_event_listeners
co-DevApaAppInEpl_how_the_correlator_evaluates_event_listeners_for_a_series_of_events
ta-DevApaAppInEpl_evaluating_event_listeners_for_all_a_events_followed_by_b_events
ta-DevApaAppInEpl_evaluating_event_listeners_for_an_a_event_followed_by_all_b_events
ta-DevApaAppInEpl_evaluating_event_listeners_for_all_a_events_followed_by_all_b_events
co-DevApaAppInEpl_defining_event_listeners_with_temporal_constraints
ta-DevApaAppInEpl_listening_for_event_patterns_within_a_set_time
ta-DevApaAppInEpl_waiting_within_an_event_listener
ta-DevApaAppInEpl_triggering_event_listeners_at_specific_times
ta-DevApaAppInEpl_using_variables_to_specify_times
co-DevApaAppInEpl_understanding_time_in_the_correlator
co-DevApaAppInEpl_correlator_timestamps_and_real_time
co-DevApaAppInEpl_event_arrival_time
co-DevApaAppInEpl_about_timers_and_their_trigger_times
co-DevApaAppInEpl_disabling_the_correlator_s_internal_clock
ta-DevApaAppInEpl_generating_events_that_keep_time
co-DevApaAppInEpl_about_repeating_timers
ta-DevApaAppInEpl_setting_the_time_in_the_correlator
co-DevApaAppInEpl_out_of_band_connection_notifications
co-DevApaAppInEpl_working_with_streams_and_stream_queries
tutorialStreams
co-DevApaAppInEpl_introduction_to_streams_and_stream_networks
co-DevApaAppInEpl_defining_streams
ta-DevApaAppInEpl_creating_streams_from_event_templates
ta-DevApaAppInEpl_terminating_streams
co-DevApaAppInEpl_using_output_from_streams
co-DevApaAppInEpl_listener_variables_and_streams
co-DevApaAppInEpl_coassigning_to_sequences_in_stream_listeners
co-DevApaAppInEpl_defining_stream_queries
co-DevApaAppInEpl_linking_stream_queries_together
co-DevApaAppInEpl_simple_example_of_a_stream_network
re-DevApaAppInEpl_stream_query_definition_syntax
co-DevApaAppInEpl_stream_query_processing_flow
re-DevApaAppInEpl_specifying_input_streams_in_from_clauses
ta-DevApaAppInEpl_adding_window_definitions_to_from_and_join_clauses
re-DevApaAppInEpl_window_definition_syntax
ta-DevApaAppInEpl_defining_time_based_windows
ta-DevApaAppInEpl_defining_size_based_windows
ta-DevApaAppInEpl_combining_time_based_and_size_based_windows
ta-DevApaAppInEpl_defining_batched_windows
ta-DevApaAppInEpl_partitioning_streams
re-DevApaAppInEpl_partitions_and_aggregate_functions
co-DevApaAppInEpl_using_multiple_partition_by_expressions
co-DevApaAppInEpl_partitioning_time_based_windows
ta-DevApaAppInEpl_defining_content_dependent_windows
co-DevApaAppInEpl_joining_two_streams
re-DevApaAppInEpl_defining_cross_joins_with_two_from_clauses
tutorialStreamsCrossJoin
re-DevApaAppInEpl_defining_equi_joins_with_the_join_clause
re-DevApaAppInEpl_filtering_items_before_projection
co-DevApaAppInEpl_generating_query_results
co-DevApaAppInEpl_aggregating_items_in_projections
re-DevApaAppInEpl_filtering_items_in_projections
co-DevApaAppInEpl_ieee_special_values_in_stream_query_expressions
co-DevApaAppInEpl_defining_custom_aggregate_functions
co-DevApaAppInEpl_example_of_defining_a_custom_aggregate_function
co-DevApaAppInEpl_defining_actions_in_custom_aggregate_functions
co-DevApaAppInEpl_overloading_in_custom_aggregate_functions
ta-DevApaAppInEpl_distinguishing_duplicate_values_in_custom_aggregate_functions
co-DevApaAppInEpl_working_with_lots_that_contain_multiple_items
co-DevApaAppInEpl_stream_queries_that_generate_lots
co-DevApaAppInEpl_behavior_of_stream_queries_with_lots
co-DevApaAppInEpl_size_based_windows_and_lots
co-DevApaAppInEpl_join_operations_and_lots
co-DevApaAppInEpl_grouped_projections_and_lots
co-DevApaAppInEpl_stream_network_lifetime
co-DevApaAppInEpl_disconnection_vs_termination
co-DevApaAppInEpl_rules_for_termination_of_stream_networks
co-DevApaAppInEpl_using_dynamic_expressions_in_stream_queries
co-DevApaAppInEpl_behavior_of_static_and_dynamic_expressions_in_stream_queries
co-DevApaAppInEpl_when_to_avoid_dynamic_expressions_in_stream_queries
co-DevApaAppInEpl_ordering_and_side_effects_in_stream_queries
co-DevApaAppInEpl_understanding_when_the_correlator_evaluates_particular_expressions
co-DevApaAppInEpl_using_dynamic_expressions_in_windows
co-DevApaAppInEpl_using_dynamic_expressions_in_equi_joins
co-DevApaAppInEpl_using_dynamic_expressions_in_where_predicates
co-DevApaAppInEpl_using_dynamic_expressions_in_projections
co-DevApaAppInEpl_examples_of_using_dynamic_expressions_in_stream_queries
co-DevApaAppInEpl_example_of_altering_query_window_size_or_period
co-DevApaAppInEpl_example_of_altering_a_threshold
co-DevApaAppInEpl_example_of_looking_up_values_in_a_dictionary
co-DevApaAppInEpl_example_of_actions_and_methods_in_dynamic_expressions
co-DevApaAppInEpl_troubleshooting_and_stream_query_coding_guidelines
co-DevApaAppInEpl_prefer_on_statements_to_from_statements
co-DevApaAppInEpl_know_when_to_spawn_and_when_to_partition
co-DevApaAppInEpl_filter_early_to_minimize_resource_usage
co-DevApaAppInEpl_avoid_duplication_of_stream_source_template_expressions
co-DevApaAppInEpl_avoid_using_large_windows_where_possible
co-DevApaAppInEpl_in_some_cases_prefer_retain_all_to_a_timed_window
co-DevApaAppInEpl_prefer_equi_joins_to_cross_joins
co-DevApaAppInEpl_be_aware_that_time_based_windows_can_empty
co-DevApaAppInEpl_be_aware_that_fixed_size_windows_can_overflow
co-DevApaAppInEpl_beware_of_accidental_stream_leaks
co-DevApaAppInEpl_defining_what_happens_when_matching_events_are_found
co-DevApaAppInEpl_using_variables
ta-DevApaAppInEpl_using_global_variables
ta-DevApaAppInEpl_using_local_variables
ta-DevApaAppInEpl_using_variables_in_listener_actions
ta-DevApaAppInEpl_specifying_named_constant_values
co-DevApaAppInEpl_defining_actions
re-DevApaAppInEpl_format_for_defining_actions
ta-DevApaAppInEpl_invoking_an_action_from_another_action
co-DevApaAppInEpl_specifying_actions_in_event_definitions
co-DevApaAppInEpl_using_action_type_variables
co-DevApaAppInEpl_defining_static_actions
ta-DevApaAppInEpl_getting_the_current_time
ta-DevApaAppInEpl_generating_events
ta-DevApaAppInEpl_generating_events_with_the_route_command
tutorialRouteEvents
ta-DevApaAppInEpl_generating_events_with_the_sendto_command
co-DevApaAppInEpl_sendto_channel_object
ta-DevApaAppInEpl_generating_events_with_the_enqueue_command
co-DevApaAppInEpl_enqueuing_to_contexts
ta-DevApaAppInEpl_generating_events_to_emit_to_outside_receivers
tutorialEmitEvents
ta-DevApaAppInEpl_assigning_values
co-DevApaAppInEpl_defining_conditional_logic_with_the_if_statement
tutorialConditionalLogic
co-DevApaAppInEpl_defining_conditional_logic_with_the_ifpresent_statement
ta-DevApaAppInEpl_defining_loops
co-DevApaAppInEpl_exception_handling
ta-DevApaAppInEpl_logging_and_printing
re-DevApaAppInEpl_specifying_log_statements
co-DevApaAppInEpl_log_levels_determine_results_of_log_statements
co-DevApaAppInEpl_where_do_log_entries_go_
co-DevApaAppInEpl_examples_of_using_log_statements
co-DevApaAppInEpl_strings_in_print_and_log_statements
co-DevApaAppInEpl_sample_financial_application
co-DevApaAppInEpl_implementing_parallel_processing
tutorialMultipleMonitors
co-DevApaAppInEpl_introduction_to_contexts
ta-DevApaAppInEpl_what_is_inside_outside_a_context_
co-DevApaAppInEpl_about_context_properties
co-DevApaAppInEpl_context_lifecycle
co-DevApaAppInEpl_comparison_of_a_correlator_and_a_context
ta-DevApaAppInEpl_creating_contexts
co-DevApaAppInEpl_how_many_contexts_can_you_create_
co-DevApaAppInEpl_using_channels_to_communicate_between_contexts
ta-DevApaAppInEpl_obtaining_context_references
ta-DevApaAppInEpl_spawning_to_contexts
co-DevApaAppInEpl_channels_and_contexts
co-DevApaAppInEpl_sending_an_event_to_a_channel
ta-DevApaAppInEpl_enqueuing_an_event_to_a_particular_context
ta-DevApaAppInEpl_enqueuing_an_event_to_a_sequence_of_contexts
co-DevApaAppInEpl_common_use_cases_for_contexts
co-DevApaAppInEpl_samples_for_implementing_contexts
co-DevApaAppInEpl_simple_sample_implementation_of_contexts
ta-DevApaAppInEpl_running_samples_of_common_concurrency_problems
co-DevApaAppInEpl_about_the_samples_of_concurrency_problems
co-DevApaAppInEpl_about_the_race_sample
co-DevApaAppInEpl_about_the_deadlock_sample
co-DevApaAppInEpl_about_the_compareswap_sample
co-DevApaAppInEpl_contexts_and_correlator_determinism
co-DevApaAppInEpl_how_contexts_affect_other_parts_of_your_apama_application
co-DevApaAppInEpl_about_replay_logs_and_parallel_processing
co-DevApaAppInEpl_deadlock_avoidance_when_parallel_processing
co-DevApaAppInEpl_clock_ticks_when_parallel_processing
ta-DevApaAppInEpl_using_epl_plug_ins_in_parallel_processing_applications
co-DevApaAppInEpl_using_correlator_persistence
co-DevApaAppInEpl_description_of_state_that_can_be_persistent
co-DevApaAppInEpl_when_persistence_is_useful
co-DevApaAppInEpl_when_non_persistent_monitors_are_useful
co-DevApaAppInEpl_how_the_correlator_persists_state
co-DevApaAppInEpl_enabling_correlator_persistence
co-DevApaAppInEpl_how_the_correlator_recovers_state
co-DevApaAppInEpl_recovery_order
co-DevApaAppInEpl_defining_recovery_actions
co-DevApaAppInEpl_simplest_recovery_use_case
co-DevApaAppInEpl_designing_applications_for_persistence_enabled_correlators
co-DevApaAppInEpl_upgrading_monitors_in_a_persistence_enabled_correlator
co-DevApaAppInEpl_sample_code_for_persistence_applications
co-DevApaAppInEpl_sample_code_for_discarding_stale_state_during_recovery
co-DevApaAppInEpl_sample_code_for_recovery_behavior_based_on_downtime_duration
co-DevApaAppInEpl_sample_code_that_recovers_subscription_to_non_persistent_monitor
co-DevApaAppInEpl_requesting_snapshots
co-DevApaAppInEpl_developing_persistence_applications
co-DevApaAppInEpl_using_epl_plug_ins_when_persistence_is_enabled
co-DevApaAppInEpl_using_the_memorystore_when_persistence_is_enabled
co-DevApaAppInEpl_comparison_of_correlator_persistence_with_other_persistence_mechanisms
co-DevApaAppInEpl_restrictions_on_correlator_persistence
co-DevApaAppInEpl_common_epl_patterns
co-DevApaAppInEpl_contrasting_using_a_dictionary_with_spawning
tutorialDictionary
co-DevApaAppInEpl_translation_using_a_dictionary
co-DevApaAppInEpl_translation_using_spawning
co-DevApaAppInEpl_factory_pattern
co-DevApaAppInEpl_canonical_factory_pattern
co-DevApaAppInEpl_alternate_factory_pattern
co-DevApaAppInEpl_using_quit___to_terminate_event_listeners
co-DevApaAppInEpl_combining_the_dictionary_and_factory_patterns
co-DevApaAppInEpl_testing_uniqueness
co-DevApaAppInEpl_reference_counting
co-DevApaAppInEpl_inline_request_response_pattern
co-DevApaAppInEpl_routing_events_for_request_response_behavior
co-DevApaAppInEpl_canonical_form_for_synchronous_requests
co-DevApaAppInEpl_writing_echo_monitors_for_debugging
co-DevApaAppInEpl_using_epl_plug_ins
co-DevApaAppInEpl_overhead_of_using_plug_ins
co-DevApaAppInEpl_when_to_use_plug_ins
co-DevApaAppInEpl_when_not_to_use_plug_ins
re-DevApaAppInEpl_using_the_time_format_plug_in
re-DevApaAppInEpl_time_format_plug_in_format_functions
re-DevApaAppInEpl_time_format_plug_in_parse_functions
co-DevApaAppInEpl_format_specification_for_the_time_format_plug_in_functions
co-DevApaAppInEpl_using_the_memorystore
tutorialPersistData
co-DevApaAppInEpl_introduction_to_using_the_memorystore
co-DevApaAppInEpl_overview_of_memorystore_events
ta-DevApaAppInEpl_adding_the_memorystore_bundle_to_your_project
co-DevApaAppInEpl_overview_of_steps_for_using_the_memorystore
ta-DevApaAppInEpl_preparing_and_opening_stores
co-DevApaAppInEpl_description_of_row_structures
ta-DevApaAppInEpl_preparing_and_opening_tables
ta-DevApaAppInEpl_using_transactions_to_manipulate_rows
ta-DevApaAppInEpl_determining_which_commit_action_to_call
ta-DevApaAppInEpl_creating_and_removing_rows
ta-DevApaAppInEpl_iterating_over_the_rows_in_a_table
ta-DevApaAppInEpl_requesting_persistence
co-DevApaAppInEpl_exposing_in_memory_or_persistent_data_to_dashboards
co-DevApaAppInEpl_restrictions_affecting_memorystore_disk_files
co-DevApaAppInEpl_using_the_distributed_memorystore
co-DevApaAppInEpl_overview_of_the_distributed_memorystore
co-DevApaAppInEpl_distributed_store_transactional_and_data_safety_guarantees
co-DevApaAppInEpl_using_a_distributed_store
co-DevApaAppInEpl_configuring_a_distributed_store
ta-DevApaAppInEpl_adding_distributed_memorystore_support_to_a_project
ta-DevApaAppInEpl_adding_a_distributed_store
AddNewDistMemStore
ta-DevApaAppInEpl_configuring_a_distributed_store
DistMemStoreAdapterEditor
co-DevApaAppInEpl_launching_a_project_that_uses_a_distributed_store
co-DevApaAppInEpl_interacting_with_a_distributed_store
co-DevApaAppInEpl_configuration_files_for_distributed_stores
co-DevApaAppInEpl_bigmemory_driver_properties
co-DevApaAppInEpl_changing_bean_property_values_when_deploying_projects
co-DevApaAppInEpl_creating_a_distributed_memorystore_driver
co-DevApaAppInEpl_using_the_management_interface
ta-DevApaAppInEpl_using_matlab__products_in_an_application
co-DevApaAppInEpl_matlabmanager_actions
co-DevApaAppInEpl_matlab_examples
ta-DevApaAppInEpl_interfacing_with_user_defined_epl_plug_ins
co-DevApaAppInEpl_about_the_chunk_data_type
co-DevApaAppInEpl_making_application_data_available_to_clients
tutorialDataViews
ta-DevApaAppInEpl_adding_the_dataview_service_bundle_to_your_project
co-DevApaAppInEpl_creating_dataview_definitions
co-DevApaAppInEpl_deleting_dataview_definitions
co-DevApaAppInEpl_creating_dataview_items
co-DevApaAppInEpl_deleting_dataview_items
co-DevApaAppInEpl_updating_dataview_items
co-DevApaAppInEpl_looking_up_field_positions
co-DevApaAppInEpl_using_multiple_correlators
co-DevApaAppInEpl_testing_and_tuning_epl
ta-DevApaAppInEpl_optimizing_epl_programs
co-DevApaAppInEpl_best_practices_for_writing_epl
co-DevApaAppInEpl_wildcard_fields_that_are_not_relevant
ta-DevApaAppInEpl_avoiding_unnecessary_allocations
ta-DevApaAppInEpl_implementing_states
co-DevApaAppInEpl_structure_of_a_basic_test_framework
ta-DevApaAppInEpl_using_event_files
ta-DevApaAppInEpl_handling_runtime_errors
co-DevApaAppInEpl_what_happens
ta-DevApaAppInEpl_using_ondie___to_diagnose_runtime_errors
ta-DevApaAppInEpl_using_logging_to_diagnose_errors
co-DevApaAppInEpl_standard_diagnostic_log_output
ta-DevApaAppInEpl_capturing_test_output
ta-DevApaAppInEpl_avoiding_listeners_and_monitor_instances_that_never_terminate
ta-DevApaAppInEpl_handling_slow_or_blocked_receivers
ta-DevApaAppInEpl_diagnosing_infinite_loops_in_the_correlator
co-DevApaAppInEpl_tuning_contexts
co-DevApaAppInEpl_parallel_processing_for_instances_of_an_event_type
co-DevApaAppInEpl_parallel_processing_for_long_running_calculations
co-DevApaAppInEpl_generating_documentation_for_your_epl_code
co-DevApaAppInEpl_code_constructs_that_are_documented
ta-DevApaAppInEpl_steps_for_using_apamadoc
WIZARD_EXPORT_APAMADOC
ta-DevApaAppInEpl_inserting_apamadoc_comments
ta-DevApaAppInEpl_inserting_apamadoc_tags
ta-DevApaAppInEpl_inserting_apamadoc_references
ta-DevApaAppInEpl_inserting_epl_source_code_examples
co-DevApaAppInEpl_generating_apamadoc_from_an_ant_script
co-DevApaAppInEveMod_how_this_book_is_organized
tutorialEMintro
co-DevApaAppInEveMod_overview_of_using_event_modeler
EventModelerEditor
co-DevApaAppInEveMod_event_modeler_layout
co-DevApaAppInEveMod_about_event_flow_states
tutorialEMstates
co-DevApaAppInEveMod_how_rules_define_scenario_behavior
tutorialEMrules
co-DevApaAppInEveMod_description_of_rule_conditions
co-DevApaAppInEveMod_description_of_rule_actions
co-DevApaAppInEveMod_description_of_functions_in_rules
co-DevApaAppInEveMod_about_rule_evaluation
co-DevApaAppInEveMod_basic_view_of_rule_processing
co-DevApaAppInEveMod_expanded_view_of_rule_processing
co-DevApaAppInEveMod_scenario_monitoring_stage
co-DevApaAppInEveMod_summary_of_adding_rules_when_a_variable_value_changes
co-DevApaAppInEveMod_about_scenario_variables
tutorialEMvariables
co-DevApaAppInEveMod_variable_types
co-DevApaAppInEveMod_auto_typing_of_variables
co-DevApaAppInEveMod_variable_properties
co-DevApaAppInEveMod_variable_constraints
co-DevApaAppInEveMod_user_input_and_output
co-DevApaAppInEveMod_about_blocks
tutorialEMblocks
ta-DevApaAppInEveMod_linking_variables__block_parameters__and_block_output_fields
co-DevApaAppInEveMod_using_event_modeler
tutorialEMinterface
ta-DevApaAppInEveMod_adding_scenarios_to_projects
ta-DevApaAppInEveMod_creating_the_globalruleexample_project
ta-DevApaAppInEveMod_adding_globalruleexample_sdf_to_the_globalruleexample_project
ta-DevApaAppInEveMod_adding_a_new_scenario_to_the_globalruleexample_project
ta-DevApaAppInEveMod_opening_and_viewing_multiple_scenarios
ta-DevApaAppInEveMod_selecting_from_the_scenario_menu
re-DevApaAppInEveMod_the_event_modeler_toolbar
ta-DevApaAppInEveMod_interacting_with_the_tabs_and_panels
ta-DevApaAppInEveMod_working_in_the_event_flow_panel
ta-DevApaAppInEveMod_interacting_with_states
ta-DevApaAppInEveMod_selecting_a_state
ta-DevApaAppInEveMod_resizing_a_state
ta-DevApaAppInEveMod_moving_a_state
ta-DevApaAppInEveMod_multiple_selection
ta-DevApaAppInEveMod_adding_a_state
ta-DevApaAppInEveMod_the_finished_status
ta-DevApaAppInEveMod_deleting_a_state
ta-DevApaAppInEveMod_labeling_a_state
ta-DevApaAppInEveMod_using_cut_copy_paste_with_states
ta-DevApaAppInEveMod_interacting_with_transitions
ta-DevApaAppInEveMod_adding_a_transition
ta-DevApaAppInEveMod_selecting_a_transition
ta-DevApaAppInEveMod_changing_end_points
ta-DevApaAppInEveMod_changing_the_shape_of_a_transition
ta-DevApaAppInEveMod_labeling_a_transition
ta-DevApaAppInEveMod_deleting_a_transition
ta-DevApaAppInEveMod_using_cut_copy_paste_with_transitions
ta-DevApaAppInEveMod_displaying_global_rule_transitions
ta-DevApaAppInEveMod_working_in_the_rules_panel
ta-DevApaAppInEveMod_adding_a_rule
co-DevApaAppInEveMod_about_global_rules
ta-DevApaAppInEveMod_selecting_rules_and_rule_elements
ta-DevApaAppInEveMod_re_ordering_rules
ta-DevApaAppInEveMod_deleting_a_rule
ta-DevApaAppInEveMod_labeling_a_rule
ta-DevApaAppInEveMod_changing_a_rule_s_description
ta-DevApaAppInEveMod_minimizing_and_maximizing_a_rule
ta-DevApaAppInEveMod_cutting__copying__and_pasting_rules
ta-DevApaAppInEveMod_activating_and_deactivating_rules
ta-DevApaAppInEveMod_specifying_conditions
co-DevApaAppInEveMod_interactive_editing
ta-DevApaAppInEveMod_language_elements
ta-DevApaAppInEveMod_selecting_and_replacing_elements
ta-DevApaAppInEveMod_cascading_alternative_menus
ta-DevApaAppInEveMod_using_functions_in_rules
ta-DevApaAppInEveMod_adding_a_condition_to_a_rule
ta-DevApaAppInEveMod_specifying_variable_changes_in_conditions
co-DevApaAppInEveMod_local_rules_and_variable_changes
co-DevApaAppInEveMod_global_rules_and_variable_changes
co-DevApaAppInEveMod_specifying_actions
ta-DevApaAppInEveMod_adding_action_statements
ta-DevApaAppInEveMod_deleting_action_statements
co-DevApaAppInEveMod_interactive_editing_2
ta-DevApaAppInEveMod_using_the_keyboard_to_edit_rules
ta-DevApaAppInEveMod_using_the_variables_tab
ta-DevApaAppInEveMod_adding_a_variable
ta-DevApaAppInEveMod_renaming_a_variable
ta-DevApaAppInEveMod_selecting_a_variable
ta-DevApaAppInEveMod_determining_which_states_use_a_particular_variable
ta-DevApaAppInEveMod_moving_a_variable
ta-DevApaAppInEveMod_deleting_a_variable
ta-DevApaAppInEveMod_changing_a_variable_s_properties
ta-DevApaAppInEveMod_setting_a_variable_s_value
ta-DevApaAppInEveMod_variable_input_and_output
ta-DevApaAppInEveMod_linking_a_variable_to_a_block_output_field
re-DevApaAppInEveMod_conversion_rules_for_variable_types
ta-DevApaAppInEveMod_using_the_catalogs_tab
ta-DevApaAppInEveMod_adding_a_block_template_catalog
ta-DevApaAppInEveMod_selecting_and_inspecting_a_block_template
ta-DevApaAppInEveMod_adding_a_block_instance_to_the_scenario
ta-DevApaAppInEveMod_using_the_functions_tab
ta-DevApaAppInEveMod_adding_a_function_catalog
ta-DevApaAppInEveMod_selecting_and_inspecting_a_function
ta-DevApaAppInEveMod_using_the_blocks_tab
ta-DevApaAppInEveMod_interacting_with_a_block_instance
ta-DevApaAppInEveMod_selecting_a_parameter
ta-DevApaAppInEveMod_viewing_a_parameter_s_properties
ta-DevApaAppInEveMod_setting_a_parameter_s_initial_value
ta-DevApaAppInEveMod_linking_a_parameter_with_a_variable_or_output_field
ta-DevApaAppInEveMod_switching_blocks
ta-DevApaAppInEveMod_using_the_block_wiring_tab
tutorialEMwiring
ta-DevApaAppInEveMod_wiring_block_input_feeds
ta-DevApaAppInEveMod_selecting__resizing__and_moving_block_instances
ta-DevApaAppInEveMod_wiring_two_blocks_together
ta-DevApaAppInEveMod_connecting_feeds_and_specifying_feed_mapping
ta-DevApaAppInEveMod_wiring_a_scenario_variable_to_a_block
ta-DevApaAppInEveMod_mapping_type_conversions
ta-DevApaAppInEveMod_editing_block_wiring
ta-DevApaAppInEveMod_deleting_a_wiring
ta-DevApaAppInEveMod_deleting_a_block_instance
ta-DevApaAppInEveMod_using_older_versions_of_blocks
co-DevApaAppInEveMod_troubleshooting_invalid_scenarios
re-DevApaAppInEveMod_event_modeler_command_line_options
co-DevApaAppInEveMod_using_standard_blocks
co-DevApaAppInEveMod_a_block_s_lifecycle
co-DevApaAppInEveMod_general_analytic_blocks
re-DevApaAppInEveMod_change_notifier_v2_0
re-DevApaAppInEveMod_correlation_calculator_v2_0
re-DevApaAppInEveMod_data_distribution_calculator_v2_0
re-DevApaAppInEveMod_median_and_mode_calculator_v1_0
re-DevApaAppInEveMod_moving_average_v1_0
re-DevApaAppInEveMod_spread_calculator_v3_0
re-DevApaAppInEveMod_statistics_calculator_v1_0
re-DevApaAppInEveMod_velocity_calculator_v2_0
re-DevApaAppInEveMod_the_timer_blocks
re-DevApaAppInEveMod_schedule_v3_0
re-DevApaAppInEveMod_wait_v3_0
co-DevApaAppInEveMod_the_utility_blocks
re-DevApaAppInEveMod_dictionary_v2_0
re-DevApaAppInEveMod_file_reader_v2_0
re-DevApaAppInEveMod_file_writer_v2_0
re-DevApaAppInEveMod_history_logger_v2_0
re-DevApaAppInEveMod_input_merger_v2_0
re-DevApaAppInEveMod_list_v2_0
re-DevApaAppInEveMod_scenario_terminator_v2_0
re-DevApaAppInEveMod_status_v2_0
re-DevApaAppInEveMod_variable_mapper_v2_0
co-DevApaAppInEveMod_database_functionality_storage_and_retrieval
re-DevApaAppInEveMod_adbc_storage_v1_0
re-DevApaAppInEveMod_adbc_retrieval_v1_0
co-DevApaAppInEveMod_blocks_for_working_with_scenario_blocks
re-DevApaAppInEveMod_change_observer_v2_0
re-DevApaAppInEveMod_filtered_summary_v2_0
co-DevApaAppInEveMod_using_functions_in_event_modeler
re-DevApaAppInEveMod_reference_information_for_provided_functions
re-DevApaAppInEveMod_date_and_time_functions
re-DevApaAppInEveMod_extended_math_functions_on_float_types
re-DevApaAppInEveMod_io_functions
re-DevApaAppInEveMod_system_value_functions
re-DevApaAppInEveMod_miscellaneous_functions
co-DevApaAppInEveMod_about_defining_your_own_functions
re-DevApaAppInEveMod_sample_abs_function_definition_file
re-DevApaAppInEveMod_sample_function_definition_file_with_imports_element
co-DevApaAppInEveMod_about_function_names
co-UsiApaStu_creating_blocks
tutorialEMcustomblock
co-UsiApaStu_about_blocks
co-UsiApaStu_introduction_to_block_definition_files
co-UsiApaStu_description_of_block_interface_elements
co-UsiApaStu_how_scenarios_communicate_with_their_blocks
co-UsiApaStu_defining_new_blocks_in_apama_studio
co-UsiApaStu_specifying_the_block_metadata
co-UsiApaStu_specifying_the_block_interface
co-UsiApaStu_creating_parallel_aware_blocks
co-UsiApaStu_adding_epl_code_to_the_block_definition
BlockEditorSourceTab
co-UsiApaStu_considerations_for_adding_epl_code_to_the_block_definition
co-UsiApaStu_details_about_epl_code_that_you_can_add
co-UsiApaStu_timeliness_of_acknowledgements
co-UsiApaStu_an_example_block
co-UsiApaStu_description_of_the_correlation_calculator_block_interface
co-UsiApaStu_description_of_the_correlation_calculator_block_epl
co-DevApaAppInEveMod_working_with_blocks_created_from_scenarios
tutorialEMscenarioblock
co-DevApaAppInEveMod_terminology_for_using_scenario_blocks
co-DevApaAppInEveMod_benefits_of_scenario_blocks
ta-DevApaAppInEveMod_steps_for_using_scenario_blocks
co-DevApaAppInEveMod_background_for_using_scenario_blocks
ta-DevApaAppInEveMod_saving_scenarios_as_block_templates
ta-DevApaAppInEveMod_incrementing_scenario_block_version_numbers
ta-DevApaAppInEveMod_adding_a_scenario_block_to_a_main_scenario
ta-DevApaAppInEveMod_examining_a_scenario_block_s_source_scenario
co-DevApaAppInEveMod_descriptions_of_scenario_block_parameters
co-DevApaAppInEveMod_descriptions_of_scenario_block_operations
co-DevApaAppInEveMod_descriptions_of_scenario_block_feeds
ta-DevApaAppInEveMod_setting_parameters_before_creating_sub_scenarios
ta-DevApaAppInEveMod_creating_sub_scenarios
ta-DevApaAppInEveMod_deleting_sub_scenarios
ta-DevApaAppInEveMod_unconditionally_deleting_a_sub_scenario
ta-DevApaAppInEveMod_deleting_all_sub_scenarios
ta-DevApaAppInEveMod_modifying_sub_scenario_input_variable_values
ta-DevApaAppInEveMod_iterating_through_sub_scenarios
ta-DevApaAppInEveMod_obtaining_variable_values_from_sub_scenarios
ta-DevApaAppInEveMod_linking_sub_scenarios_with_other_blocks
ta-DevApaAppInEveMod_inheriting_sub_scenarios
co-DevApaAppInEveMod_description_of_inheritexternalinstances_values
co-DevApaAppInEveMod_notes_for_setting_the_inheritexternalinstances_parameter
co-DevApaAppInEveMod_example_of_inheriting_sub_scenarios
ta-DevApaAppInEveMod_observing_changes_in_sub_scenarios
ta-DevApaAppInEveMod_performing_simple_calculations_across_sub_scenarios
co-UsiApaStu_file_definition_formats
re-UsiApaStu_function_definition_file_format
re-UsiApaStu_defining_metadata_in_function_definition_files
re-UsiApaStu_defining_the_version_element
re-UsiApaStu_defining_the_description_element
re-UsiApaStu_defining_the_imports_element
re-UsiApaStu_defining_the_parameters_element
re-UsiApaStu_defining_epl_code_in_function_definition_files
re-UsiApaStu_block_definition_file_format
re-UsiApaStu_block_definition_file_dtd
re-UsiApaStu_block_definition_file_encodings
re-UsiApaStu_xml_elements_that_define_a_block
co-DevApaAppInJav_how_this_book_is_organized
co-DevApaAppInJav_overview_of_apama_java_applications
tutorialJavamain
co-DevApaAppInJav_introducing_apama_java_api_concepts
co-DevApaAppInJav_about_event_types
tutorialJavaEventTypes
co-DevApaAppInJav_simple_example_of_an_event_type
co-DevApaAppInJav_extended_example_of_a_java_event_type
co-DevApaAppInJav_comparing_java_and_epl_event_type_parameters
co-DevApaAppInJav_about_event_parameters_that_are_complex_types
co-DevApaAppInJav_non_null_values_for_non_primitive_event_field_types
co-DevApaAppInJav_about_monitors
tutorialJavaMonitors
co-DevApaAppInJav_about_event_listeners_and_match_listeners
tutorialJavaMonitorTemplates
co-DevApaAppInJav_example_of_a_matchlistener
ta-DevApaAppInJav_defining_multiple_listeners
ta-DevApaAppInJav_removing_listeners
co-DevApaAppInJav_description_of_the_flow_of_execution_in_java_applications
co-DevApaAppInJav_parallel_processing_in_java_applications
co-DevApaAppInJav_overview_of_contexts_in_java_applications
ta-DevApaAppInJav_using_contexts_in_java_applications
ta-DevApaAppInJav_using_the_context_class_default_constructor
co-DevApaAppInJav_descriptions_of_methods_on_the_context_class
co-DevApaAppInJav_identifying_external_events
co-DevApaAppInJav_optimizing_event_types
co-DevApaAppInJav_wildcarding_parameters_in_event_types
co-DevApaAppInJav_logging_in_java_applications
co-DevApaAppInJav_using_epl_keywords_as_identifiers_in_java
co-DevApaAppInJav_defining_event_expressions
tutorialJavaComplexEvents
co-DevApaAppInJav_about_event_templates
ta-DevApaAppInJav_specifying_positional_syntax
ta-DevApaAppInJav_specifying_completed_event_templates
ta-DevApaAppInJav_specifying_parameter_constraints_in_event_templates
ta-DevApaAppInJav_obtaining_matching_events
ta-DevApaAppInJav_emitting__routing__and_enqueuing_events
tutorialJavaRouteEvents
ta-DevApaAppInJav_specifying_temporal_sequencing
ta-DevApaAppInJav_chaining_listeners
ta-DevApaAppInJav_using_temporal_operators
ta-DevApaAppInJav_defining_advanced_event_expressions
ta-DevApaAppInJav_specifying_other_temporal_operators
ta-DevApaAppInJav_specifying_a_perpetual_listener_for_repeated_matching
ta-DevApaAppInJav_deactivating_a_listener
co-DevApaAppInJav_temporal_contexts
ta-DevApaAppInJav_specifying_the_timer_operators
ta-DevApaAppInJav_looking_for_event_sequences_within_a_set_time
ta-DevApaAppInJav_waiting_within_a_listener
ta-DevApaAppInJav_working_with_absolute_time
ta-DevApaAppInJav_optimizing_event_expressions
co-DevApaAppInJav_validation_of_event_expressions
co-DevApaAppInJav_the_concept_of_time_in_the_correlator
ta-DevApaAppInJav_getting_the_current_time
co-DevApaAppInJav_about_timers_and_their_trigger_times
co-DevApaAppInJav_developing_and_deploying_java_applications
ta-DevApaAppInJav_steps_for_developing_java_applications_in_apama_studio
co-DevApaAppInJav_java_prerequisites
ta-DevApaAppInJav_steps_for_developing_java_applications_manually
ta-DevApaAppInJav_deploying_java_applications
ta-DevApaAppInJav_removing_java_applications_from_the_correlator
ta-DevApaAppInJav_creating_deployment_descriptor_files
co-DevApaAppInJav_format_for_deployment_descriptor_files
ta-DevApaAppInJav_specifying_classpath_in_deployment_descriptor_files
ta-DevApaAppInJav_defining_event_types_in_deployment_descriptor_files
ta-DevApaAppInJav_defining_monitor_classes_in_deployment_descriptor_files
ta-DevApaAppInJav_inserting_annotations_for_deployment_descriptor_files
co-DevApaAppInJav_sample_source_files_with_annotations
ta-DevApaAppInJav_generating_deployment_descriptor_files_from_annotations
co-DevApaAppInJav_package_names_and_namespaces_in_java_applications
co-DevApaAppInJav_sample_java_applications
co-WriCorPlu_developing_epl_plug_ins
co-WriCorPlu_introduction_to_epl_plug_ins
co-WriCorPlu_providing_an_EPL_wrapper_for_a_plug_in
co-WriCorPlu_writing_epl_plug_ins_in_cplusplus
co-WriCorPlu_creating_a_plug_in_using_cplusplus
co-WriCorPlu_method_signatures
co-WriCorPlu_compiling_cplusplus_plug_ins
co-WriCorPlu_exceptions
co-WriCorPlu_writing_to_the_correlator_log_file
co-WriCorPlu_storing_data_using_chunks
co-WriCorPlu_sending_events
co-WriCorPlu_receiving_events
co-WriCorPlu_blocking_behavior_of_plug_ins
co-WriCorPlu_load_time_or_unload_time_code
co-WriCorPlu_handling_thread_specific_data_in_plug_ins
co-WriCorPlu_using_plug_ins_written_in_cplusplus
co-WriCorPlu_epl_plug_ins_in_c_and_cplusplus_written_prior_to_10
co-WriCorPlu_comparison_between_the_new_and_old_apis
co-WriCorPlu_migrating_from_912_or_older_plug_ins
co-WriCorPlu_writing_a_plug_in_in_c_and_cplusplus
co-WriCorPlu_a_simple_plug_in_in_cplusplus
ta-WriCorPlu_calling_the_test_function_from_epl
co-WriCorPlu_a_simple_c_plug_in
co-WriCorPlu_parameter_less_plug_in_functions
co-WriCorPlu_advanced_plug_in_functionality_in_cplusplus_and_c
co-WriCorPlu_introducing_complex_plugin
co-WriCorPlu_the_chunk_data_type
co-WriCorPlu_working_with_chunk_in_cplusplus
co-WriCorPlu_working_with_chunk_in_c
co-WriCorPlu_working_with_sequence
co-WriCorPlu_the_complete_example
co-WriCorPlu_using_complex_plugin_from_the_correlator
co-WriCorPlu_asynchronous_plug_ins
co-WriCorPlu_writing_epl_plug_ins_for_parallel_processing_applications
co-WriCorPlu_blocking_nonblocking
co-WriCorPlu_cplusplus_channel_use
co-WriCorPlu_the_epl_plug_in_apis_for_c_and_cplusplus
co-WriCorPlu_primary_class_types
co-WriCorPlu_writing_epl_plug_ins_in_java
ta-WriCorPlu_creating_a_plug_in_using_java
co-WriCorPlu_permitted_signatures_for_methods
co-WriCorPlu_using_java_plug_ins
co-WriCorPlu_sample_plug_ins_in_java
co-WriCorPlu_a_simple_plug_in
co-WriCorPlu_a_more_complex_plug_in
co-WriCorPlu_a_plug_in_using_enqueue
co-WriCorPlu_subscribe_java_plugin_example
co-ApaEplRef_how_this_book_is_organized
co-ApaEplRef_introduction
co-ApaEplRef_hello_world_example
co-ApaEplRef_types
re-ApaEplRef_primitive_and_string_data_types
re-ApaEplRef_boolean
re-ApaEplRef_decimal
re-ApaEplRef_float
re-ApaEplRef_integer
re-ApaEplRef_string
co-ApaEplRef_reference_data_types
re-ApaEplRef_action
re-ApaEplRef_channel
re-ApaEplRef_chunk
re-ApaEplRef_context
re-ApaEplRef_dictionary
re-ApaEplRef_event
re-ApaEplRef_exception
re-ApaEplRef_listener
re-ApaEplRef_location
re-ApaEplRef_optional
re-ApaEplRef_sequence
re-ApaEplRef_stacktraceelement
re-ApaEplRef_stream
re-ApaEplRef_default_values_for_types
re-ApaEplRef_monitor_pseudo_type
co-ApaEplRef_type_properties_summary
co-ApaEplRef_timestamps__dates__and_times
re-ApaEplRef_type_methods_and_instance_methods
co-ApaEplRef_type_conversion
co-ApaEplRef_comparable_types
co-ApaEplRef_cloneable_types
co-ApaEplRef_potentially_cyclic_types
co-ApaEplRef_which_types_are_potentially_cyclic_
re-ApaEplRef_string_form_of_potentially_cyclic_types
re-ApaEplRef_support_for_ieee_754_special_values
co-ApaEplRef_events_and_event_listeners
re-ApaEplRef_event_definitions
re-ApaEplRef_event_fields
re-ApaEplRef_event_actions
re-ApaEplRef_event_field_and_action_scope
re-ApaEplRef_event_templates
re-ApaEplRef_by_position_qualifiers
re-ApaEplRef_by_name_qualifiers
re-ApaEplRef_range_expressions
re-ApaEplRef_field_operators
re-ApaEplRef_event_listener_definitions
co-ApaEplRef_event_lifecycle
co-ApaEplRef_event_listener_lifecycle
co-ApaEplRef_event_processing_order
co-ApaEplRef_query_event_processing_order
co-ApaEplRef_event_expressions
re-ApaEplRef_event_primaries
re-ApaEplRef_timers
re-ApaEplRef_the_not_operator
re-ApaEplRef_the_all_operator
re-ApaEplRef_the_and__xor__and_or_logical_event_operators
re-ApaEplRef_the_followed_by_event_operator
re-ApaEplRef_event_expression_operator_precedence
co-ApaEplRef_event_channels
co-ApaEplRef_monitors
co-ApaEplRef_monitor_lifecycle
re-ApaEplRef_programs
re-ApaEplRef_packages
re-ApaEplRef_the_using_declaration
re-ApaEplRef_monitor_declarations
re-ApaEplRef_the_import_declaration
re-ApaEplRef_monitor_actions
re-ApaEplRef_simpleactions
re-ApaEplRef_actions_with_parameters
co-ApaEplRef_contexts
co-ApaEplRef_plug_ins
co-ApaEplRef_garbage_collection
co-EplQueRun_queries
co-EplQueRun_query_lifetime
re-EplQueRun_query_definition
re-EplQueRun_metadata_section
re-EplQueRun_parameters_section
re-EplQueRun_inputs_section
re-EplQueRun_query_input_definition
re-EplQueRun_find_statement
re-EplQueRun_pattern
re-EplQueRun_where_condition
re-EplQueRun_within_condition
re-EplQueRun_without_condition
re-EplQueRun_between_clause
re-EplQueRun_select_clause
re-EplQueRun_having_clause
co-ApaEplRef_aggregate_functions
re-ApaEplRef_built_in_aggregate_functions
re-ApaEplRef_custom_aggregates
co-ApaEplRef_statements
re-ApaEplRef_simple_statements
re-ApaEplRef_the_assignment_statement
re-ApaEplRef_the_emit_statement
re-ApaEplRef_the_enqueue_statement
re-ApaEplRef_the_enqueue_______to_statement
re-ApaEplRef_the_expression_statement
re-ApaEplRef_the_log_statement
re-ApaEplRef_the_print_statement
re-ApaEplRef_the_route_statement
re-ApaEplRef_sendto
re-ApaEplRef_the_spawn_statement
re-ApaEplRef_the_spawn
re-ApaEplRef_the_throw_statement
re-ApaEplRef_variable_declaration_statements
re-ApaEplRef_compound_statements
re-ApaEplRef_the_for_statement
re-ApaEplRef_the_from_statement
re-ApaEplRef_the_if_statement
re-ApaEplRef_the_ifpresent_statement
re-ApaEplRef_the_on_statement
re-ApaEplRef_the_while_statement
re-ApaEplRef_the_try_catch_statement
re-ApaEplRef_transfer_of_control_statements
re-ApaEplRef_the_break_statement
re-ApaEplRef_the_continue_statement
re-ApaEplRef_the_die_statement
re-ApaEplRef_the_return_statement
co-ApaEplRef_expressions
co-ApaEplRef_introduction_to_expressions
re-ApaEplRef_primary_expressions
re-ApaEplRef_bitwise_logical_operators
re-ApaEplRef_bitwise_intersection__and_
re-ApaEplRef_bitwise_union__or_
re-ApaEplRef_bitwise_exclusive__xor_
re-ApaEplRef_unary_bitwise_inverse
re-ApaEplRef_logical_operators
re-ApaEplRef_logical_intersection__and_
re-ApaEplRef_logical_union__or_
re-ApaEplRef_logical_exclusive_or__xor_
re-ApaEplRef_unary_logical_inverse__not_
re-ApaEplRef_shift_operators
re-ApaEplRef_left_shift_operator
re-ApaEplRef_right_shift_operator
re-ApaEplRef_comparison_operators_2
re-ApaEplRef_additive_operators
re-ApaEplRef_multiplicative_operators
re-ApaEplRef_unary_additive_operators
re-ApaEplRef_expression_operators
re-ApaEplRef_expression_operator_precedence
re-ApaEplRef_postfix_expressions
re-ApaEplRef_action_and_method_calls
re-ApaEplRef_the_subscript_operator____
re-ApaEplRef_the_new_object_creation_operator
re-ApaEplRef_stream_queries
re-ApaEplRef_stream_query_window_definitions
re-ApaEplRef_stream_source_templates
co-ApaEplRef_variables
co-ApaEplRef_variable_declarations
co-ApaEplRef_variable_scope
re-ApaEplRef_predefined_variable_scope
re-ApaEplRef_monitor_scope
re-ApaEplRef_action_scope
re-ApaEplRef_block_scope
re-ApaEplRef_event_action_scope
re-ApaEplRef_custom_aggregate_function_scope
re-ApaEplRef_provided_variables
re-ApaEplRef_currenttime
re-ApaEplRef_event_timestamps
re-ApaEplRef_self
re-ApaEplRef_specifying_named_constant_values
co-ApaEplRef_lexical_elements
re-ApaEplRef_program_text
re-ApaEplRef_comments
re-ApaEplRef_white_space
re-ApaEplRef_line_terminators
re-ApaEplRef_symbols
re-ApaEplRef_identifiers
re-ApaEplRef_keywords
re-ApaEplRef_operators
re-ApaEplRef_separators
re-ApaEplRef_literals
re-ApaEplRef_boolean_literals
re-ApaEplRef_integer_literals
re-ApaEplRef_base_10_literals
re-ApaEplRef_base_16_literals
re-ApaEplRef_floating_point_and_decimal_literals
re-ApaEplRef_string_literals
re-ApaEplRef_location_literals
re-ApaEplRef_dictionary_literals
re-ApaEplRef_sequence_literals
re-EplQueRun_time_literals
re-ApaEplRef_names
re-ApaEplRef_annotations
co-ApaEplRef_limits
co-ApaEplRef_obsolete_language_elements
co-ApaEplRef_old_style_listener_calls
co-ApaEplRef_old_style_spawn_statements
co-DevApaAppInEpl_epl_naming_conventions
co-DevApaAppInEpl_epl_methods_quick_reference
to-help_connecting_apama_applications_to_external_components
co-ConApaAppToExtCom_preface
co-ConApaAppToExtCom_standard_connectivity_plug_ins
co-DepAndManApaApp_the_universal_messaging_transport_plug_in
co-DepAndManApaApp_um_about
co-DepAndManApaApp_um_comparison_um_apama_channels
co-DepAndManApaApp_um_choosing
co-DepAndManApaApp_um_steps
co-DepAndManApaApp_um_engine_connect_compare
co-DepAndManApaApp_um_comparison_adapters_um_channel
co-DepAndManApaApp_um_considerations
co-DepAndManApaApp_um_config_in_um
co-DepAndManApaApp_um_configuring_the_um_connectivity_plug_in
co-DepAndManApaApp_um_loading_the_umtransport
co-DepAndManApaApp_um_configuring_the_dynamicchainmanagers
co-DepAndManApaApp_um_configuring_the_dynamicchains
co-DepAndManApaApp_um_using_dynamic_replacement_variables
co-DepAndManApaApp_um_subscribing_to_automatically_created_um_channels
co-DepAndManApaApp_um_channel_lookup_caching
co-DepAndManApaApp_um_supported_payloads
co-DepAndManApaApp_um_replacing_the_deprecated_um_integration
co-DepAndManApaApp_um_specifying_channels_in_apps
co-DepAndManApaApp_um_using_um_connectivity_from_epl
co-DepAndManApaApp_um_monitoring
co-DepAndManApaApp_um_legacy_um_integration
co-DepAndManApaApp_um_about_events
co-DepAndManApaApp_um_channel_mode_property
co-DepAndManApaApp_um_starting_correlators
co-DepAndManApaApp_um_properties
co-ConApaAppToExtCom_the_mqtt_transport_connectivity_plug_in
co-ConApaAppToExtCom_mqtt_about_the_mqtt_transport
co-ConApaAppToExtCom_mqtt_using_mqtt_connectivity_from_epl
co-ConApaAppToExtCom_mqtt_loading_the_mqtt_transport
co-ConApaAppToExtCom_mqtt_configuring_the_dynamicchainmanagers
co-ConApaAppToExtCom_mqtt_configuring_the_dynamicchains
co-ConApaAppToExtCom_mqtt_payload_for_the_mqtt_message
co-ConApaAppToExtCom_mqtt_wildcard_topic_subscriptions
co-ConApaAppToExtCom_mqtt_restrictions
co-ConApaAppToExtCom_the_digital_event_services_transport_connectivity_plug_in
co-ConApaAppToExtCom_des_about_the_des_transport
co-ConApaAppToExtCom_des_using_des_connectivity_from_epl
co-ConApaAppToExtCom_des_reliable_messaging_with_des
co-ConApaAppToExtCom_the_http_client_transport_connectivity_plug_in
co-ConApaAppToExtCom_httpclient_about_the_http_client_transport
co-ConApaAppToExtCom_httpclient_loading_the_http_client_transport
co-ConApaAppToExtCom_httpclient_configuring_the_http_client_transport
co-ConApaAppToExtCom_httpclient_mapping_events_between_epl_and_http
co-ConApaAppToExtCom_httpclient_distinguishing_response_types
co-ConApaAppToExtCom_httpclient_handling_http_headers
co-ConApaAppToExtCom_httpclient_mapping_the_body
co-ConApaAppToExtCom_httpclient_dealing_with_cookies
co-ConApaAppToExtCom_httpclient_providing_http_query_parameters
co-ConApaAppToExtCom_httpclient_example_mapping_rules
co-ConApaAppToExtCom_httpclient_configuring_dynamic_connections_to_services
co-ConApaAppToExtCom_the_kafka_transport_connectivity_plug_in
co-ConApaAppToExtCom_codec_connectivity_plug_ins
co-ConApaAppToExtCom_string_codec
co-ConApaAppToExtCom_json_codec
co-ConApaAppToExtCom_classifier_codec
co-ConApaAppToExtCom_mapper_codec
co-ConApaAppToExtCom_unittestharness_codec
co-ConApaAppToExtCom_diagnostic_codec
co-ConApaAppToExtCom_standard_iaf_plug_ins
co-DepAndManApaApp_the_database_connector_iaf_adapter_adbc
ta-DepAndManApaApp_overview_of_using_adbc
ta-BuiDas_registering_your_database_with_odbc
ta-DepAndManApaApp_adding_an_adbc_adapter_to_an_apama_studio_project
co-DepAndManApaApp_configuring_the_apama_database_connector
ta-DepAndManApaApp_configuring_an_adbc_adapter
ADBCAdapterEditor
ta-DepAndManApaApp_manually_editing_a_configuration_file
co-DepAndManApaApp_configuring_adbc_localization
co-DepAndManApaApp_configuring_adbc_automatic_database_close
co-DepAndManApaApp_service_monitors
co-DepAndManApaApp_codecs
co-DepAndManApaApp_the_adbchelper_application_programming_interface
ta-DepAndManApaApp_adbchelper_api_overview
ta-DepAndManApaApp_opening_databases
ta-DepAndManApaApp_specifying_the_adapter_instance
ta-DepAndManApaApp_checking_to_see_if_a_database_is_open
ta-DepAndManApaApp_issuing_and_stopping_sql_queries
ta-DepAndManApaApp_issuing_sql_commands
ta-DepAndManApaApp_committing_database_changes
ta-DepAndManApaApp_performing_rollback_operations
ta-DepAndManApaApp_handling_query_results_for_row_data
ta-DepAndManApaApp_handling_query_results_for_event_data
ta-DepAndManApaApp_handling_acknowledgments
ta-DepAndManApaApp_handling_errors
co-DepAndManApaApp_reconnection_settings
ta-DepAndManApaApp_closing_databases
ta-DepAndManApaApp_getting_schema_information
ta-DepAndManApaApp_setting_context
ta-DepAndManApaApp_logging
co-DepAndManApaApp_examples
ta-DepAndManApaApp_the_adbc_event_application_programming_interface
ta-DepAndManApaApp_discovering_data_sources
ta-DepAndManApaApp_discovering_databases
ta-DepAndManApaApp_opening_a_database
ta-DepAndManApaApp_closing_a_database
ta-DepAndManApaApp_storing_event_data
ta-DepAndManApaApp_storing_non_event_data
ta-DepAndManApaApp_creating_and_deleting_store_events
ta-DepAndManApaApp_handling_data_storing_errors
ta-DepAndManApaApp_committing_transactions
ta-DepAndManApaApp_rolling_back_transactions
ta-DepAndManApaApp_running_commands
co-DepAndManApaApp_executing_queries
ta-DepAndManApaApp_executing_standard_queries
ta-DepAndManApaApp_stopping_queries
ta-DepAndManApaApp_preserving_column_name_case
co-DepAndManApaApp_prepared_statements
ta-DepAndManApaApp_using_a_prepared_statement
co-DepAndManApaApp_stored_procedures
ta-DepAndManApaApp_using_a_stored_procedure
co-DepAndManApaApp_named_queries
ta-DepAndManApaApp_using_named_queries
ta-DepAndManApaApp_creating_named_queries
co-DepAndManApaApp_the_visual_event_mapper
ta-DepAndManApaApp_using_the_visual_event_mapper
EVENT_PERSISTENCE_SELECTION_DIALOG
co-DepAndManApaApp_playback
co-DepAndManApaApp_sample_applications
co-DepAndManApaApp_format_of_events_in__sim_files
co-DepAndManApaApp_the_web_services_client_iaf_adapter
co-DepAndManApaApp_web_services_client_adapter_overview
WebServiceAdapterEditor
ta-DepAndManApaApp_adding_a_web_services_client_adapter_to_an_apama_studio_project
co-DepAndManApaApp_configuring_a_web_services_client_adapter
SERVICE_PERSISTENCE_SELECTION_DIALOG
ta-DepAndManApaApp_specify_the_web_service_and_operation_to_use
UsageDialog
co-ConApaAppToExtCom_web_service_client_dialog
WEB_SERVICE_CLIENT_DIALOG
ta-DepAndManApaApp_specifying_apama_events_for_mapping
ta-DepAndManApaApp_editing_web_services_client_adapter_configurations
ta-DepAndManApaApp_adding_multiple_instances_of_the_web_services_client_adapter
co-DepAndManApaApp_mapping_web_service_message_parameters
ta-DepAndManApaApp_simple_mapping
co-DepAndManApaApp_convention_based_xml_mapping
ta-DepAndManApaApp_convention_based_web_service_message_mapping_example
ta-DepAndManApaApp_add_computed_node_dialog
ADD_COMPUTED_NODE_DIALOG
co-ConApaAppToExtCom_xmldecode
ta-DepAndManApaApp_template_based_mapping
ASSIGN_TEMPLATE_DIALOG
ta-DepAndManApaApp_combining_convention_and_template_mapping
co-DepAndManApaApp_mapping_complex_types
co-DepAndManApaApp_difference_between_doc_literal_and_rpc_literal_wsdls
co-DepAndManApaApp_custom_el_methods
co-DepAndManApaApp_juel_expressions_for_web_client_adapter
ta-DepAndManApaApp_specifying_a_correlation_id_field
ta-ConApaAppToExtCom_specifying_transformation_types
CONNECTION_PROPERTIES_DIALOG
co-ConApaAppToExtCom_using_the_xpath_helper
XPathDialog
ta-ConApaAppToExtCom_launching_the_xpath_helper
ta-ConApaAppToExtCom_setting_node_properties
ta-ConApaAppToExtCom_generating_xpath_expressions
ta-ConApaAppToExtCom_adding_and_removing_namespaces
ta-ConApaAppToExtCom_evaluating_xpath_expressions
co-DepAndManApaApp_customizing_mapping_rules
ta-DepAndManApaApp_mapping_soap_body_elements
ta-DepAndManApaApp_mapping_soap_header_elements
ta-DepAndManApaApp_mapping_http_header_elements
co-DepAndManApaApp_using_epl_to_interact_with_web_services
ta-DepAndManApaApp_configuring_logging_for_web_services_client_adapter
co-DepAndManApaApp_web_services_client_adapter_artifacts
ta-DepAndManApaApp_updating_a_web_service_operation_using_the_archive_editor
ArchiveEditor
co-DevAda_the_file_iaf_adapter_jmultifiletransport
co-DevAda_file_adapter_plug_ins
co-DevAda_file_adapter_service_monitor_files
ta-DevAda_adding_the_file_adapter_to_an_apama_studio_project
GenericAdapterEditor
co-DevAda_configuring_the_file_adapter
co-DevAda_overview_of_event_protocol_for_communication_with_the_file_adapter
co-DevAda_opening_files_for_reading
co-DevAda_opening_files_for_reading_with_parallel_processing_applications
co-DevAda_specifying_file_names_in_openfileforreading_events
co-DevAda_opening_comma_separated_values__csv__files
co-DevAda_opening_fixed_width_files
co-DevAda_sending_the_read_request
co-DevAda_requesting_data_from_the_file
co-DevAda_receiving_data
co-DevAda_opening_files_for_writing
co-DevAda_opening_files_for_writing_with_parallel_processing_applications
co-DevAda_linewritten_event
co-DevAda_monitoring_the_file_adapter
co-DevAda_the_basic_file_iaf_adapter_jfiletransport
co-DevAda_codec_iaf_plug_ins
co-DevAda_the_string_codec_iaf_plug_in
co-DevAda_the_null_codec_iaf_plug_in
co-DevAda_null_codec_transport_related_properties
co-DevAda_the_filter_codec_iaf_plug_in
co-DevAda_filter_codec_transport_related_properties
ta-DevAda_specifying_filters_for_the_filter_codec
co-DevAda_examples_of_filter_specifications
co-DevAda_the_xml_codec_iaf_plug_in
co-DevAda_supported_xml_features
ta-DevAda_adding_xml_codec_to_adapter_configuration
ta-DevAda_setting_up_the_classpath
co-DevAda_about_the_xml_parser
co-DevAda_specifying_xml_codec_properties
co-DevAda_required_xml_codec_properties
co-DevAda_xml_codec_transport_related_properties
co-DevAda_message_logging_properties
co-DevAda_downstream_node_order_suffix_properties
co-DevAda_additional_downstream_properties
co-DevAda_sequence_field_properties
co-DevAda_upstream_properties
co-DevAda_performance_properties
co-DevAda_description_of_event_fields_that_represent_normalised_xml
co-DevAda_examples_of_conversions
co-DevAda_sequence_field_example
co-DevAda_xpath_examples
co-DevAda_the_csv_codec_iaf_plug_in
co-DevAda_multiple_configurations_and_the_csv_codec
ta-DevAda_decoding_csv_data_from_the_sink_to_send_to_the_correlator
ta-DevAda_encoding_csv_data_from_the_correlator_for_the_sink
co-DevAda_the_fixed_width_codec_iaf_plug_in
co-DevAda_multiple_configurations_and_the_fixed_width_codec
ta-DevAda_decoding_fixed_width_data_from_the_sink_to_send_to_the_correlator
ta-DevAda_encoding_fixed_width_data_from_the_correlator_for_the_sink
co-ConApaAppToExtCom_correlator_integrated_support_for_jms
co-DepAndManApaApp_using_the_java_message_service_jms
co-DepAndManApaApp_correlator_integrated_jms_messaging_overview
co-DepAndManApaApp_correlator_integrated_jms_example_applications
co-DepAndManApaApp_key_concepts
ta-DepAndManApaApp_getting_started___creating_an_application_with_simple_jms_messaging
re-ConApaAppToExtCom_correlator_integrated_adapter_editor
JMSResiliencyAdapterEditor
ta-DepAndManApaApp_configuring_connections
JMS_CONFIG_WIZARD
ta-DepAndManApaApp_adding_jms_receivers
ta-DepAndManApaApp_configuring_receiver_event_mappings
ta-DepAndManApaApp_using_conditional_expressions
CONDITIONAL_EXPRESSION_DIALOG
ta-DepAndManApaApp_adding_a_classpath_variable_entry
ADD_CLASSPATH_VARIABLE_DIALOG
ta-DepAndManApaApp_configuring_sender_event_mappings
co-DepAndManApaApp_using_epl_to_send_and_receive_jms_messages
ta-DepAndManApaApp_getting_started___creating_an_application_with_reliable_jms_messaging
co-ConApaAppToExtCom_mapping_apama_events_and_jms_messages
ta-DepAndManApaApp_simple_mapping_for_jms_messages
ta-DepAndManApaApp_using_expressions_in_mapping_rules
SourceTargetDialog
ta-DepAndManApaApp_template_based_xml_generation
co-ConApaAppToExtCom_adding_multiple_xpath_mappings_rules_for_a_received_xml_document
ta-ConApaAppToExtCom_using_treat_as_on_jms_body_dialog_sender
JMS_BODY_INPUT_TREAT_AS_DIALOG
ta-ConApaAppToExtCom_using_treat_as_on_jms_body_dialog_receiver
JMS_BODY_OUTPUT_TREAT_AS_DIALOG
ta-ConApaAppToExtCom_using_the_type_chooser_dialog
TYPE_CHOOSER_DIALOG
co-DepAndManApaApp_using_convention_based_xml_mapping_with_jms_messages
co-DepAndManApaApp_convention_based_jms_message_mapping_example
ta-DepAndManApaApp_using_convention_based_xml_mapping_when_receiving_parsing_messages
ta-DepAndManApaApp_using_convention_based_xml_mapping_when_sending_generating_messages
VariableDialog
co-DepAndManApaApp_combining_convention_based_xml_mapping_with_template_based_xml_generation
co-DepAndManApaApp_using_eda_events
co-DepAndManApaApp_eda_escape_conventions
co-DepAndManApaApp_eda_namespaces
ta-DepAndManApaApp_create_typedef_for_EDA_event
WIZARD_EVENT_GEN_FROM_EDA
ta-DepAndManApaApp_setup_eda_mappings
co-DepAndManApaApp_eda_manual_mapping
co-DepAndManApaApp_jms_handling_blob_data
co-DepAndManApaApp_custom_el_methods_jms
co-DepAndManApaApp_juel_mapping_expressions_reference
co-ConApaAppToExtCom_custom_mapping
co-DepAndManApaApp_dynamic_senders_and_receivers
co-DepAndManApaApp_durable_topics
co-DepAndManApaApp_receiver_flow_control
ta-DepAndManApaApp_monitoring_correlator_integrated_jms_status
co-DepAndManApaApp_logging_jms_enabled_correlator_status
co-DepAndManApaApp_jms_configuration_reference
co-DepAndManApaApp_configuration_files
co-DepAndManApaApp_xml_configuration_file_format
co-DepAndManApaApp_xml_configuration_bean_reference
co-DepAndManApaApp_advanced_configuration_bean_properties
co-DepAndManApaApp_designing_and_implementing_applications_for_jms
co-DepAndManApaApp_using_correlator_persistence_with_correlator_integrated_jms
co-DepAndManApaApp_how_reliable_jms_sending_integrates_with_correlator_persistence
co-DepAndManApaApp_how_reliable_jms_receiving_integrates_with_correlator_persistence
co-ConApaAppToExtCom_jms_sending_and_receiving_reliably_without_correlator_persistence
co-ConApaAppToExtCom_app_controlled
co-ConApaAppToExtCom_jms_sending_messages_reliably_with_application_flushing_notification
co-DepAndManApaApp_using_the_correlator_replay_log_with_correlator_integrated_jms
co-DepAndManApaApp_reliability_considerations
co-DepAndManApaApp_duplicate_detection
co-DepAndManApaApp_performance_considerations
co-DepAndManApaApp_jms_performance_logging
co-DepAndManApaApp_receiver_performance_breakdown
co-DepAndManApaApp_sender_performance_breakdown
ta-DepAndManApaApp_configuring_java_options_and_system_properties
co-DepAndManApaApp_diagnosing_problems_when_using_jms
co-DepAndManApaApp_jms_failures_modes_and_how_to_cope_with_them
co-ConApaAppToExtCom_working_with_connectivity_plug_ins
co-ConApaAppToExtCom_using_connectivity_plug_ins
co-ConApaAppToExtCom_overview_of_using_connectivity_plug_ins
co-ConApaAppToExtCom_static_and_dynamic_connectivity_chains
co-ConApaAppToExtCom_configuration_file_for_connectivity_plug_ins
co-ConApaAppToExtCom_host_plug_ins_and_configuration
co-ConApaAppToExtCom_translating_epl_events_using_the_apama_eventmap_host_plug_in
co-ConApaAppToExtCom_using_reliable_transports
co-ConApaAppToExtCom_creating_dynamic_chains_from_epl
co-ConApaAppToExtCom_sending_and_receiving_events_with_connectivity_plug_ins
co-ConApaAppToExtCom_deploying_plug_in_libraries
co-ConApaAppToExtCom_developing_connectivity_plug_ins
co-ConApaAppToExtCom_chain_components_and_messages
co-ConApaAppToExtCom_requirements_of_a_plug-in_class
co-ConApaAppToExtCom_requirements_of_a_transport_chain_manager_plug-in_class
co-ConApaAppToExtCom_building_plug_ins
co-ConApaAppToExtCom_cplusplus_data_types
co-ConApaAppToExtCom_map_contents_used_by_the_apama_eventmap_host_plug_in
co-ConApaAppToExtCom_metadata_values
co-ConApaAppToExtCom_lifetime_of_connectivity_plug-ins
co-ConApaAppToExtCom_creating_dynamic_chains_from_a_chain_manager_plug_in
co-ConApaAppToExtCom_user_defined_status_reporting_from_connectivity_plug_ins
co-ConApaAppToExtCom_logging_and_configuration
co-ConApaAppToExtCom_threading
co-ConApaAppToExtCom_developing_reliable_transports
co-DevAda_working_with_iaf_plug_ins
co-DevAda_the_integration_adapter_framework
co-DevAda_overview
co-DevAda_architecture
co-DevAda_the_transport_layer
co-DevAda_the_codec_layer
co-DevAda_the_semantic_mapper_layer
co-DevAda_contents_of_the_iaf
co-DevAda_using_the_iaf
co-DevAda_the_iaf_runtime
co-DevAda_iaf_library_paths
re-DevAda_iaf_command_line_options
co-DevAda_iaf_log_file_status_messages
co-DevAda_iaf_log_rotation
co-DevAda_iaf_management___managing_a_running_adapter_i
co-DevAda_iaf_client___managing_a_running_adapter_ii
co-DevAda_iaf_watch___monitoring_running_adapter_status
co-DevAda_the_iaf_configuration_file
co-DevAda_including_other_files
co-DevAda_transport_and_codec_plug_in_configuration
co-DevAda_event_mappings_configuration
co-DevAda_apama_correlator_configuration
co-DepAndManApaApp_um_configuring_iaf_adapters
co-DevAda_logging_configuration__optional_
co-DevAda_java_configuration__optional_
co-DevAda_iaf_samples
co-DevAda_c_cplusplus_transport_plug_in_development
co-DevAda_the_c_cplusplus_transport_plug_in_development_specification
co-DevAda_transport_functions_to_implement
ta-DevAda_defining_the_transport_function_table
co-DevAda_the_transport_constructor__destructor_and_info_functions
co-DevAda_other_transport_definitions
co-DevAda_transport_utilities
co-DevAda_communication_with_the_codec_layer_2
co-DevAda_getting_started_with_transport_layer_plug_in_development
co-DevAda_c_cplusplus_codec_plug_in_development
co-DevAda_the_c_cplusplus_codec_plug_in_development_specification
co-DevAda_codec_functions_to_implement
co-DevAda_codec_encoder_functions
co-DevAda_codec_decoder_functions
co-DevAda_defining_the_codec_function_tables
co-DevAda_the_codec_function_table
co-DevAda_the_codec_encoder_function_table
co-DevAda_the_codec_decoder_function_table
ta-DevAda_registering_the_codec_function_tables
co-DevAda_the_codec_constructor__destructor_and_info_functions
co-DevAda_other_codec_definitions
co-DevAda_codec_utilities
co-DevAda_communication_with_other_layers_2
co-DevAda_working_with_normalised_events_2
co-DevAda_the_ap_normalisedevent_structure
co-DevAda_the_ap_normalisedeventiterator_structure
co-DevAda_transport_example
ta-DevAda_getting_started_with_codec_layer_plug_in_development
co-DevAda_c_cplusplus_plug_in_support_apis
co-DevAda_logging_from_plug_ins_in_c_cplusplus
co-DevAda_using_the_latency_framework
co-DevAda_c_cplusplus_timestamp
co-DevAda_c_cplusplus_timestamp_set
co-DevAda_c_cplusplus_timestamp_configuration_object
co-DevAda_c_cplusplus_latency_framework_api
co-DevAda_java_transport_plug_in_development
co-DevAda_the_java_transport_plug_in_development_specification
co-DevAda_java_transport_functions_to_implement
co-DevAda_communication_with_the_codec_layer
ta-DevAda_sending_upstream_messages_received_from_a_codec_plug_in_to_a_sink
ta-DevAda_sending_downstream_messages_received_from_a_source_on_to_a_codec_plug_in
co-DevAda_transport_exceptions
co-DevAda_logging_2
co-DevAda_example
co-DevAda_getting_started_with_java_transport_layer_plug_in_development
co-DevAda_java_codec_plug_in_development
co-DevAda_the_java_codec_plug_in_development_specification
co-DevAda_java_codec_functions_to_implement
co-DevAda_communication_with_other_layers
ta-DevAda_sending_upstream_messages_received_from_the_semantic_mapper_to_a_transport_plug_in
ta-DevAda_sending_downstream_messages_received_from_a_transport_plug_in_to_the_semantic_mapper
co-DevAda_java_codec_exceptions
co-DevAda_semantic_mapper_exceptions
co-DevAda_logging
co-DevAda_working_with_normalised_events
co-DevAda_the_normalisedevent_class
co-DevAda_the_normalisedeventiterator_class
co-DevAda_java_codec_example
ta-DevAda_getting_started_with_java_codec_layer_plug_in_development
co-DevAda_java_plug_in_support_apis
co-DevAda_logging_from_plug_ins_in_java
co-DevAda_using_the_latency_framework_2
co-DevAda_java_timestamp
co-DevAda_java_timestamp_set
co-DevAda_java_timestamp_configuration_object
co-DevAda_java_latency_framework_api
co-DevAda_monitoring_adapter_status
co-DevAda_iafstatusmanager
co-DevAda_application_interface
co-DevAda_returning_information_from_the_getstatus_method
co-DevAda_connections_and_other_custom_properties
co-DevAda_asynchronously_notifying_iafstatusmanager_of_connection_changes
co-DevAda_mapping_adapterconnectionclosed_and_adapterconnectionopened_events
co-DevAda_statussupport
co-DevAda_statussupport_events
co-DevAda_dataview_support
co-DevAda_out_of_band_connection_notification
co-DevAda_mapping_example
co-DevAda_ordering_of_out_of_band_notifications
co-DevAda_the_event_payload
co-DevCli_developing_custom_clients
co-DevCli_the_client_software_development_kits
co-DevCli_the_client_libraries
co-DevCli_working_with_event_objects
co-DevCli_logging
co-DevCli_exception_handling_and_thread_safety
co-DevCli_enginemanagement_api
co-DevCli_engineclient_api
co-DevCli_eventservice_api
co-DevCli_scenarioservice_api
to-help_building_and_using_dashboards
co-BuiAndUsiDas_preface
co-BuiDas_how_this_book_is_organized
co-BuiDas_introduction
dashboard_builder_context
co-BuiDas_web_client_requirements
co-BuiDas_about_dashboards
tutorialDashboard
ta-BuiDas_starting_the_dashboard_builder
ta-BuiDas_starting_builder_from_the_windows_start_menu
ta-BuiDas_starting_builder_from_apama_studio
ta-BuiDas_specifying_dashboard_builder_options
DashboardBuilderOptions
ta-BuiDas_starting_builder_from_the_command_line
co-BuiDas_scenario_instance_and_dataview_item_ownership
ta-BuiDas_using_the_tutorial_application
co-BuiDas_using_dashboard_builder
co-BuiDas_dashboard_builder_layout
re-BuiDas_the_menubar
re-BuiDas_the_toolbar
re-BuiDas_the_canvas
re-BuiDas_the_object_palette
co-BuiDas_the_object_properties_panel
ta-BuiDas_specifying_data_sources
ta-BuiDas_specifying_correlators
ta-BuiDas_specifying_xml_data_sources
ta-BuiDas_activating_data_source_specifications
ta-BuiDas_saving_data_source_specifications
ta-BuiDas_setting_the_background_properties
co-BuiDas_about_resize_modes
co-BuiDas_about_resize_modes_and_display_server_deployments
co-BuiDas_about_resize_modes_and_composite_objects
ta-BuiDas_working_with_objects
ta-BuiDas_adding_objects_to_a_dashboard
ta-BuiDas_selecting_an_object
ta-BuiDas_resizing_objects
ta-BuiDas_moving_objects
ta-BuiDas_copy_and_pasting_objects
ta-BuiDas_deleting_objects
ta-BuiDas_setting_builder_options
ta-BuiDas_setting_dashboard_options
ta-BuiDas_setting_options_in_the_general_tab_group
ta-BuiDas_setting_options_in_the_general_tab
ta-BuiDas_setting_options_in_the_substitutions_tab
ta-BuiDas_setting_options_in_the_data_server_tab
ta-BuiDas_setting_options_in_the_custom_colors_tab
ta-BuiDas_setting_options_in_the_apama_tab_group
ta-BuiDas_setting_options_in_the_sql_tab_group
ta-BuiDas_setting_options_in_the_xml_tab_group
ta-BuiDas_saving_options
re-BuiDas_command_line_options
re-BuiDas_using_dashboard_builder_restrictions
co-BuiDas_attaching_dashboards_to_correlator_data
co-BuiDas_dashboard_data_tables
co-BuiDas_scenario_instance_table
co-BuiDas_query_instance_table
co-BuiDas_scenario_trend_table
co-BuiDas_scenario_ohlc_table
co-BuiDas_correlator_status_table
co-BuiDas_data_server_status_table
co-BuiDas_scenario_constraint_table
co-BuiDas_dataview_item_table
co-BuiDas_dataview_trend_table
co-BuiDas_dataview_ohlc_table
co-BuiDas_sql_based_instance_table
co-BuiDas_def_extra_params_table
ta-BuiDas_setting_data_options
co-BuiDas_scenario_instance_and_dataview_item_ownership_2
ta-BuiDas_creating_a_data_attachment
ta-BuiDas_using_the_attach_to_apama_dialog
ta-BuiDas_selecting_display_variables_or_fields
ta-BuiDas_displaying_attached_data
ta-BuiDas_filtering_data
ta-BuiDas_attaching_to_constraint_data
co-BuiDas_about_timestamps
ta-BuiDas_using_dashboard_variables_in_attachments
ta-BuiDas_about_non_substitution_variables
co-BuiDas_about_drilldown_and__instanceid
co-BuiDas_about_other_predefined_substitution_variables
ta-BuiDas_using_sql_based_instance_tables
co-BuiDas_working_with_multiple_data_servers
co-BuiDas_builder_with_multiple_data_servers
co-BuiDas_viewer_with_multiple_data_servers
co-BuiDas_display_server_deployments_with_multiple_data_servers
co-BuiDas_webstart_deployments_with_multiple_data_servers
ta-BuiDas_using_table_objects
ta-BuiDas_creating_a_scenario_summary_table
ta-BuiDas_filtering_rows_of_a_scenario_summary_table
ta-BuiDas_performing_drilldowns_on_tables
ta-BuiDas_specifying_drill_down_column_substitutions
ta-BuiDas_hiding_table_columns
ta-BuiDas_using_pre_set_substitution_variables_for_drill_down
ta-BuiDas_formatting_table_data
ta-BuiDas_colorizing_table_rows_and_cells
ta-BuiDas_setting_column_headers
ta-BuiDas_using_rotated_tables
ta-BuiDas_using_pie_and_bar_charts
ta-BuiDas_creating_a_summary_pie_or_bar_chart
ta-BuiDas_using_series_and_non_series_bar_charts
ta-BuiDas_performing_drilldowns_on_pie_and_bar_charts
ta-BuiDas_using_trend_charts
ta-BuiDas_creating_a_scenario_trend_chart
ta-BuiDas_charting_multiple_variables
ta-BuiDas_adding_thresholds
ta-BuiDas_configuring_trend_data_caching
co-BuiDas_using_webchart_trend_charts
ta-BuiDas_using_stock_charts
ta-BuiDas_using_ohlc_values
ta-BuiDas_creating_a_scenario_stock_chart
ta-BuiDas_adding_overlays
ta-BuiDas_recreating_the_stock_chart_overlay_sample
ta-BuiDas_generating_ohlc_values
ta-BuiDas_localizing_dashboard_labels
ta-BuiDas_localizing_dashboard_messages
co-BuiDas_using_dashboard_functions
ta-BuiDas_using_built_in_functions
ta-BuiDas_creating_custom_functions
ta-BuiDas_developing_a_custom_function_library
ta-BuiDas_implementing_getfunctiondescriptors
ta-BuiDas_implementing_evaluatefunction
ta-BuiDas_installing_a_custom_function_library
co-BuiDas_sample_ifunctionlibrary_implementation
co-BuiDas_defining_dashboard_commands
co-BuiDas_scenario_lifecycle
ta-BuiDas_defining_commands
ta-BuiDas_using_dashboard_variables_in_commands
ta-BuiDas_defining_commands_for_creating_a_scenario_instance
ta-BuiDas_defining_commands_for_editing_a_scenario_instance
ta-BuiDas_supporting_deletion_of_a_scenario_instance
ta-BuiDas_supporting_deletion_of_all_instances_of_a_scenario
ta-BuiDas_defining_commands_for_creating_a_query_instance
ta-BuiDas_defining_commands_for_editing_a_query_instance
ta-BuiDas_defining_commands_for_deleting_a_query_instance
ta-BuiDas_supporting_deletion_of_all_instances_of_a_query
ta-BuiDas_using_popup_dialogs_for_commands
co-BuiDas_command_options
ta-BuiDas_associating_a_command_with_keystrokes
ta-BuiDas_defining_multiple_commands
ta-BuiDas_creating_custom_commands
ta-BuiDas_developing_a_custom_command_library
ta-BuiDas_installing_a_custom_command_library
co-BuiDas_sample_icommandlibrary_implementation
co-BuiDas_apama_set_substitution_command
co-BuiDas_reusing_dashboard_components
ta-BuiDas_using_object_grids
ta-BuiDas_configuring_object_grids
ta-BuiDas_recreating_the_object_grid_sample
ta-BuiDas_using_composite_objects
ta-BuiDas_creating_files_to_display_in_composite_objects
ta-BuiDas_configuring_composite_objects
ta-BuiDas_using_substitutions_with_composite_objects
co-BuiDas_composite_object_interactivity
co-BuiDas_composite_object_sample
ta-BuiDas_recreating_the_composite_object_sample
ta-BuiDas_using_composite_grids
ta-BuiDas_configuring_composite_grids
ta-BuiDas_composite_grid_sample
ta-BuiDas_recreating_the_composite_grid_sample
ta-BuiDas_using_include_files
ta-BuiDas_include_file_sample
ta-BuiDas_recreating_the_include_file_sample
co-BuiDas_working_with_multiple_display_panels
ta-BuiDas_about_the_format_of_the_panels_configuration_file
co-BuiDas_using_new_tags_to_configure_the_panels_in_a_window
co-BuiDas_configuring_panels_with_accordion_controls
co-BuiDas_configuring_static_tree_navigation_panels
co-BuiDas_configuring_tabbed_navigation_panels
co-BuiDas_using_tab_definition_files
co-BuiDas_examples_of_configuration_files_for_multiple_panels
co-BuiDas_using_tree_controls_in_panel_displays
co-BuiDas_creating_tree_controls
co-BuiDas_configuring_tree_control_icons
co-BuiDas_specifying_tree_control_properties
co-BuiDas_tree_control_limitations
co-BuiDas_using_old_tags_to_configure_the_panels_in_a_window
ta-BuiDas_using_border_panels
ta-BuiDas_using_card_panels
ta-BuiDas_using_grid_panels
ta-BuiDas_using_tabs_panels
ta-BuiDas_using_tree_panels
ta-BuiDas_using_the_rtviewnavtreepanel_tag
ta-BuiDas_using_the_rtviewpanel_tag
co-BuiDas_new_tab_control_object
co-BuiDas_sending_events_to_correlators
ta-BuiDas_using_the_define_apama_command_dialog
co-BuiDas_other_dialog_fields
ta-BuiDas_updating_event_definitions_in_builder
co-BuiDas_example
co-BuiDas_send_event_authorization
co-BuiDas_using_xml_data
co-BuiDas_xml_data_format
ta-BuiDas_scalar_data_elements
ta-BuiDas_tabular_data_elements
ta-BuiDas_defining_an_xml_data_source
ta-BuiDas_attaching_objects_to_xml_data
co-BuiDas_using_sql_data
co-BuiDas_sql_system_requirements_and_setup
ta-BuiDas_attaching_visualization_objects_to_sql_data
co-BuiDas_validation_colors_2
co-BuiDas_substitutions
ta-BuiDas_select_table_columns
ta-BuiDas_defining_sql_commands
co-BuiDas_validation_colors
co-BuiDas_special_values
ta-BuiDas_specifying_application_options
co-BuiDas_sql_tab
ta-BuiDas_adding_a_database
co-BuiDas_database_repository
ta-BuiDas_entering_database_information_directory_into_options_ini
ta-BuiDas_generating_encrypted_passwords_for_sql_data_sources
ta-BuiDas_deploying_webstart_dashboards
ta-BuiDas_setting_up_sql_database_connections
ta-BuiDas_direct_jdbc_connection
ta-BuiDas_setting_sql_data_source_options
co-DasProRef_about_this_documentation
co-DasProRef_introduction
co-DasProRef_objects_for_complex_data_visualization
co-DasProRef_about_the_object_properties_window
ta-DasProRef_editing_property_values
ta-DasProRef_copying_and_pasting_property_values
co-DasProRef_graph_objects
co-DasProRef_bar_graphs
re-DasProRef_bar_graph__alert_group
re-DasProRef_bar_graph__background_group
re-DasProRef_bar_graph__bar_group
re-DasProRef_bar_graph__column_group
re-DasProRef_bar_graph__data_group
re-DasProRef_bar_graph__data_format_group
re-DasProRef_bar_graph__data_label_group
re-DasProRef_bar_graph__historian_group
re-DasProRef_bar_graph__interaction_group
re-DasProRef_bar_graph__label_group
re-DasProRef_bar_graph__layout_group
re-DasProRef_bar_graph__legend_group
re-DasProRef_bar_graph__marker_group
re-DasProRef_bar_graph__object_group
re-DasProRef_bar_graph__plot_area_group
re-DasProRef_bar_graph__trace_group
re-DasProRef_bar_graph__x_axis_group
re-DasProRef_bar_graph__y_axis_group
co-DasProRef_google_map
re-DasProRef_google_map_data_group
re-DasProRef_google_map_interaction_group
re-DasProRef_google_map_map_group
re-DasProRef_google_map_object_group
re-DasProRef_google_map_licensing
co-DasProRef_heat_map
co-DasProRef_heat_maps_with_one_index_column
co-DasProRef_heat_maps_with_multiple_index_columns
co-DasProRef_mapping_from_possible_aggregation_results_to_colors
co-DasProRef_drill_down_displays
co-DasProRef_object_class_name
re-DasProRef_heat_map_property_groups
re-DasProRef_heat_map__background_properties
re-DasProRef_heat_map__data_group
re-DasProRef_heat_map__data_format_group
re-DasProRef_heat_map__data_label_group
re-DasProRef_heat_map__historian_group
re-DasProRef_heat_map__interaction_group
re-DasProRef_heat_map__label_group
re-DasProRef_heat_map__layout_group
re-DasProRef_heat_map__node_group
re-DasProRef_heat_map__object_group
re-DasProRef_heat_map__quality_group
co-DasProRef_legend
re-DasProRef_legend__background_group
re-DasProRef_legend__data_group
re-DasProRef_legend__historian_group
re-DasProRef_legend__interaction_group
re-DasProRef_legend__label_group
re-DasProRef_legend__legend_group
re-DasProRef_legend__object_group
co-DasProRef_pie_graph
re-DasProRef_pie_graph__background_group
re-DasProRef_pie_graph__column_group
re-DasProRef_pie_graph__data_group
re-DasProRef_pie_graph__data_format_group
re-DasProRef_pie_graph__data_label_group
re-DasProRef_pie_graph__historian_group
re-DasProRef_pie_graph__interaction_group
re-DasProRef_pie_graph__label_group
re-DasProRef_pie_graph__legend_group
re-DasProRef_pie_graph__object_group
re-DasProRef_pie_graph__wedge_group
co-DasProRef_radar_graph
re-DasProRef_radar_graph__alert_group
re-DasProRef_radar_graph__background_group
re-DasProRef_radar_graph__column_group
re-DasProRef_radar_graph__data_group
re-DasProRef_radar_graph__data_format_group
re-DasProRef_radar_graph__data_label_group
re-DasProRef_radar_graph__historian_group
re-DasProRef_radar_graph__interaction_group
re-DasProRef_radar_graph__label_group
re-DasProRef_radar_graph__legend_group
re-DasProRef_radar_graph__marker_group
re-DasProRef_radar_graph__object_group
re-DasProRef_radar_graph__plot_area_group
re-DasProRef_radar_graph__radial_axis_group
re-DasProRef_radar_graph__trace_group
re-DasProRef_radar_graph__value_axis_group
co-DasProRef_xy_graph
re-DasProRef_xy_graph__alert_group
re-DasProRef_xy_graph__background_group
re-DasProRef_xy_graph__column_group
re-DasProRef_xy_graph__data_group
re-DasProRef_xy_graph__data_format_group
re-DasProRef_xy_graph__data_label_group
re-DasProRef_xy_graph__historian_group
re-DasProRef_xy_graph__interaction_group
re-DasProRef_xy_graph__label_group
re-DasProRef_xy_graph__legend_group
re-DasProRef_xy_graph__marker_group
re-DasProRef_xy_graph__object_group
re-DasProRef_xy_graph__plot_area_group
re-DasProRef_xy_graph__trace_group
re-DasProRef_xy_graph__x_axis_group
re-DasProRef_xy_graph__y_axis_group
co-DasProRef_table_objects
co-DasProRef_standard_tables
re-DasProRef_standard_table__alert_group
re-DasProRef_standard_table__background_group
re-DasProRef_standard_table__cell_group
re-DasProRef_standard_table__column_group
re-DasProRef_standard_table__column_header_group
re-DasProRef_standard_table__data_group
re-DasProRef_standard_table__data_label_group
re-DasProRef_standard_table__grid_group
re-DasProRef_standard_table__historian_group
re-DasProRef_standard_table__interaction_group
re-DasProRef_standard_table__label_group
re-DasProRef_standard_table__object_group
re-DasProRef_standard_table__row_header_group
re-DasProRef_standard_table__sort_group
co-DasProRef_rotated_tables
re-DasProRef_rotated_table__background_group
re-DasProRef_rotated_table__cell_group
re-DasProRef_rotated_table__column_group
re-DasProRef_rotated_table__data_group
re-DasProRef_rotated_table__grid_group
re-DasProRef_rotated_table__historian_group
re-DasProRef_rotated_table__interaction_group
re-DasProRef_rotated_table__label_group
re-DasProRef_rotated_table__object_group
co-DasProRef_html5_tables
co-DasProRef_trend_objects
co-DasProRef_sparkline_charts
re-DasProRef_sparkline_chart__alert_group
re-DasProRef_sparkline_chart__background_group
re-DasProRef_sparkline_chart__data_group
re-DasProRef_sparkline_chart__data_format_group
re-DasProRef_sparkline_chart__historian_group
re-DasProRef_sparkline_chart__interaction_group
re-DasProRef_sparkline_chart__label_group
re-DasProRef_sparkline_chart__legend_group
re-DasProRef_sparkline_chart__marker_group
re-DasProRef_sparkline_chart__object_group
re-DasProRef_sparkline_chart__plot_area_group
re-DasProRef_sparkline_chart__trace_group
re-DasProRef_sparkline_chart__x_axis_group
re-DasProRef_sparkline_chart__y_axis_group
co-DasProRef_stock_charts
re-DasProRef_stock_chart__background_group
re-DasProRef_stock_chart__data_group
re-DasProRef_stock_chart__data_format_group
re-DasProRef_stock_chart__interaction_group
re-DasProRef_stock_chart__historian_group
re-DasProRef_stock_chart__label_group
re-DasProRef_stock_chart__legend_group
re-DasProRef_stock_chart__object_group
re-DasProRef_stock_chart__plot_area_group
re-DasProRef_stock_chart__price_trace_group
re-DasProRef_stock_chart__trace_group
re-DasProRef_stock_chart__trace
re-DasProRef_stock_chart__x_axis_group
re-DasProRef_stock_chart__y_axis_group
co-DasProRef_trend_graphs
re-DasProRef_trend_graph__alert_group
re-DasProRef_trend_graph__background_group
re-DasProRef_trend_graph__data_group
re-DasProRef_trend_graph__data_format_group
re-DasProRef_trend_graph__interaction_group
re-DasProRef_trend_graph__label_group
re-DasProRef_trend_graph__legend_group
re-DasProRef_trend_graph__marker_group
re-DasProRef_trend_graph__object_group
re-DasProRef_trend_graph__plot_area_group
re-DasProRef_trend_graph__trace_group
re-DasProRef_trend_graph__trace
re-DasProRef_trend_graph__trace_groups_group
re-DasProRef_trend_graph__x_axis_group
re-DasProRef_trend_graph__y_axis_group
co-DasProRef_drill_down_specification
ta-DasProRef_using_the_drill_down_properties_dialog
ta-DasProRef_activating_drill_downs
co-DasProRef_about_drilldown_displays_opened_in_dashboard_builder
co-DasFunRef_how_this_book_is_organized
co-DasFunRef_introduction_to_dashboard_functions
ta-DasFunRef_working_with_functions
co-DasFunRef_scalar_functions
re-DasFunRef_add
re-DasFunRef_average
re-DasFunRef_boolean_expression
re-DasFunRef_concatenate
re-DasFunRef_correlator_time_format
re-DasFunRef_date_add
re-DasFunRef_date_ceiling
re-DasFunRef_date_compare
re-DasFunRef_date_difference
re-DasFunRef_date_floor
re-DasFunRef_date_format
re-DasFunRef_date_now
re-DasFunRef_delta
re-DasFunRef_divide
re-DasFunRef_duration
re-DasFunRef_evaluate_expression_as_double
re-DasFunRef_evaluate_expression_as_string
re-DasFunRef_format_number
re-DasFunRef_get_substitution
re-DasFunRef_init_local_variable
re-DasFunRef_iswindowsos
re-DasFunRef_max
re-DasFunRef_min
re-DasFunRef_modulo
re-DasFunRef_multiply
re-DasFunRef_percent
re-DasFunRef_quick_set_sub
re-DasFunRef_replace_all
re-DasFunRef_replace_value
re-DasFunRef_set_substitution
re-DasFunRef_set_substitutions_by_lookup
re-DasFunRef_subtract
re-DasFunRef_validate_substitutions
co-DasFunRef_tabular_functions
re-DasFunRef_add_all_rows_or_columns
re-DasFunRef_add_columns
re-DasFunRef_average_all_rows_or_columns
re-DasFunRef_average_columns
re-DasFunRef_baseline_over_time
re-DasFunRef_buffer_table_rows
re-DasFunRef_combine
re-DasFunRef_concatenate_columns
re-DasFunRef_convert_columns
re-DasFunRef_copy
re-DasFunRef_count
re-DasFunRef_count_by_bands
re-DasFunRef_count_unique_values
re-DasFunRef_count_unique_values_by_time
re-DasFunRef_create_selector_list
re-DasFunRef_delta_and_rate_rows
re-DasFunRef_delta_rows
re-DasFunRef_distinct_values
re-DasFunRef_divide_columns
re-DasFunRef_ensure_columns
re-DasFunRef_ensure_timestamp_column
re-DasFunRef_evaluate_expression_by_row
re-DasFunRef_filter_and_extract_matches
re-DasFunRef_filter_by_pattern
re-DasFunRef_filter_by_row
re-DasFunRef_filter_by_time_range
re-DasFunRef_first_table_rows
re-DasFunRef_format_table_columns
re-DasFunRef_get_data_server_connection_status
re-DasFunRef_group_by_time
re-DasFunRef_group_by_time_and_unique_values
re-DasFunRef_group_by_unique_values
re-DasFunRef_join
re-DasFunRef_join_outer
re-DasFunRef_last_table_rows
re-DasFunRef_mark_time_gaps
re-DasFunRef_max_all_rows_or_columns
re-DasFunRef_max_columns
re-DasFunRef_min_all_rows_or_columns
re-DasFunRef_min_columns
re-DasFunRef_modulo_columns
re-DasFunRef_multiply_columns
re-DasFunRef_percent_columns
re-DasFunRef_pivot_on_unique_values
re-DasFunRef_reference
re-DasFunRef_rename_columns
re-DasFunRef_select_column
re-DasFunRef_set_column_type
re-DasFunRef_sort_table
re-DasFunRef_split_string
re-DasFunRef_string_to_table
re-DasFunRef_subtotal_by_time
re-DasFunRef_subtotal_by_unique_values
re-DasFunRef_subtract_columns
re-DasFunRef_table_contains_values
co-DasFunRef_expression_syntax
co-DasFunRef_expression_operators
co-DasFunRef_arithmetic_functions_in_expressions
co-DasFunRef_string_functions_in_expressions
co-ConDasWitApaApp_how_this_book_is_organized
co-ConDasWitApaApp_dashboard_deployment_concepts
co-ConDasWitApaApp_deployment_options
co-BuiDas_dashboard_support_for_apple_ipad
co-ConDasWitApaApp_data_server_and_display_server
co-ConDasWitApaApp_process_architecture
co-ConDasWitApaApp_builders_and_administrators
co-ConDasWitApaApp_generating_dashboards
DASHBOARD_GENERATION_EDITOR
ta-ConDasWitApaApp_starting_the_wizard
ta-ConDasWitApaApp_using_the_wizard
ta-ConDasWitApaApp_using_the_titlebar_toolbar
ta-ConDasWitApaApp_using_the_introduction_form
ta-ConDasWitApaApp_using_the_main__create__edit__and_details_forms
DASHBOARD_GENERATION_MAINPAGE
ta-ConDasWitApaApp_using_the_layout_configuration_forms
DASHBOARD_GENERATION_LAYOUT_CONFIGURATION_FORMS
ta-BuiDas_preparing_dashboards_for_deployment
co-ConDasWitApaApp_dashboard_feature_checklist
ta-ConDasWitApaApp_changing_correlator_definitions_for_deployment
co-ConDasWitApaApp_choosing_among_deployment_types
co-ConDasWitApaApp_application_installation
co-ConDasWitApaApp_authentication
co-ConDasWitApaApp_authorization
co-ConDasWitApaApp_data_protection
co-ConDasWitApaApp_scalability
co-ConDasWitApaApp_choosing_among_web_based_deployment_types
co-ConDasWitApaApp_installation
co-ConDasWitApaApp_served_data
co-ConDasWitApaApp_refresh_latency
co-ConDasWitApaApp_dashboard_ipad_support
ta-BuiDas_using_the_deployment_configuration_editor
DASHBOARD_DEPLOY_CONFIG_EDITOR
ta-ConDasWitApaApp_starting_the_configuration_editor
DASHBOARD_NEW_DEPLOY_CONFIG_WIZARD
ta-BuiDas_rename_deploy_configuration
DASHBOARD_DEPLOY_RENAME_CONFIG_DIALOG
ta-ConDasWitApaApp_saving_deployment_configurations
co-BuiDas_title_bar_toolbar
ta-BuiDas_general_settings
ta-ConDasWitApaApp_startup_and_server
ta-ConDasWitApaApp_additional_jar_files
DASHBOARD_DEPLOY_ADD_JAR_FILES_DIALOG
ta-BuiDas_layout_2
ta-BuiDas_using_the_dashboard_package_wizard
DASHBOARD_PACKAGING_WIZARD_PAGE
ta-ConDasWitApaApp_generating_a_deployment_package_from_the_command_line
ta-ConDasWitApaApp_sharing_information_with_the_dashboard_administrator
co-BuiDas_deploying_dashboards
co-BuiDas_generating_the_dashboard__war_file
ta-BuiDas_installing_a_dashboard__war_file
co-BuiDas_inside_a_dashboard__war_file
co-ConDasWitApaApp_additional_steps_for_display_server_deployments
co-ConDasWitApaApp_webstart_deployment
co-ConDasWitApaApp_managing_the_dashboard_data_server_and_display_server
re-ConDasWitApaApp_prerequisites
ta-ConDasWitApaApp_starting_the_data_server_or_display_server
re-ConDasWitApaApp_options_3
co-ConDasWitApaApp_controlling_update_frequency
ta-ConDasWitApaApp_configuring_trend_data_caching
ta-ConDasWitApaApp_managing_connect_and_disconnect_notification
co-ConDasWitApaApp_working_with_multiple_data_servers
co-ConDasWitApaApp_builder_with_multiple_data_servers
co-ConDasWitApaApp_viewer_with_multiple_data_servers
co-ConDasWitApaApp_display_server_deployments_with_multiple_data_servers
co-ConDasWitApaApp_webstart_deployments_with_multiple_data_servers
re-ConDasWitApaApp_managing_and_stopping_the_data_server_and_display_server
co-ConDasWitApaApp_administering_dashboard_security
ta-ConDasWitApaApp_administering_authentication
co-ConDasWitApaApp_authentication_for_local_and_websphere_deployments
co-ConDasWitApaApp_dashboard_login_modules_provided_by_apama
ta-ConDasWitApaApp_developing_custom_login_modules
ta-ConDasWitApaApp_installing_login_modules
ta-ConDasWitApaApp_installing_userfileloginmodule
ta-ConDasWitApaApp_installing_ldaploginmodule
ta-ConDasWitApaApp_administering_authorization
co-ConDasWitApaApp_users_and_roles
ta-ConDasWitApaApp_default_scenario_and_dataview_access_control
ta-ConDasWitApaApp_customizing_scenario_and_dataview_access_control
co-ConDasWitApaApp_providing_a_scenario_authority
ta-ConDasWitApaApp_developing_a_custom_scenario_authority
ta-ConDasWitApaApp_implementing_iscenarioauthority_methods
ta-ConDasWitApaApp_installing_a_scenario_authority
co-ConDasWitApaApp_sample_custom_scenario_authority
co-ConDasWitApaApp_send_event_authorization
co-ConDasWitApaApp_using_usercredential_accessor_methods
co-ConDasWitApaApp_compiling_your_event_authority
ta-ConDasWitApaApp_installing_your_event_authority
ta-ConDasWitApaApp_providing_a_login_module_that_supports_a_scenario_or_event_authority
ta-ConDasWitApaApp_securing_communications
co-ConDasWitApaApp_example__implementing_loginmodule
co-UsiTheDasVie_how_this_book_is_organized
co-UsiTheDasVie_concepts
dashboard_viewer_context
co-UsiTheDasVie_about_dashboards
ta-UsiTheDasVie_starting_the_dashboard_viewer
co-UsiTheDasVie_scenario_instance_and_dataview_item_ownership
co-UsiTheDasVie_using_the_dashboard_viewer
ta-UsiTheDasVie_opening_and_viewing_dashboards
ta-UsiTheDasVie_running_the_statistical_arbitrage_demo
ta-UsiTheDasVie_displaying_additional_dashboards
ta-UsiTheDasVie_creating_instances_visualized_by_the_statistical_arbitrage_main_dashboard
re-UsiTheDasVie_the_dashboard_viewer_menubar
ta-UsiTheDasVie_resizing_the_dashboard_viewer
co-UsiTheDasVie_working_with_dashboard_objects
co-UsiTheDasVie_trend_charts
co-UsiTheDasVie_stock_charts
ta-UsiTheDasVie_tables
co-UsiTheDasVie_pie_and_bar_charts
co-UsiTheDasVie_startup_options
co-UsiTheDasVie_timezone_id_values
to-help_deploying_and_managing_apama_applications
co-DepAndManApaApp_how_this_book_is_organized
co-DepAndManApaApp_security_requirements_for_Apama
co-DepAndManApaApp_overview_of_deploying_apama_applications
co-DepAndManApaApp_command_central
co-DepAndManApaApp_about_deploying_apama_applications_with_an_ant_script
co-DepAndManApaApp_using_apama_command_line_utilities
co-DepAndManApaApp_deploying_dashboards
co-DepAndManApaApp_tuning_applications_for_performance
co-DepAndManApaApp_setting_up_the_environment_using_the_apama_command_prompt
co-DepAndManApaApp_deploying_apama_components_with_command_central
co-DepAndManApaApp_overview_of_deploying_components_with_command_central
co-DepAndManApaApp_getting_started_with_command_central
co-DepAndManApaApp_using_command_central_web_interface
co-DepAndManApaApp_using_command_central_command_line_interface
co-about_administering_apama
cce.apama.about.administering.apama
ta-creating_and_deleting_instances_using_cc_webui
ta-configuring_instances_using_cc_webui
cce.configuring.instances
re-creating_and_deleting_apama_component_instances
cce.apama.creating.deleting.apama.component.instance
re-commands_that_apama_components_support
re-configuration_types_that_apama_components_support
cce.apama.configuring.apama.component.instance
re-configuration_types_that_apama_correlator_supports
re-the_correlator_persistence_properties
re-the_correlator_license_key
re-configuration_types_that_apama_iaf_supports
re-the_iaf_configuration_file
re-configuration_types_that_apama_display_server_and_apama_data_server_support
re-server_modes
re-additional_.jar_files
re-memory_configuration
re-component_endpoint_configuration
re-usage_notes
re-extra_arguments
re-component_logging
re-component_ports
re-apama_environment_variables
re-correlator_connections
re-correlator_initializations
ta-configuring_digital_event_services_for_a_correlator_instance
re-retrieving_configuration_data_for_apama_component_instances
re-lifecycle_actions_for_apama_component_instances
cce.apama.starting.stopping.apama.component.instance
re-monitoring_apama_from_command_central
re-monitoring_kpis_for_correlator
re-monitoring_kpis_for_epl_applications
re-monitoring_kpis_for_iaf
re-monitoring_kpis_for_dashboard_servers
re-viewing_log_files
cce.apama.viewing.log.files
co-DepAndManApaApp_deploying_designer_project_to_command_central
co-DepAndManApaApp_configuring_deploying_managing_queries
co-DepAndManApaApp_query_overview_of_steps_to_deploy
co-DepAndManApaApp_query_architecture_overview
co-DepAndManApaApp_deploying_query_applications
co-DepAndManApaApp_clustering_queries
co-DepAndManApaApp_query_deploy_on_multiple_nodes
co-DepAndManApaApp_deploying_bigmemory_terracotta_server_array
co-DepAndManApaApp_configuring_bigmemory_driver
co-DepAndManApaApp_query_connecting_to_jms
co-DepAndManApaApp_mixing_queries_with_monitors
co-DepAndManApaApp_handling_node_failure_and_failover
co-DepAndManApaApp_managing_parameterizations
co-DepAndManApaApp_creating_new_query_instances
co-DepAndManApaApp_changing_parameter_values_for_running_queries
co-DepAndManApaApp_query_monitoring
co-DepAndManApaApp_tuning_correlator_performance
co-DepAndManApaApp_scaling_up_apama
co-DepAndManApaApp_partitioning_strategies
co-DepAndManApaApp_engine_topologies
re-DepAndManApaApp_correlator_pipelining
re-DepAndManApaApp_configuring_pipelining_with_engine_connect
co-DepAndManApaApp_connection_configuration_file
co-DepAndManApaApp_configuring_pipelining_through_the_client_api
re-DepAndManApaApp_event_partitioning
co-DepAndManApaApp_managing_and_monitoring_over_rest
co-DepAndManApaApp_generic_management
co-DepAndManApaApp_correlator_management
co-DepAndManApaApp_iaf_management
co-DepAndManApaApp_dashboard_management
co-DepAndManApaApp_correlator_utilities_reference
re-DepAndManApaApp_starting_the_correlator
co-DepAndManApaApp_specifying_correlator_log_filename
co-DepAndManApaApp_command_line_examples_for_creating_a_replay_log
ta-DepAndManApaApp_logging_correlator_status
co-DepAndManApaApp_text_internationalization_issues
co-DepAndManApaApp_determining_whether_to_disconnect_slow_receivers
co-DepAndManApaApp_description_of_slow_receivers
co-DepAndManApaApp_how_frequently_slow_receivers_occur
co-DepAndManApaApp_correlator_behavior_when_there_is_a_slow_receiver
co-DepAndManApaApp_tradeoffs_for_disconnecting_a_slow_receiver
co-DepAndManApaApp_determining_whether_to_disable_the_correlator_s_internal_clock
co-DepAndManApaApp_injection_time_of_compiled_runtime
re-DepAndManApaApp_injecting_epl_code
re-DepAndManApaApp_deploying_a_correlator
re-DepAndManApaApp_deleting_epl_code
re-DepAndManApaApp_packaging_correlator_input_files
re-DepAndManApaApp_sending_events_to_correlators
re-DepAndManApaApp_receiving_events_from_correlators
re-DepAndManApaApp_watching_correlator_runtime_status
re-DepAndManApaApp_inspecting_correlator_state
re-DepAndManApaApp_shutting_down_and_managing_components
ta-DepAndManApaApp_viewing_garbage_collection_information
co-DepAndManApaApp_using_the_epl_memory_profiler
ta-DepAndManApaApp_using_the_cpu_profiler
co-DepAndManApaApp_setting_logging_attributes_for_packages__monitors_and_events
co-DepAndManApaApp_rotate_log
co-DepAndManApaApp_rotating_all_logs
co-DepAndManApaApp_rotating_individual_logs
re-DepAndManApaApp_using_the_command_line_debugger
ta-DepAndManApaApp_obtaining_online_help_for_the_command_line_debugger
ta-DepAndManApaApp_enabling_and_disabling_debugging_in_the_correlator
co-DepAndManApaApp_working_with_breakpoints_using_the_command_line_debugger
ta-DepAndManApaApp_controlling_execution_with_the_command_line_debugger
co-DepAndManApaApp_the_wait_command
co-DepAndManApaApp_command_shortcuts_for_the_command_line_debugger
ta-DepAndManApaApp_examining_the_stack_with_the_command_line_debugger
ta-DepAndManApaApp_displaying_variables_with_the_command_line_debugger
co-DepAndManApaApp_generating_code_coverage_information_about_epl_files
co-DepAndManApaApp_recording_code_coverage_information
re-DepAndManApaApp_creating_code_coverage_reports
co-DepAndManApaApp_interpreting_the_html_code_coverage_reports
co-DepAndManApaApp_using_epl_code_coverage_with_pysys_tests
co-DepAndManApaApp_using_a_replay_log_to_diagnose_problems
ta-DepAndManApaApp_creating_a_replay_log
ta-DepAndManApaApp_rotating_the_replay_log
co-DepAndManApaApp_performance_when_generating_a_replay_log
co-DepAndManApaApp_reproducing_correlator_behavior_from_a_replay_log
co-DepAndManApaApp_event_file_format
co-DepAndManApaApp_event_representation
co-DepAndManApaApp_event_timing
co-DepAndManApaApp_event_data_types
co-DepAndManApaApp_event_channel_association
re-DepAndManApaApp_using_the_data_player_command_line_interface
co-DepAndManApaApp_configuring_the_correlator
co-DepAndManApaApp_using_yaml_configuration_files
co-DepAndManApaApp_including_yaml_configuration_files_inside_another_yaml_configuration_file
co-DepAndManApaApp_sample_yaml_configuration_file_for_the_correlator
co-DepAndManApaApp_using_properties_files
co-DepAndManApaApp_runtime_parameterization_of_configuration
co-DepAndManApaApp_specifying_the_correlator_port_number
co-DepAndManApaApp_binding_server_components_to_particular_addresses
co-DepAndManApaApp_ensuring_that_client_connections_are_from_particular_addresses_yaml
co-DepAndManApaApp_setting_environment_variables_for_apama_components_yaml
co-DepAndManApaApp_setting_log_files_and_log_levels_in_a_yaml_configuration_file
co-DepAndManApaApp_configuring_persistence_in_a_yaml_configuration_file
co-DepAndManApaApp_specifying_jvm_options
co-DepAndManApaApp_deploying_apama_applications_with_a_yaml_configuration_file
co-DepAndManApaApp_using_the_apama_component_extended_configuration_file
ta-DepAndManApaApp_binding_server_components_to_particular_addresses
co-DepAndManApaApp_ensuring_that_client_connections_are_from_particular_addresses
co-DepAndManApaApp_setting_environment_variables_for_apama_components
co-DepAndManApaApp_sample_extended_configuration_file
co-ApaDoc_apamadoc_documentation
co-ApaDoc_apama_java_api_reference
co-ApaDoc_apama_doxygen_api_reference
co-ApaDoc_apama_dotnet_api_reference
to-online-copyright-page