Apama Documentation
About the Apama Version 9.10 Documentation
Documentation roadmap
Online Information
Contacting customer support
Release Notes
Overview
License Terms and Technical Restrictions
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
What's New in Apama 5.0.1
Linux runtime performance enhancement
Changes to the Apama Database Connector
Integrating JMon applications with Corticon
Correlator-integrated adapter for JMS bundle name changes
Improved profiling analysis
5.0 features now documented
Specifying Dashboard Builder options in Apama Studio
What's New in Apama 5.0
Changes to EPL features in Apama 5.0
EPL changes without migration implications
EPL changes that might have migration implications
The com.apama namespace is restricted
New Apama client API support for decimal type
New ADBC adapter features
Packaged Progress database drivers
New Web Services client adapter features
New correlator-integrated messaging for JMS features
Event parser usability/type-safety improvements
Correlator Deployment Packages
New correlator startup option
Changes to engine_send
Deprecated serialize and deserialize operations have been removed
Deprecated high availability components removed
Changes in Apama Studio
Changes related to dashboards
Event Modeler standard block changes
Migrating from Apama 4.3
Platform changes between 4.3 and 5.0
Changes to Apama client APIs between 4.3 and 5.0
Migrating 4.3 projects that use Web Services Client adapters
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 Event Modeler
Description of Dashboard Builder and Dashboard Viewer
Description of client development kits
Description of Management and Monitoring Console
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 scenarios and blocks
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
block
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
event
event collection
event listener
Event Modeler
event pattern
event template
.evt
exception
IAF
Integration Adapter Framework (IAF)
JMon
latest event
listener
lot
Management and Monitoring
match set
MemoryStore
.mon
monitor
MonitorScript
parameterization
parameters
partition
partitioning
plug-in
.qry
query
query aggregate
Query Designer
query input definition
query instance
query key
query window
range
.rtv
scenario
.sdf
sentinel agent
simulation
SmartBlock
Software AG Designer
stack trace element
standard blocks
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
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
Adding resources to EPL projects
Adding resources to JMon projects
Adding JMon applications
Adding JMon classes
Adding non-JMon Java files
Adding bundles to projects
Bundle instances
Adding adapters to projects
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
Searching in EPL files
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
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
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
Using Software AG Designer to configure adapters that use UM
Using Query Designer
Use cases for queries
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
Injections
Event Files
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
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
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
Adapters
Web Service
Catalogs
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
Architectural comparison of queries and monitors
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
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
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 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
Format for defining query parameters
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
Out of band notification events
Enabling out of band 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
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
Defining loops
Catching exceptions
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 correlator 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 correlator 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 Correlator Plug-ins in EPL
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 correlator 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 in headless mode
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
Exporting scenarios as EPL
Exporting scenarios as block templates
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
Correlator timestamps and real time
Event arrival time
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 Correlator Plug-ins
Introduction to Correlator Plug-ins
Providing an EPL event wrapper for a plug-in
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 event correlator
Asynchronous plug-ins
Writing correlator 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 Correlator 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
sequence
StackTraceElement
stream
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
Reserved words in queries
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
Variable declaration statements
Compound statements
The for statement
The from statement
The if 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
List of EPL keywords
List of identifiers reserved for future use
Escaping keywords to use them as identifiers
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 Keyword Quick Reference
EPL Methods Quick Reference
EPL Streams: A Quick Tour
About the Apama event stream processing model
Example events for stream queries
Processing events using streams
Creating a stream network
Using inline stream source template expressions
Using compound stream queries
Using dynamic values in stream queries
Using stream variables
Using the short-form from statement
Stream lifetime
Using windows in stream queries
Using joins in stream queries
Using partitions and groups in stream queries
Using rstream
Common stream query patterns
Aggregation in stream queries
Throttling in stream queries
Dynamic filters in stream queries
Joining the most recent event on each of two streams
Retaining the most recent item in each partition of a partitioned stream
Joining an event with a previous event
Connecting Apama Applications to External Components
Overview
Using Standard Adapters
Using the Apama Database Connector
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
ADBC blocks
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
Using the Apama Web Services Client 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
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
Specifying an XSLT transformation type
Adding an XPath XML transformation to a mapping rule
Specifying an XMLDecode transformation type
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 Web Services Client adapter
Web Services Client adapter artifacts
Updating a Web Service operation using the Archive Editor
Using the Apama File Adapter
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
Using Adapter Plug-ins
The Null Codec plug-in
Null codec transport-related properties
The File Transport plug-in
The String Codec plug-in
The Filter Codec plug-in
Filter codec transport-related properties
Specifying filters for the filter codec
Examples of filter specifications
The XML codec 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 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 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
Using Message Services
Using Correlator-Integrated Messaging for 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
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
Adding an XPath XML transformation to a mapping rule
Specifying an XSLT transformation type
Specifying an XMLDecode transformation type
Convention-based XML mapping
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
Using Universal Messaging in Apama Applications
Overview of using UM in Apama applications
Comparison of Apama channels and UM channels
Choosing when to use UM channels and when to use Apama channels
General steps for using UM in Apama applications
About events transported by UM
Using UM channels instead of engine_connect
Using UM channels instead of configuring adapter connections
Enabling automatic creation of UM channels
Considerations for using UM channels
Setting up UM for use by Apama
Starting correlators that use UM
Configuring adapters to use UM
EPL and UM channels
Defining UM properties for Apama applications
Monitoring Apama application use of UM
Working with Connectivity Plug-ins
Using Connectivity Plug-ins
Overview of using connectivity plug-ins
Predefined connectivity plug-ins
Configuration file for connectivity plug-ins
Host plug-ins and configuration
Translating EPL events using the apama.eventMap host plug-in
Deploying connectivity plug-ins
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
Building plug-ins
C++ data types
Map contents used by the apama.eventMap host plug-in
Metadata values
Lifetime of connectivity plug-ins
Logging and configuration
Threading
Developing Custom Adapters
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 event correlator configuration
Configuring adapters to use UM
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
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
Applet and WebStart 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
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
Sending Events to Correlators
Using the Define Apama Command dialog
Command field
Package field
Event field
Channel field
Other dialog fields
Default values
Specifying values for complex types
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 applet and WebStart 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 command support
Dashboard iPad Support
Using the Deployment Configuration editor
Starting the Configuration editor
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
Applet and WebStart 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
Applet and WebStart 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 scenario 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
Getting started with Command Central
Deploying an Apama project in Command Central
About deploying Apama applications with a YAML configuration file
About deploying components with EMM
About Apama command line utilities
About deploying dashboards
About tuning applications for performance
Setting up the environment using the Apama Command Prompt
Using the Management and Monitoring Console
Installation
Concepts
The EMM console window
Committed values and outstanding changes
State persistence
Managing licenses
Managing security
Managing hosts
Sentinel Agents
Using the sentinel_agent tool
Working directory
Working with hosts
Managing all known hosts
Managing components
Component status indicators
Working with components
Add correlator
Add adapter
Remove component
Move component to host
Start component
Stop component
Restart component
Clear all component logs
Configuring components with the details pane
Specifying paths and filenames in the Details Pane
Preferences
Warnings
Display
Timing
Deploying and Configuring Correlators
Adding correlators
The correlator tabs
Management tab
Configuration tab
Initialization tab
Adding initialization actions
Connections tab
Adding new upstream connections
Downstream connections
Statistics tab
Inspect tab
Deleting Monitors, Event Types, or JMon applications from a correlator
Displaying event type definition for multiple Event Types
Diagnostics tab
Deploying and Configuring Adapters
Adding adapters
Configuring adapters
Specifying paths and filenames in the Details Pane
The Adapter tabs
Management tab
Configuration tab
Connections tab
Control tab
Statistics tab
Diagnostics tab
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 and scenarios
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
Event 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 event 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
Deleting code from a correlator
Packaging EPL and Java code
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
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
Setting log files and log levels in an extended configuration file
Sample extended configuration file
Starting a correlator with an 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
co-ApaEplRef_documentation_roadmap
re-webm_online_information
co-ApaEplRef_contacting_customer_support
co-WhaNewInApa_about_this_documentation
co-WhaNewInApa_license_terms_and_technical_restrictions
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
co-WhaNewInApa_what_s_new_in_apama_5_0_1
co-WhaNewInApa_linux_runtime_performance_enhancement
co-WhaNewInApa_changes_to_the_apama_database_connector
co-WhaNewInApa_integrating_apama_java_applications_with_corticon
co-WhaNewInApa_jms_adapter_bundle_name_changes
co-WhaNewInApa_improved_profiling_analysis
co-WhaNewInApa_5_0_features_now_documented
co-WhaNewInApa_specifying_dashboard_builder_options_in_apama_studio
co-WhaNewInApa_what_s_new_in_apama_5_0
co-WhaNewInApa_changes_to_epl_features_in_apama_5_0
co-ApaRelNot_50_epl_changes
co-ApaRelNot_migration_43_50_epl
co-WhaNewInApa_the_com_apama_namespace_is_restricted
co-WhaNewInApa_new_apama_client_api_support_for_decimal_type
co-WhaNewInApa_new_adbc_adapter_features
co-WhaNewInApa_packaged_sag_database_drivers
co-WhaNewInApa_new_web_services_client_adapter_features
co-WhaNewInApa_new_correlator_integrated_jms_messaging_features
co-WhaNewInApa_event_parser_usability_type_safety_improvements
co-WhaNewInApa_correlator_deployment_packages
co-WhaNewInApa_new_correlator_startup_option
co-WhaNewInApa_changes_to_engine_send
co-WhaNewInApa_deprecated_serialize_and_deserialize_operations_have_been_removed
co-WhaNewInApa_deprecated_high_availability_components_removed
co-WhaNewInApa_changes_in_apama_studio
co-WhaNewInApa_changes_related_to_dashboards
co-WhaNewInApa_event_modeler_standard_block_changes
co-ApaRelNot_migration_43_50
co-ApaRelNot_migration_43_50_platforms
co-ApaRelNot_migration_43_50_client_APIs
co-ApaRelNot_migration_43_50_web_services_client_adapter
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
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_event_modeler
tutorialEMintro
co-IntToApa_description_of_dashboard_builder_and_dashboard_viewer
co-IntToApa_description_of_client_development_kits
co-IntToApa_description_of_management_and_monitoring_console
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-IntToApa_understanding_scenarios_and_blocks
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
co-UsiApaStu_how_this_book_is_organized
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
co-UsiApaStu_workbench_project_view
co-UsiApaStu_the_apama_developer_perspective
co-UsiApaStu_project_explorer_view
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
ta-UsiApaStu_creating_event_definitions_by_adding_epl_code
ta-UsiApaStu_creating_event_definitions_from_xml_files
ta-UsiApaStu_creating_event_definitions_from_xsd_files
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
ta-UsiApaStu_creating_a_block_with_the_block_editor
ta-UsiApaStu_creating_a_block_from_an_epl_event_definition
ta-UsiApaStu_adding_epl_code_to_a_block
ta-UsiApaStu_creating_new_scenario_functions
ta-UsiApaStu_creating_new_dashboards
DASHBOARD_NEW_CONFIG_WIZARD
ta-UsiApaStu_creating_new_dashboard_deployment_configurations
ta-UsiApaStu_creating_new_event_files
ta-UsiApaStu_adding_resources_to_epl_projects
ta-UsiApaStu_adding_resources_to_apama_java_projects
ta-UsiApaStu_adding_apama_java_applications
ta-UsiApaStu_adding_apama_java_classes
ta-UsiApaStu_adding_non_apama_java_files
ta-UsiApaStu_adding_bundles_to_projects
ta-UsiApaStu_bundle_instances
ta-UsiApaStu_adding_adapters_to_projects
co-UsiApaStu_um_adding_config_to_project
ta-UsiApaStu_editing_apama_files
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_searching_in_epl_files
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
ta-UsiApaStu_project_source_files
ta-UsiApaStu_specifying_projects
ta-UsiApaStu_specifying_external_dependencies
ta-UsiApaStu_specifying_dependencies_for_a_single_user_project
ta-UsiApaStu_specifying_dependencies_for_a_multi_user_project
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
ta-UsiApaStu_exporting_a_launch_configuration
ANT_EXPORT_PAGE
ta-UsiApaStu_exporting_scenarios
ta-UsiApaStu_exporting_correlator_deployment_packages
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
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
ta-UsiApaStu_adding_a_correlator
ta-UsiApaStu_correlator_arguments
co-UsiApaStu_persistence_options
ta-UsiApaStu_initialization
co-UsiApaStu_launch_config_event_files_tab
co-UsiApaStu_connecting_components
ta-UsiApaStu_adding_an_external_process
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_using_the_engine_status_view
ta-UsiApaStu_using_the_scenario_browser_view
ta-UsiApaStu_displaying_the_scenario_browser
ta-UsiApaStu_browsing_scenarios
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_launching_a_remote_profiling_session
ta-UsiApaStu_creating_a_remote_profiler_launch_configuration
ta-UsiApaStu_the_apama_profiler_perspective
ta-UsiApaStu_profiling_monitor_view
PROFILER_ProfileLaunchView_View
co-UsiApaStu_execution_statistics_view
co-UsiApaStu_the_execution_statistics_tab
co-UsiApaStu_comparison_of_execution_statistics_tab
ta-UsiApaStu_viewing_epl_code
ta-UsiApaStu_using_filters
ta-UsiApaStu_creating_a_filter
ta-UsiApaStu_managing_filters
ta-UsiApaStu_taking_snapshots
PROFILER_CREATE_SNAPSHOT
ta-UsiApaStu_using_snapshots
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
re-UsiApaStu_data_player_control_view
re-UsiApaStu_playback_settings
re-UsiApaStu_playback_controls
re-UsiApaStu_playback_status
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_adapters
ADAPTERS_PREFERENCES_PAGE
re-UsiApaStu_preferences_webservice
WEB_SERVICE_PREFERENCES_PAGE
re-UsiApaStu_preferences_catalogs
CATALOGS_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
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_comparison_of_queries_and_monitors
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_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_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_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_format_for_defining_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_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_out_of_band_notification_events
ta-DevApaAppInEpl_enabling_out_of_band_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
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
ta-DevApaAppInEpl_defining_conditional_logic
tutorialConditionalLogic
ta-DevApaAppInEpl_defining_loops
co-DevApaAppInEpl_catching_exceptions
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_correlator_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_correlator_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_correlator_plug_ins_in_epl
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
ta-DevApaAppInEpl_configuring_a_distributed_store
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_correlator_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
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_in_headless_mode
co-DevApaAppInEveMod_how_this_book_is_organized
co-DevApaAppInEveMod_overview_of_using_event_modeler
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
ta-DevApaAppInEveMod_exporting_scenarios_as_epl
ta-DevApaAppInEveMod_exporting_scenarios_as_block_templates
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
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
co-DevApaAppInJav_correlator_timestamps_and_real_time
co-DevApaAppInJav_event_arrival_time
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_about_this_documentation
co-WriCorPlu_introduction_to_correlator_plug_ins
co-WriCorPlu_providing_an_EPL_wrapper_for_a_plug_in
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_event_correlator
co-WriCorPlu_asynchronous_plug_ins
co-WriCorPlu_writing_correlator_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_correlator_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_sequence
re-ApaEplRef_stacktraceelement
re-ApaEplRef_stream
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-EplQueRun_reserved_words_in_queries
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_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_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_list_of_epl_keywords
re-ApaEplRef_list_of_identifiers_reserved_for_future_use
ta-ApaEplRef_escaping_keywords_to_use_them_as_identifiers
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_keyword_quick_reference
co-DevApaAppInEpl_epl_methods_quick_reference
co-DevApaApp_epl_streams_quick_tour
co-DevApaApp_swp_the_apama_event_stream_processing_model
co-DevApaApp_swp_example_events
co-DevApaApp_swp_about_processing_events_using_streams
co-DevApaApp_swp_creating_a_stream_network
co-DevApaApp_swp_using_inline_stream_source_template_expressions
co-DevApaApp_swp_using_compound_stream_queries
co-DevApaApp_swp_using_dynamic_values_in_stream_queries
co-DevApaApp_swp_using_stream_variables
co-DevApaApp_swp_using_the_short_form_from_statement
co-DevApaApp_swp_stream_lifetime
co-DevApaApp_swp_using_windows
co-DevApaApp_swp_using_joins
co-DevApaApp_swp_using_partitions_and_groups
co-DevApaApp_swp_using_rstream
co-DevApaApp_swp_common_patterns
co-DevApaApp_swp_aggregation_in_stream_queries
co-DevApaApp_swp_throttling
co-DevApaApp_swp_dynamic_filters
co-DevApaApp_swp_joining_the_most_recent_on_each
co-DevApaApp_swp_retaining_the_most_recent
co-DevApaApp_swp_joining_an_event_with_a_previous_event
co-ConApaAppToExtCom_preface
co-ConApaAppToExtCom_using_standard_adapters
co-DepAndManApaApp_using_the_apama_database_connector
ta-DepAndManApaApp_overview
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_adbc_blocks
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
co-DepAndManApaApp_playback
co-DepAndManApaApp_sample_applications
co-DepAndManApaApp_format_of_events_in__sim_files
co-DepAndManApaApp_the_apama_web_services_client_adapter
co-DepAndManApaApp_web_services_client_adapter_overview
ta-DepAndManApaApp_adding_a_web_services_client_adapter_to_an_apama_studio_project
co-DepAndManApaApp_configuring_a_web_services_client_adapter
ta-DepAndManApaApp_specify_the_web_service_and_operation_to_use
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
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
co-DepAndManApaApp_specifying_transformation_types
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_standard_apama_adapters
co-DevAda_file_adapter_plug_ins
co-DevAda_file_adapter_service_monitor_files
ta-DevAda_adding_the_file_adapter_to_an_apama_studio_project
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_standard_plug_ins
co-DevAda_the_null_codec_plug_in
co-DevAda_null_codec_transport_related_properties
co-DevAda_the_file_transport_plug_in
co-DevAda_the_string_codec_plug_in
co-DevAda_the_filter_codec_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_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_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_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-UsiMesSer_using_message_services
co-DepAndManApaApp_correlator_integrated_jms_messaging
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
ta-DepAndManApaApp_configuring_connections
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
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
ta-ConApaAppToExtCom_adding_an_xpath_xml_transformation_to_a_mapping_rule
ta-ConApaAppToExtCom_specifying_an_xslt_transformation_type
ta-ConApaAppToExtCom_specifying_an_xmldecode_transformation_type
co-DepAndManApaApp_convention_based_xml_mapping
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
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
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-DepAndManApaApp_using_um
co-DepAndManApaApp_um_about
co-DepAndManApaApp_um_comparison_um_apama_channels
co-DepAndManApaApp_um_choosing
co-DepAndManApaApp_um_steps
co-DepAndManApaApp_um_about_events
co-DepAndManApaApp_um_engine_connect_compare
co-DepAndManApaApp_um_comparison_adapters_um_channel
co-DepAndManApaApp_um_channel_mode_property
co-DepAndManApaApp_um_considerations
co-DepAndManApaApp_um_config_in_um
co-DepAndManApaApp_um_starting_correlators
co-DepAndManApaApp_um_specifying_channels_in_apps
co-DepAndManApaApp_um_properties
co-DepAndManApaApp_um_monitoring
co-ConApaAppToExtCom_working_with_connectivity_plug_ins
co-ConApaAppToExtCom_using_connectivity_plug_ins
co-ConApaAppToExtCom_overview_of_using_connectivity_plug_ins
co-ConApaAppToExtCom_predefined_connectivity_plug_ins
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_deploying_connectivity_plug_ins
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_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_logging_and_configuration
co-ConApaAppToExtCom_threading
co-DevAda_how_this_book_is_organized
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_event_correlator_configuration
co-DepAndManApaApp_um_configuring_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
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
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_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_applet_and_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_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_sending_events_to_correlators
ta-BuiDas_using_the_define_apama_command_dialog
co-BuiDas_command_field
co-BuiDas_package_field
co-BuiDas_event_field
co-BuiDas_channel_field
co-BuiDas_other_dialog_fields
co-BuiDas_default_values
ta-BuiDas_specifying_values_for_complex_types
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_applet_and_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
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
ta-ConDasWitApaApp_using_the_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_command_support
co-ConDasWitApaApp_dashboard_ipad_support
ta-BuiDas_using_the_deployment_configuration_editor
ta-ConDasWitApaApp_starting_the_configuration_editor
ta-ConDasWitApaApp_saving_deployment_configurations
co-BuiDas_title_bar_toolbar
ta-BuiDas_general_settings
ta-ConDasWitApaApp_startup_and_server
ta-ConDasWitApaApp_additional_jar_files
ta-BuiDas_layout_2
ta-BuiDas_using_the_dashboard_package_wizard
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_applet_and_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_applet_and_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_scenario_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
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_tips_for_deploying_apama_project_in_command_central
co-DepAndManApaApp_deploying_apama_applications_with_a_yaml_configuration_file
co-DepAndManApaApp_deploying_components_with_emm
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_using_the_management_and_monitoring_console
emm_context
co-DepAndManApaApp_installation
co-DepAndManApaApp_concepts
co-DepAndManApaApp_the_emm_console_window
co-DepAndManApaApp_committed_values_and_outstanding_changes
co-DepAndManApaApp_state_persistence
ta-DepAndManApaApp_managing_licenses
ta-DepAndManApaApp_managing_security
co-DepAndManApaApp_managing_hosts
co-DepAndManApaApp_sentinel_agents
re-DepAndManApaApp_using_the_sentinel_agent_tool
co-DepAndManApaApp_working_directory
co-DepAndManApaApp_working_with_hosts
co-DepAndManApaApp_managing_all_known_hosts
co-DepAndManApaApp_managing_components
co-DepAndManApaApp_component_status_indicators
co-DepAndManApaApp_working_with_components
co-DepAndManApaApp_add_correlator
co-DepAndManApaApp_add_adapter
co-DepAndManApaApp_remove_component
co-DepAndManApaApp_move_component_to_host
co-DepAndManApaApp_start_component
co-DepAndManApaApp_stop_component
co-DepAndManApaApp_restart_component
co-DepAndManApaApp_clear_all_component_logs
co-DepAndManApaApp_configuring_components_with_the_details_pane
co-DepAndManApaApp_specifying_paths_and_filenames_in_the_details_pane
co-DepAndManApaApp_preferences
co-DepAndManApaApp_warnings
co-DepAndManApaApp_display
co-DepAndManApaApp_timing
co-DepAndManApaApp_deploying_and_configuring_correlators
ta-DepAndManApaApp_adding_correlators
co-DepAndManApaApp_the_correlator_tabs
co-DepAndManApaApp_management_tab_2
ta-DepAndManApaApp_configuration_tab
co-DepAndManApaApp_initialization_tab
ta-DepAndManApaApp_adding_initialization_actions
co-DepAndManApaApp_connections_tab
ta-DepAndManApaApp_adding_new_upstream_connections
re-DepAndManApaApp_downstream_connections
ta-DepAndManApaApp_statistics_tab_2
ta-DepAndManApaApp_inspect_tab
ta-DepAndManApaApp_deleting_monitors__event_types__or_java_applications_from_a_correlator
ta-DepAndManApaApp_displaying_event_type_definition_for_multiple_event_types
co-DepAndManApaApp_diagnostics_tab
co-DepAndManApaApp_deploying_and_configuring_adapters
ta-DepAndManApaApp_adding_adapters
ta-DepAndManApaApp_configuring_adapters
ta-DepAndManApaApp_specifying_paths_and_filenames_in_the_details_pane
co-DepAndManApaApp_the_adapter_tabs
co-DepAndManApaApp_management_tab
co-DepAndManApaApp_configuration_tab
ta-DepAndManApaApp_connections_tab
ta-DepAndManApaApp_control_tab
ta-DepAndManApaApp_statistics_tab
co-DepAndManApaApp_diagnostics_tab_2
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_and_scnearios
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_event_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_event_correlator_utilities_reference
re-DepAndManApaApp_starting_the_event_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_deleting_epl_code
re-DepAndManApaApp_packaging_epl_code
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_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_setting_log_files_and_log_levels_in_an_extended_configuration_file
co-DepAndManApaApp_sample_extended_configuration_file
ta-DepAndManApaApp_starting_a_correlator_with_an_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