COH-31223: Update CE 14.1.2.0 docs

chpatel3 · chpatel3 · commit 9736e2103873 · 2024-12-19T17:08:05.000-05:00
[git-p4: depot-paths = "//dev/coherence-ce/release/coherence-ce-v14.1.2.0/": change = 113038]
diff --git a/README.md b/README.md
@@ -101,8 +101,8 @@ Coherence Maps provide a number of features:
 
 * Fundamental **key-based access**: get/put getAll/putAll.
 * Client-side and storage-side events:
-  * **MapListeners** to asynchronously notify clients of changes to data.
-  * **EventInterceptors** (either sync or async) to be notified storage level events, including
+    * **MapListeners** to asynchronously notify clients of changes to data.
+    * **EventInterceptors** (either sync or async) to be notified storage level events, including
 mutations, partition transfer, failover, and so on.
 * **NearCaches** - Locally cached data based on previous requests with local content
 invalidated upon changes in the storage tier.
@@ -119,7 +119,7 @@ to execute processing logic for the appropriate entries with exclusive access.
 associating data (thus being on the same partition) and manipulating other entries
 on the same partition, potentially across different maps.
 * **Non-blocking / async NamedMap API**
-* **Polyglot clients** - Access the same NamedMap API from C++, Go, Java, JavaScript, .NET, or Python.
+* **Polyglot clients** - Access the same NamedMap API from [C++](https://github.com/oracle/coherence-cpp-extend-client), [Go](https://github.com/oracle/coherence-go-client), Java, [JavaScript](https://github.com/oracle/coherence-js-client), [.NET](https://github.com/oracle/coherence-dotnet-extend-client), or [Python](https://github.com/oracle/coherence-py-client)
 * **Portable Object Format** - Optimized serialization format, with the ability to
 navigate the serialized form for optimized queries, aggregations, or data processing.
 * **Integration with Databases** - Database and third party data integration with
@@ -130,10 +130,13 @@ the storage capacity, the cluster, and parallelizable subscribers.
 * **Repository API** - a framework implementing the Repository pattern from Domain-Driven Design,
 abstracting persistent storage implementation from application code, with advanced features like
 support for pagination, projections, streaming, and updating in-place
-* **Microservices integration** - broad and close integration with Helidon, Micronaut, and Spring for
-developing microservices applications using Coherence as a data source or cache
-* **coherence-concurrent** - Coherence-backed implementations of types from the `java.util.concurrent`
-package enabling distributed process coordination through the grid
+* **coherence-concurrent** - Coherence-backed implementations of types from the `java.util.concurrent` package enabling distributed process coordination through the grid
+    * **Atomics** - for implementing e.g. atomic counters shared between cluster, with an optional asynchronous API
+    * **Executors** - for submitting tasks to be executed in the cluster
+    * **Locks** - for implementing lock-based concurrency control across multiple cluster members
+    * **Queues** - for implementing blocking queue / dequeue behavior across multiple cluster members
+    * **Semaphores** - for implementing synchronization of execution across multiple cluster members
+* **Microservices integration** - broad and close integration with [Helidon](https://docs.oracle.com/en/middleware/standalone/coherence/14.1.2/integrate/index.html), [Micronaut](https://micronaut-projects.github.io/micronaut-coherence/latest/guide/), and [Spring](https://spring.coherence.community/4.3.0/#/about/01_overview) for developing microservices applications using Coherence as a data source or cache
 
 Coherence also provides a number of non-functional features:
 
@@ -158,8 +161,7 @@ JMX server that provides a view of all members of the cluster.
 * **Management over REST** - All JMX data and operations can be performed over REST,
 including cluster wide thread dumps and heapdumps.
 * **Non-cluster Access** - Provides access to the cluster from the outside via proxies,
-for distant (high latency) clients and for non-Java languages such as C++, Go, JavaScript,
-.NET, and Python.
+for distant (high latency) clients and for non-Java languages such as [C++](https://github.com/oracle/coherence-cpp-extend-client), [Go](https://github.com/oracle/coherence-go-client), [JavaScript](https://github.com/oracle/coherence-js-client), [.NET](https://github.com/oracle/coherence-dotnet-extend-client), and [Python](https://github.com/oracle/coherence-py-client).
 * **Kubernetes friendly** - Enables seamless and safe deployment of applications to k8s with
 our own [operator](https://github.com/oracle/coherence-operator).
 
diff --git a/prj/docs/about/01_overview.adoc b/prj/docs/about/01_overview.adoc
@@ -73,7 +73,7 @@ Oracle Coherence commercial edition product documentation.
 
 [CARD]
 .API Docs
-[icon=library_books,link=../api/java/index.html,link-type=url]
+[icon=library_books,link=docs/about/04_api.adoc]
 --
 Browse the Coherence CE API Docs.
 --
diff --git a/prj/docs/about/02_introduction.adoc b/prj/docs/about/02_introduction.adoc
@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////
-    Copyright (c) 2000, 2021, Oracle and/or its affiliates.
+    Copyright (c) 2000, 2024, Oracle and/or its affiliates.
 
     Licensed under the Universal Permissive License v 1.0 as shown at
-    http://oss.oracle.com/licenses/upl.
+    https://oss.oracle.com/licenses/upl.
 ///////////////////////////////////////////////////////////////////////////////
 = Introduction
 
@@ -29,6 +29,7 @@ a cache will be represented by an implementation of `NamedCache<K,V>`.
 Cache is an unfortunate name, as many customers use Coherence as a system-of-record rather than a lossy store of data.
 A cache is hosted by a service, generally the PartitionedService, and is the entry point to storing, retrieving,
 aggregating, querying, and streaming data.
+
 There are a number of features that caches provide:
 
 * Fundamental *key-based access*: get/put getAll/putAll
@@ -42,14 +43,19 @@ There are a number of features that caches provide:
 * *Data local processing* - an ability to send a function to the relevant storage node to execute processing logic for the appropriate entries with exclusive access
 * *Partition local transactions* - an ability to perform scalable transactions by associating data (thus being on the same partition) and manipulating other entries on the same partition potentially across caches
 * *Non-blocking / async NamedCache API*
-* *Polyglot clients* - access the same NamedCache API from C{pp}, Go, Java, JavaScript, .NET, or Python
+* *Polyglot clients* - access the same NamedCache API from https://github.com/oracle/coherence-cpp-extend-client[C++], https://github.com/oracle/coherence-go-client[Go], Java, https://github.com/oracle/coherence-js-client[JavaScript], https://github.com/oracle/coherence-dotnet-extend-client[.NET], or https://github.com/oracle/coherence-py-client[Python]
 * *Portable Object Format* - optimized serialization format, with the ability to navigate the serialized form for optimized queries, aggregations, or data processing
 * *Integration with Databases* - Database & third party data integration with CacheStores including both synchronous or asynchronous writes
 * *CohQL* - ansi-style query language with a console for adhoc queries
 * *Topics* - distributed topics implementation offering pub/sub messaging with the storage capacity the cluster and parallelizable subscribers
 * *Repository API* - a framework implementing the Repository pattern from Domain-Driven Design, abstracting persistent storage implementation from application code, with advanced features like support for pagination, projections, streaming, and updating in-place
-* *Microservices integration* - broad and close integration with Helidon, Micronaut, and Spring for developing microservices applications using Coherence as a data source or cache
 * *coherence-concurrent* - Coherence-backed implementations of types from the `java.util.concurrent` package enabling distributed process coordination through the grid
+** *Atomics* - for implementing e.g. atomic counters shared between cluster, with an optional asynchronous API
+** *Executors* - for submitting tasks to be executed in the cluster
+** *Locks* - for implementing lock-based concurrency control across multiple cluster members
+** *Queues* - for implementing blocking queue / dequeue behavior across multiple cluster members
+** *Semaphores* - for implementing synchronization of execution across multiple cluster members
+* *Microservices integration* - broad and close integration with https://docs.oracle.com/en/middleware/standalone/coherence/14.1.2/integrate/index.html[Helidon], https://micronaut-projects.github.io/micronaut-coherence/latest/guide/[Micronaut], and https://spring.coherence.community/4.3.0/#/about/01_overview[Spring] for developing microservices applications using Coherence as a data source or cache
 
 There are also a number of non-functional features that Coherence provides:
 
@@ -62,7 +68,7 @@ There are also a number of non-functional features that Coherence provides:
 * *Lossy redundancy* - ability to reduce the redundancy guarantee by making backups and/or persistence asynchronous from a client perspective
 * *Single Mangement View* - provides insight into the cluster  with a single JMX server that provides a view of all members of the cluster
 * *Management over REST* - all JMX data and operations can be performed over REST, including cluster wide thread dumps and heapdumps
-* *Non-cluster Access* - access to the cluster from the outside via proxies, for distant (high latency) clients and for non-Java languages such as C{pp}, Go, JavaScript, .NET, and Python
+* *Non-cluster Access* - access to the cluster from the outside via proxies, for distant (high latency) clients and for non-Java languages such as https://github.com/oracle/coherence-cpp-extend-client[C++], https://github.com/oracle/coherence-go-client[Go], https://github.com/oracle/coherence-js-client[JavaScript], https://github.com/oracle/coherence-dotnet-extend-client[.NET], or https://github.com/oracle/coherence-py-client[Python]
 * *Kubernetes friendly* - seamlessly and safely deploy applications to k8s with our own https://github.com/oracle/coherence-operator[operator]
 
 
diff --git a/prj/docs/about/04_api.adoc b/prj/docs/about/04_api.adoc
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+    Copyright (c) 2000, 2024, Oracle and/or its affiliates.
+
+    Licensed under the Universal Permissive License v 1.0 as shown at
+    https://oss.oracle.com/licenses/upl.
+///////////////////////////////////////////////////////////////////////////////
+= API Docs
+:description: Oracle Coherence CE Documentation
+:keywords: coherence, API, Java, .NET, C++, Python, Go, JavaScript documentation
+
+// DO NOT remove this header - it might look like a duplicate of the header above, but
+// both they serve a purpose, and the docs will look wrong if it is removed.
+== API Docs
+
+
+- https://oracle.github.io/coherence/{version-coherence-maven}/api/java/index.html[Coherence CE Java API]
+
+- https://docs.oracle.com/en/middleware/fusion-middleware/coherence/14.1.2.0/net-reference/html[Coherence .NET Client API]
+
+- https://docs.oracle.com/en/middleware/fusion-middleware/coherence/14.1.2.0/cplus-reference/index.html[Coherence C++ Client API]
+
+- https://oracle.github.io/coherence-py-client/api_reference.html[Coherence Python Client API]
+
+- https://pkg.go.dev/github.com/oracle/coherence-go-client/v2/coherence#pkg-index[Coherence Go Client API]
+
+- https://oracle.github.io/coherence-js-client/[Coherence JavaScript Client API]
