Go to main content
1/51
Contents
Title and Copyright Information
Preface
Audience
Documentation Accessibility
Related Documents
Conventions
What's New in This Guide
New and Changed Features for 12
c
(12.2.1)
Other Significant Changes in This Document for 12
c
(12.2.1)
Part I Getting Started
1
Introduction to Coherence
Basic Concepts
Clustered Data Management
A single API for the logical layer, XML configuration for the physical layer
Caching Strategies
Data Storage Options
Serialization Options
Configurability and Extensibility
Namespace Hierarchy
Read/Write Caching
NamedCache
NamedCache Usage Patterns
Querying the Cache
Invocation Service
Event Programming
Transactions
HTTP Session Management
Object-Relational Mapping Integration
C++/.NET Integration
Management and Monitoring
2
Building Your First Coherence Application
Task 1: Define the Example Cache
Task 2: Configure and Start the Example Cluster
Task 3: Create and Run a Basic Coherence Standalone Application
Create the Sample Standalone Application
Run the Sample Standalone Application
Verify the Example Cache
Task 4: Create and Run a Basic Coherence JavaEE Web Application
Create the Sample Web Application
Deploy and Run the Sample Web Application
Verify the Example Cache
Using JDeveloper for Coherence Development
Running Coherence in JDeveloper
Viewing Thread Dumps in JDeveloper
Creating Configuration Files in JDeveloper
3
Understanding Configuration
Overview of the Default Configuration Files
Specifying an Operational Configuration File
Using the Default Operational Override File
Specifying an Operational Override File
Defining Override Files for Specific Operational Elements
Viewing Which Operational Override Files are Loaded
Specifying a Cache Configuration File
Using a Default Cache Configuration File
Overriding the Default Cache Configuration File
Using the Cache Configuration File System Property
Viewing Which Cache Configuration File is Loaded
Specifying a POF Configuration File
Overriding the Default POF Configuration File
Using the POF Configuration File System Property
Combining Multiple POF Configuration Files
Viewing Which POF Configuration Files are Loaded
Specifying Management Configuration Files
Specifying a Custom Report Group Configuration File
Overriding the Default Report Group Configuration File
Using the Report Group Configuration File System Property
Specifying an MBean Configuration File
Using the Default MBean Configuration Override File
Using the MBean Configuration File System Property
Viewing Which Management Configuration Files are Loaded
Disabling Schema Validation
Understanding the XML Override Feature
Using the Predefined Override Files
Defining Custom Override Files
Defining Multiple Override Files for the Same Element
Changing Configuration Using System Properties
Using Preconfigured System Properties
Creating Custom System Properties
4
Debugging in Coherence
Overview of Debugging in Coherence
Configuring Logging
Changing the Log Level
Changing the Log Destination
Sending Log Messages to a File
Changing the Log Message Format
Setting the Logging Character Limit
Using JDK Logging for Coherence Logs
Using Log4J Logging for Coherence Logs
Mapping Log4J Log Levels with Coherence Log Levels
Using SLF4J for Coherence Logs
Performing Remote Debugging
Troubleshooting Coherence-Based Applications
Using Coherence Logs
Using JMX Management and Coherence Reports
Using JVM Options to Help Debug
Capturing Thread Dumps
Capturing Heap Dumps
Monitoring the Operating System
Part II Using Coherence Clusters
5
Introduction to Coherence Clusters
Cluster Overview
Understanding Clustered Services
Understanding TCMP
6
Setting Up a Cluster
Overview of Setting Up Clusters
Specifying a Cluster's Name
Specifying a Cluster Member's Identity
Configuring Multicast Communication
Specifying a Cluster's Multicast Address and Port
Changing the Multicast Socket Interface
Disabling Multicast Communication
Specifying the Multicast Time-to-Live
Specifying the Multicast Join Timeout
Changing the Multicast Threshold
Specifying a Cluster Member's Unicast Address
Changing the Default Unicast Address
Changing the Default Unicast Port
Using Well Known Addresses
Specifying WKA Addresses
Specifying a WKA Address Provider
Enabling Single-Server Mode
Configuring Death Detection
Changing TCP-Ring Settings
Changing the Heartbeat Interval
Disabling Death Detection
Specifying Cluster Priorities
Specifying a Cluster Member's Priority
Specifying Communication Thread Priorities
Specifying Thread Priorities for Services
Configuring Firewalls for Cluster Members
7
Starting and Stopping Cluster Members
Starting Cache Servers
Overview of the DefaultCacheServer Class
Starting Cache Servers From the Command Line
Starting Cache Servers Programmatically
Starting Cache Clients
Disabling Local Storage
Using the CacheFactory Class to Start a Cache Client
Stopping Cluster Members
Stopping Cluster Members From the Command Line
Stopping Cache Servers Programmatically
Performing a Rolling Restart
Prerequisites to Performing a Rolling Restart
Restarting Cache Servers for a Rolling Restart
8
Dynamically Managing Cluster Membership
Overview of Managing Cluster Membership
Using the Cluster and Service Objects
Using the Member Object
Listening to Member Events
9
Tuning TCMP Behavior
Overview of TCMP Data Transmission
Throttling Data Transmission
Adjusting Packet Flow Control Behavior
Disabling Packet Flow Control
Adjusting Packet Traffic Jam Behavior
Bundling Packets to Reduce Load
Changing Packet Retransmission Behavior
Changing the Packet Resend Interval
Changing the Packet Resend Timeout
Configuring Packet Acknowledgment Delays
Configuring the Size of the Packet Buffers
Understanding Packet Buffer Sizing
Configuring the Outbound Packet Buffer Size
Configuring the Inbound Packet Buffer Size
Adjusting the Maximum Size of a Packet
Changing the Packet Speaker Volume Threshold
Configuring the Incoming Message Handler
Changing the Time Variance
Disabling Negative Acknowledgments
Using Network Filters
Using the Compression Filter
Enabling the Compression Filter for Specific Services
Enabling the Compression Filter for All Services
Configuring the Compression Filter
Using Custom Network Filters
Declaring a Custom Filter
Enabling a Custom Filter for Specific Services
Enabling a Custom Filter for All Services
Changing the TCMP Socket Provider Implementation
Using the TCP Socket Provider
Using the SDP Socket Provider
Using the SSL Socket Provider
10
Using the Service Guardian
Overview
Configuring the Service Guardian
Setting the Guardian Timeout
Setting the Guardian Timeout for All Threads
Setting the Guardian Timeout Per Service Type
Setting the Guardian Timeout Per Service Instance
Using the Timeout Value From the PriorityTask API
Setting the Guardian Service Failure Policy
Setting the Guardian Failure Policy for All Threads
Setting the Guardian Failure Policy Per Service Type
Setting the Guardian Failure Policy Per Service Instance
Enabling a Custom Guardian Failure Policy
Issuing Manual Guardian Heartbeats
Part III Using Caches
11
Introduction to Coherence Caches
Understanding Distributed Caches
Understanding Replicated Caches
Understanding Optimistic Caches
Understanding Near Caches
Understanding Local Caches
Understanding Remote Caches
Summary of Cache Types
12
Configuring Caches
Overview
Defining Cache Mappings
Using Exact Cache Mappings
Using Name Pattern Cache Mappings
Defining Cache Schemes
Defining Distributed Cache Schemes
Defining Replicated Cache Schemes
Defining Optimistic Cache Schemes
Defining Local Cache Schemes
Controlling the Growth of a Local Cache
Specifying a Custom Eviction Policy
Defining Near Cache Schemes
Near Cache Invalidation Strategies
Using Scheme Inheritance
Using Cache Scheme Properties
Using Parameter Macros
Using User-Defined Parameter Macros
Using Predefined Parameter Macros
Using System Property Macros
13
Implementing Storage and Backing Maps
Cache Layers
Local Storage
Operations
Capacity Planning
Using Partitioned Backing Maps
Using the Elastic Data Feature to Store Data
Journaling Overview
Defining Journal Schemes
Configuring a RAM Journal Backing Map
Configuring a Flash Journal Backing Map
Referencing a Journal Scheme
Using Journal Expiry and Eviction
Using a Journal Scheme for Backup Storage
Enabling a Custom Map Implementation for a Journal Scheme
Changing Journaling Behavior
Configuring the RAM Journal Resource Manager
Configuring the Flash Journal Resource Manager
Using Asynchronous Backup
Using Delta Backup
Enabling Delta Backup
Enabling a Custom Delta Backup Compressor
14
Caching Data Sources
Overview of Caching Data Sources
Pluggable Cache Store
Read-Through Caching
Write-Through Caching
Write-Behind Caching
Write-Behind Requirements
Refresh-Ahead Caching
Selecting a Cache Strategy
Read-Through/Write-Through versus Cache-Aside
Refresh-Ahead versus Read-Through
Write-Behind versus Write-Through
Creating a Cache Store Implementation
Plugging in a Cache Store Implementation
Sample Cache Store Implementation
Sample Controllable Cache Store Implementation
Implementation Considerations
Idempotency
Write-Through Limitations
Cache Queries
Re-entrant Calls
Cache Server Classpath
CacheStore Collection Operations
Connection Pools
15
Serialization Paged Cache
Understanding Serialization Paged Cache
Configuring Serialization Paged Cache
Optimizing a Partitioned Cache Service
Configuring for High Availability
Configuring Load Balancing and Failover
Supporting Huge Caches
16
Using Quorum
Overview of Using Quorum
Using the Cluster Quorum
Configuring the Cluster Quorum Policy
Using the Partitioned Cache Quorums
Configuring the Partitioned Cache Quorum Policy
Using the Proxy Quorum
Configuring the Proxy Quorum Policy
Using Custom Action Policies
Enabling Custom Action Policies
Enabling the Custom Failover Access Policy
17
Cache Configurations by Example
Local Caches (accessible from a single JVM)
In-memory Cache
Size Limited In-memory Cache
In-memory Cache with Expiring Entries
In-memory Cache with Disk Based Overflow
Cache on Disk
Size Limited Cache on Disk
Persistent Cache on Disk
Cache of a Database
Clustered Caches (accessible from multiple JVMs)
Partitioned Cache
Partitioned Cache with Overflow
Partitioned Cache with Journal Storage
Partitioned Cache of a Database
Partitioned Cache with a Serializer
Near Cache
Replicated Cache
Replicated Cache with Overflow
18
Extending Cache Configuration Files
Introduction to Extending Cache Configuration Files
Declaring XML Namespaces
Creating Namespace Handlers
Implementing the Namespace Handler Interface
Extending the Namespace Handler Abstract Class
Registering Processors
Using Injection to Process Element Content
Example: the JNDI Resource Namespace Handler
Create the JNDI Resource Namespace Handler
Declare the JNDI Namespace Handler
Use the JNDI Resource Namespace Handler
Part IV Performing Data Grid Operations
19
Introduction to Coherence Programming
Overview of the Coherence API
Support for Generics
Support for Java 8 Features
20
Performing Basic Cache Operations
Overview of the NamedCache API
Getting a Cache Instance
Requirements for Cached Objects
Performing Cache Put Operations
Performing Cache Get Operations
Performing Cache Remove Operations
Using Default Map Operations
Pre-Loading a Cache
Bulk Loading Data Into a Cache
Performing Distributed Bulk Loading
A Distributed Bulk Loading Example
Clearing Caches
Releasing Caches
Destroying Caches
Performing NameCache Operations Asynchronously
Using NameCache Type Checking
21
Using Portable Object Format
Overview of POF Serialization
Using the POF API to Serialize Objects
Implementing the PortableObject Interface
Implementing the PofSerializer Interface
Guidelines for Assigning POF Indexes
Using POF Object References
Enabling POF Object References
Registering POF Object Identities for Circular and Nested Objects
Registering POF Objects
Configuring Coherence to Use the ConfigurablePofContext Class
Configure the ConfigurablePofContext Class Per Service
Configure the ConfigurablePofContext Class for All Services
Configure the ConfigurablePofContext Class For the JVM
Using POF Annotations to Serialize Objects
Annotating Objects for POF Serialization
Registering POF Annotated Objects
Generating a POF Configuration File
Enabling Automatic Indexing
Providing a Custom Codec
Using POF Extractors and POF Updaters
Navigating a POF object
Using POF Extractors
Using POF Updaters
Serializing Keys Using POF
22
Querying Data In a Cache
Query Overview
Query Concepts
Performing Queries
Efficient Processing of Filter Results
Using Query Indexes
Creating an Index
Creating User-Defined Indexes
Implementing the MapIndex Interface
Implementing the IndexAwareExtractor Interface
Using a Conditional Index
Performing Batch Queries
Performing Queries on Multi-Value Attributes
Using Chained Extractors
Evaluating Query Cost and Effectiveness
Creating Query Records
Interpreting Query Records
Query Explain Plan Record
Query Trace Record
Running The Query Record Example
23
Using Continuous Query Caching
Overview of Using Continuous Query Caching
Understanding Use Cases for Continuous Query Caching
Understanding the Continuous Query Cache Implementation
Constructing a Continuous Query Cache
Cleaning up the resources associated with a ContinuousQueryCache
Caching only keys, or caching both keys and values
Listening to the ContinuousQueryCache
Achieving a Stable Materialized View
Support for Synchronous and Asynchronous Listeners
Making the ContinuousQueryCache Read-Only
24
Processing Data In a Cache
Overview of Processing Data In a Cache
Performing Targeted Processing
Performing Parallel Processing
Performing Query-Based Processing
Performing Data-Grid-Wide Processing
Using Agents for Targeted, Parallel and Query-Based Processing
Processing Entries Using Lambda Expressions
Processing Entries in Multiple Caches
Ignoring the Results of an Entry Processor
Performing Synthetic Operations
Processing Entries Asynchronously
Performing Data Grid Aggregation
Performing Data Grid Aggregation Using Streams
Performing Node-Based Processing
Using a Work Manager
25
Using Map Events
Overview of Map Events
Listener Interface and Event Object
Understanding Event Guarantees
Caches and Classes that Support Events
Signing Up for All Events
Using an Inner Class as a MapListener
Using Lambda Expressions to Add Map Listeners
Configuring a MapListener For a Cache
Signing Up For Events On Specific Identities
Filtering Events
Using Lite Events
Listening to Queries
Filtering Events Versus Filtering Cached Data
Using Synthetic Events
Using Backing Map Events
Producing Readable Backing MapListener Events from Distributed Caches
Using Synchronous Event Listeners
26
Controlling Map Operations with Triggers
Overview of Map Triggers
A Map Trigger Example
27
Using Live Events
Overview of Live Events
Understanding Live Event Types
Understanding Partitioned Cache Events
Entry Events
Entry Processor Events
Understanding Partitioned Cache Lifecycle Events
Understanding Partitioned Service Events
Transfer Events
Transaction Events
Understanding Lifecycle Events
Understanding Federation Events
Federated Connection Events
Federated Change Events
Federated Partition Events
Handling Live Events
Creating Event Interceptors
Understanding Event Threading
Registering Event Interceptors
Registering Event Interceptors For a Specific Cache
Registering Event Interceptors For a Partitioned Service
Registering Event Interceptors For a Cache Configuration Factory
Using Custom Registration
Guidelines for Registering Event Interceptors
Chaining Event Interceptors
Specifying an Event Interceptor Chain Order
28
Using Coherence Query Language
Understanding Coherence Query Language Syntax
Query Syntax Basics
Using Path-Expressions
Using Bind Variables
Using Key and Value Pseudo-Functions
Using Aliases
Using Quotes with Literal Arguments
Managing the Cache Lifecycle
Creating a Cache
Removing a Cache from the Cluster
Writing a Serialized Representation of a Cache to a File
Restoring Cache Contents from a File
Retrieving Data
Retrieving Data from the Cache
Filtering Entries in a Result Set
Working with Cache Data
Aggregating Query Results
Changing Existing Values
Inserting Entries in the Cache
Deleting Entries in the Cache
Working with Indexes
Creating an Index on the Cache
Removing an Index from the Cache
Issuing Multiple Query Statements
Processing Query Statements in Batch Mode
Persisting Cache Data to Disk
Creating Snapshots
Validating Snapshots
Recovering Snapshots
Archiving Snapshots
Validating Archived Snapshots
Retrieving Archived Snapshots
Removing Snapshots
Suspending Services During Persistence Operations
Viewing Query Cost and Effectiveness
Handling Errors
Using the CohQL Command-Line Tool
Starting the Command-line Tool
Using Command-Line Tool Arguments
Setting the Request Timeout
A Command-Line Example
Building Filters in Java Programs
Additional Coherence Query Language Examples
Simple SELECT * FROM Statements that Highlight Filters
Complex Queries that Feature Projection, Aggregation, and Grouping
UPDATE Examples
Key and Value Pseudo-Function Examples
29
Performing Transactions
Overview of Transactions
Using Explicit Locking for Data Concurrency
Using Entry Processors for Data Concurrency
Using the Transaction Framework API
Defining Transactional Caches
Performing Cache Operations within a Transaction
Using the NamedCache API
Using the Connection API
Creating Transactional Connections
Using Transactional Connections
Using Auto-Commit Mode
Setting Isolation Levels
Using Eager Mode
Setting Transaction Timeout
Using the OptimisticNamedCache Interface
Configuring POF When Performing Transactions
Configuring Transactional Storage Capacity
Performing Transactions from Java Extend Clients
Create an Entry Processor for Transactions
Configure the Cluster-Side Transaction Caches
Configure the Client-Side Remote Cache
Use the Transactional Entry Processor from a Java Client
Viewing Transaction Management Information
CacheMBeans for Transactional Caches
TransactionManagerBean
Using the Coherence Resource Adapter
Performing Cache Operations within a Transaction
Creating a Coherence Connection
Getting a Named Cache
Demarcating Transaction Boundaries
Packaging the Application
Configure the Connection Factory Resource Reference
Configure the Resource Adapter Module Reference
Include the Required Libraries
Using the Coherence Cache Adapter for Transactions
30
Working with Partitions
Specifying Data Affinity
Overview of Data Affinity
Specifying Data Affinity with a KeyAssociation
Specifying Data Affinity with a KeyAssociator
Deferring the Key Association Check
Example of Using Affinity
Changing the Number of Partitions
Deciding the number of Partitions
Changing the Partition Distribution Strategy
Specifying a Partition Assignment Strategy
Enabling a Custom Partition Assignment Strategy
31
Managing Thread Execution
Overview of Priority Tasks
Setting Priority Task Timeouts
Configuring Execution Timeouts
Execution Timeout Command Line Options
Creating Priority Task Execution Objects
APIs for Creating Priority Task Objects
Errors Thrown by Task Timeouts
32
Constraints on Re-entrant Calls
Overview of Constraints on Re-Entrant Calls
Re-entrancy, Services, and Service Threads
Parent-Child Object Relationships
Avoiding Deadlock
Re-entrancy and Listeners
Part V Using the Coherence JCache Implementation
33
Introduction to Coherence JCache
Overview of the Coherence JCache Implementation
Comparison of JCache and NamedCache Features
Dependencies for Coherence JCache
Overview of Configuration for the Coherence JCache Provider
JCache Primer
What is JCache
JCache Caching Providers and Cache Managers
JCache Caches
JCache Cache Configuration
JCache Custom Programming
JCache Management
34
Building Your First Coherence JCache Application
Task 1: Create a Simple Object
Task 2: Store the Object in a Local Cache
Create the Sample JCache Application
Run the Sample JCache Application
Task 3: Configure an Example Cluster
Task 4: Store the Object in a Partitioned Cache
Start the Example Cache Server
Run The Application
Verify the Cache
Task 5: Store the Object in a Pass-Through Cache
Define the Example Cache
Start the Example Cache Server
Run the Application
Verify the Cache
35
Performing Basic Coherence JCache Tasks
Specifying Coherence as the JCache Provider
Creating Coherence JCache Caches
Creating Local Caches
Creating Partitioned Caches
Creating Pass-Through Caches
Creating Remote Caches
Using Native Coherence Functionality from JCache
Accessing NamedCache Instances from JCache
Using Coherence Configuration with JCache
Configuring Coherence JCache Caches
Setting Store-By Semantics
Setting Cache Entry Types
Setting Cache Expiry
Enabling Read-Through and Write-Through Caching
Enabling Management
Performing Cache Operations
Using Read-Through and Write-Through Caching
Providing a Read-Through Implementation
Pre-Loading a Cache
Providing a Write-Through Implementation
Configuring a JCache POF Configuration file
Viewing JCache Management Information
Understanding the JCache CacheConfiguration MBean
JCache CacheConfiguration MBean Attributes
JCache CacheConfiguration MBean Operations
Understanding the JCache CacheStatistics MBean
JCache CacheStatistics MBean Attributes
JCache CacheStatistics MBean Operations
Changing the Refresh Interval for Partitioned Cache Statistics
36
Using JCache Events
Overview of Using JCache Events
Creating Event Listeners
Creating Event Filters
Registering Event Listeners and Filters
Registering Event Listeners and Filters During Cache Configuration
Registering Event Listeners and Filters at Runtime
37
Processing JCache Entries
Overview of Processing JCache Entries
Creating Entry Processors
Using Entry Processors
Invoking Entry Processors for a Single Key
Invoking Entry Processors for Multiple Keys
A
Operational Configuration Elements
Operational Deployment Descriptor
Operational Override File
Element Reference
access-controller
active-passive
address-provider
address-providers
authorized-hosts
cache-factory-builder-config
callback-handler
central-replication
cluster-config
cluster-quorum-policy
coherence
configurable-cache-factory-config
custom-topology
federation-config
filter
filters
flashjournal-manager
flow-control
group
groups
host-range
hub-spoke
identity-asserter
identity-manager
identity-transformer
incoming-message-handler
init-param
init-params
instance
journaling-config
key-store
license-config
logging-config
management-config
mbean
mbeans
mbean-filter
member-identity
multicast-listener
notification-queueing
outgoing-message-handler
outstanding-packets
packet-buffer
packet-bundling
packet-delivery
packet-publisher
packet-size
packet-speaker
participant
participants
pause-detection
persistence-environment
persistence-environments
provider
ramjournal-manager
remote-addresses
reporter
security-config
serializer
serializers
service
Initialization Parameter Settings
DistributedCache Service Parameters
ReplicatedCache Service Parameters
OptimisticCache Service Parameters
Invocation Service Parameters
LocalCache Service Parameters
Proxy Service Parameters
RemoteCache Service Parameters
RemoteInvocation Service Parameters
NameService Parameters
RemoteNameService Parameters
FederatedCache Service Parameters
service-guardian
services
shutdown-listener
snapshot-archivers
socket-address
socket-provider
socket-providers
ssl
storage-authorizer
storage-authorizers
tcp-ring-listener
topology-definitions
traffic-jam
trust-manager
unicast-listener
volume-threshold
well-known-addresses
Attribute Reference
B
Cache Configuration Elements
Cache Configuration Deployment Descriptor
Element Reference
acceptor-config
address-provider
async-store-manager
authorized-hosts
back-scheme
backing-map-scheme
backup-storage
bdb-store-manager
bundle-config
cache-config
cache-mapping
cache-service-proxy
cachestore-scheme
caching-scheme-mapping
caching-schemes
class-scheme
custom-store-manager
defaults
distributed-scheme
external-scheme
federated-scheme
flashjournal-scheme
front-scheme
http-acceptor
identity-manager
incoming-message-handler
initiator-config
init-param
init-params
instance
interceptor
interceptors
invocation-scheme
invocation-service-proxy
key-associator
key-partitioning
key-store
listener
local-address
local-scheme
memcached-acceptor
name-service-addresses
near-scheme
nio-file-manager
operation-bundling
optimistic-scheme
outgoing-message-handler
overflow-scheme
paged-external-scheme
partition-listener
partitioned-quorum-policy-scheme
persistence
provider
proxy-config
proxy-scheme
proxy-quorum-policy-scheme
ramjournal-scheme
read-write-backing-map-scheme
remote-addresses
remote-cache-scheme
remote-invocation-scheme
replicated-scheme
resource-config
serializer
socket-address
socket-provider
ssl
tcp-acceptor
tcp-initiator
topologies
topology
transactional-scheme
trust-manager
Attribute Reference
C
POF User Type Configuration Elements
POF Configuration Deployment Descriptor
Element Reference
default-serializer
init-param
init-params
pof-config
serializer
user-type
user-type-list
D
System Property Overrides
Overview of System Property Overrides
Override Example
Preconfigured Override Values
E
The PIF-POF Binary Format
Overview of the PIF-POF Binary Format
Stream Format
Integer Values
Type Identifiers
Binary Formats for Predefined Types
Int
Coercion of Integer Types
Decimal
Floating Point
Boolean
Octet
Octet String
Char
Char String
Date
Year-Month Interval
Time
Time Interval
Date-Time
Coercion of Date and Time Types
Day-Time Interval
Collections
Arrays
Sparse Arrays
Key-Value Maps (Dictionaries)
Identity
Reference
Binary Format for User Types
Versioning of User Types
Scripting on this page enhances content navigation, but does not change the content in any way.