You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by db...@apache.org on 2020/10/16 22:13:22 UTC
[geode-native] branch support/1.13 updated: GEODE-8593: Update
geode-native examples to use builder pattern: C++
This is an automated email from the ASF dual-hosted git repository.
dbarnes pushed a commit to branch support/1.13
in repository https://gitbox.apache.org/repos/asf/geode-native.git
The following commit(s) were added to refs/heads/support/1.13 by this push:
new 03f16b7 GEODE-8593: Update geode-native examples to use builder pattern: C++
03f16b7 is described below
commit 03f16b7e17426dc940139e97c466041d4e8960c2
Author: Dave Barnes <db...@apache.org>
AuthorDate: Fri Oct 16 15:07:23 2020 -0700
GEODE-8593: Update geode-native examples to use builder pattern: C++
---
.../source/subnavs/geode-nc-nav.erb | 15 ++
.../about-connection-pools.html.md.erb | 37 ---
.../about-server-locators.html.md.erb | 34 ---
.../client-load-balancing.html.md.erb | 38 ---
.../connection-pools/configuring-pools.html.md.erb | 4 -
.../connection-pools/connection-pools.html.md.erb | 32 ---
.../discovering-locators-dynamically.html.md.erb | 34 ---
.../running-connection-pool-code.html.md.erb | 76 ------
.../getting-started-nc-client.html.md.erb | 31 +--
.../getting-started/put-get-example.html.md.erb | 16 +-
.../regions/regions.html.md.erb | 31 ++-
.../security/authentication.html.md.erb | 45 +---
.../cpp-serialization/data-as-blob.html.md.erb | 25 --
.../cpp-serialization/object-graphs.html.md.erb | 23 --
.../pdx-ignore-unread-fields.html.md.erb | 37 ---
.../pdx-serialization.html.md.erb | 59 -----
.../pdx-with-delta-propagation.html.md.erb | 45 ----
.../pdxserializable-example.html.md.erb | 151 ------------
.../pdxserializable-interface.html.md.erb | 114 ---------
.../performing-ops-with-pdx-object.html.md.erb | 60 -----
.../serialization-options.html.md.erb | 85 -------
.../serialization-overview.html.md.erb | 47 ----
.../serialization-using-serializable.html.md.erb | 271 ---------------------
.../using-enum-type-with-pdx.html.md.erb | 130 ----------
.../using-pdxinstance.html.md.erb | 59 -----
.../using-pdxinstancefactory.html.md.erb | 134 ----------
.../using-pdxserialization.html.md.erb | 70 ------
.../using-pdxserializer.html.md.erb | 119 ---------
.../geode-native-docs-cpp/transactions.html.md.erb | 51 ++--
examples/cpp/authinitialize/README.md | 12 +-
examples/cpp/continuousquery/README.md | 22 +-
examples/cpp/continuousquery/main.cpp | 18 +-
examples/cpp/dataserializable/README.md | 21 +-
examples/cpp/dataserializable/main.cpp | 15 +-
examples/cpp/functionexecution/README.md | 10 +-
examples/cpp/pdxserializable/README.md | 20 +-
examples/cpp/pdxserializable/main.cpp | 15 +-
examples/cpp/pdxserializer/README.md | 12 +-
examples/cpp/pdxserializer/main.cpp | 14 +-
examples/cpp/putgetremove/README.md | 14 +-
examples/cpp/putgetremove/main.cpp | 14 +-
examples/cpp/remotequery/README.md | 20 +-
examples/cpp/remotequery/main.cpp | 15 +-
examples/cpp/sslputget/README.md | 18 +-
examples/cpp/transaction/README.md | 2 +
examples/cpp/transaction/main.cpp | 12 +-
46 files changed, 237 insertions(+), 1890 deletions(-)
diff --git a/docs/geode-native-book-cpp/master_middleman/source/subnavs/geode-nc-nav.erb b/docs/geode-native-book-cpp/master_middleman/source/subnavs/geode-nc-nav.erb
index 1968220..bd82c4b 100644
--- a/docs/geode-native-book-cpp/master_middleman/source/subnavs/geode-nc-nav.erb
+++ b/docs/geode-native-book-cpp/master_middleman/source/subnavs/geode-nc-nav.erb
@@ -65,6 +65,21 @@ limitations under the License.
</ul>
</li>
+ <li class="has_submenu">
+ <a href="/docs/geode-native/<%=vars.product_language%>/<%=vars.product_version_nodot%>/connection-pools/configuring-pools.html">Configuring Pools</a>
+ <ul>
+ <li>
+ <a href="/docs/geode-native/<%=vars.product_language%>/<%=vars.product_version_nodot%>/connection-pools/client-pool-api.html">Native Client Pool API</a>
+ </li>
+ <li>
+ <a href="/docs/geode-native/<%=vars.product_language%>/<%=vars.product_version_nodot%>/connection-pools/configuring-pools-attributes-example.html">Pool Configuration Example and Settings</a>
+ </li>
+ <li>
+ <a href="/docs/geode-native/<%=vars.product_language%>/<%=vars.product_version_nodot%>/connection-pools/subscription-properties.html">Subscription Properties</a>
+ </li>
+ </ul>
+ </li>
+
<li>
<a href="/docs/geode-native/<%=vars.product_language%>/<%=vars.product_version_nodot%>/serialization/data-serialization.html">Serializing Data</a>
</li>
diff --git a/docs/geode-native-docs-cpp/connection-pools/about-connection-pools.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/about-connection-pools.html.md.erb
deleted file mode 100644
index 2f66e68..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/about-connection-pools.html.md.erb
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Connection Pools
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Clients contain connection pools. Each region is associated with a connection pool using a region attribute, and operations on the region use connections from the respective pools.
-
-The server connectivity options are specified in the connection pool configuration. Each pool has a minimum and maximum number of connections.
-
-Each cache operation that requires server connectivity obtains a connection from the pool for the server group that the operation affects, performs the operation using the connection, and returns the connection to the pool. If the pool size is less than the maximum number of connections and all connections are in use, the connection pool creates a new connection and returns it. If the pool is at the maximum number of connections, that thread blocks until a connection becomes available or [...]
-
-The connection pool has a configurable timeout period that is used to expire idle connections. The idle connections are expired until the pool has the minimum number of connections. A monitoring thread expires idle connections, adds sufficient connections to bring up the count to minimum, and closes connections whose lifetime has been exceeded. See the `load-conditioning-interval` and `idle-timeout` attributes of the [<pool>](../../reference/topics/client-cache.html#cc-pool) elemen [...]
-
-<a id="client-load-balancing__fig_226964BAA1464DBA9F5CEDC2CB7B3585"></a>
-<span class="figtitleprefix">Figure: </span>Logical Architecture of Client/Server Connections
-
-<img src="../images/client-server-arch.gif" id="client-load-balancing__image_1E8316666E1B4CC2ADE4D927B629E49F" class="image" />
-
-When a connection receives an exception, the operation is failed over to another connection from the pool. The failover mechanism obtains the endpoint to failover to from the locator or from the specified endpoint list in the pool.
-
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/about-server-locators.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/about-server-locators.html.md.erb
deleted file mode 100644
index d637df3..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/about-server-locators.html.md.erb
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: Server Locators
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Server locators continuously monitor server availability and server load information. The client is configured with a list of server locators and consults a server locator to request a connection to a server in the distributed system.
-
-Locators provide clients with dynamic server discovery and server load balancing. They give clients connection information for the server with the least load at any given time.
-
-Server locators provide these main features:
-
-- **Automated discovery of servers and locators**. Adding and removing servers or locators is made easy as each client does not require a list of servers to be configured at the time of pool creation.
-- **Client load rebalancing**. Server locators give clients dynamic server information and provide server load rebalancing after servers depart or join the system.
-- **High availability**. When a client/server connection receives an exception, the connection is automatically failed over to another available connection in the pool. Redundancy is also provided for client subscriptions.
-
-Alternatively, you can configure a pool statically with a list of endpoints. When the pools are statically configured, a round-robin load balancing policy is used to distribute connections across the servers.
-
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/client-load-balancing.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/client-load-balancing.html.md.erb
deleted file mode 100644
index 7f5cebf..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/client-load-balancing.html.md.erb
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: How Client Load Balancing Works
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-In a distributed system, servers can be added or removed and their capacity to service new client connections may vary. The server connectivity options are specified in the connection pool configuration.
-
-The connection pool API supports connecting to servers through server locators or directly connecting to servers.
-
-- **[Server Locators](about-server-locators.html)**
-
- Server locators continuously monitor server availability and server load information. The client is configured with a list of server locators and consults a server locator to request a connection to a server in the distributed system.
-
-- **[Connection Pools](about-connection-pools.html)**
-
- Clients contain connection pools. Each region is associated with a connection pool using a region attribute, and operations on the region use connections from the respective pools.
-
-- **[Discovering Locators Dynamically](discovering-locators-dynamically.html)**
-
- A background thread periodically queries the locator for any other locators joining the distributed system.
-
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/configuring-pools.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/configuring-pools.html.md.erb
index 848c27a..5934b27 100644
--- a/docs/geode-native-docs-cpp/connection-pools/configuring-pools.html.md.erb
+++ b/docs/geode-native-docs-cpp/connection-pools/configuring-pools.html.md.erb
@@ -35,8 +35,4 @@ You configure locator, server, and pool settings declaratively in the client's `
Each connection pool has a single subscription connection that can be to any server that matches the requirements of the connection pool.
-- **[Running the Connection Pool Code](running-connection-pool-code.html)**
-
- Examples demonstrate a simple procedure to create a pool factory and then create a pool instance in C++ and C\#. They also help you to execute a query.
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/connection-pools.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/connection-pools.html.md.erb
deleted file mode 100644
index e57778d..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/connection-pools.html.md.erb
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: Using Connection Pools
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-*Using Connection Pools* describes how connection pools achieve load balancing for the client and describes how to configure connection pools as server locators or as a list of servers.
-
-- **[How Client Load Balancing Works](client-load-balancing.html)**
-
- In a distributed system, servers can be added or removed and their capacity to service new client connections may vary. The server connectivity options are specified in the connection pool configuration.
-
-- **[Configuring Pools](configuring-pools.html)**
-
- A pool can be configured as locators or as a list of servers.
-
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/discovering-locators-dynamically.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/discovering-locators-dynamically.html.md.erb
deleted file mode 100644
index e00bed0..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/discovering-locators-dynamically.html.md.erb
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: Discovering Locators Dynamically
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-A background thread periodically queries the locator for any other locators joining the distributed system.
-
-However, if locator A (to which the client is connected) goes down before it discovers locator B, locator B is never discovered even though it is alive and the client receives a `NoLocatorsAvailable` exception.
-
-One connection is attached to every application thread that is `local` to the respective thread. This is known as a thread local connection.
-
-In this case, to perform any cache operation the client is not required to obtain a connection from pool. Instead the thread local connection of the client is used.
-
-A thread local connection can be released by invoking the `Pool::releaseThreadLocalConnection()` method. The released connection is returned to the pool. If the number of threads is larger than the number of `max-connections`, the client throws an `AllConnectionsInUseException` after the `free-connection-timeout` lapses, unless the `Pool::releaseThreadLocalConnection()` method is used judiciously.
-
-If a connection expires or the server goes down on which the connection was established, a thread local connection is immediately replaced with a good connection obtained from the pool.
-
-
diff --git a/docs/geode-native-docs-cpp/connection-pools/running-connection-pool-code.html.md.erb b/docs/geode-native-docs-cpp/connection-pools/running-connection-pool-code.html.md.erb
deleted file mode 100644
index fd62593..0000000
--- a/docs/geode-native-docs-cpp/connection-pools/running-connection-pool-code.html.md.erb
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: Running the Connection Pool Code
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Examples demonstrate a simple procedure to create a pool factory and then create a pool instance in C++ and C\#. They also help you to execute a query.
-
-The examples create a pool with locators. Ensure that you create a pool with locators or endpoints, but not both. The first example demonstrates creating a pool by adding locators. The second example demonstrates creating a pool by adding servers. For more information, see the example in the QuickStart Guide.
-
-## Connection Pool Creation and Execution Using C++
-
-``` pre
-PropertiesPtr prptr = Properties::create();
-systemPtr = CacheFactory::createCacheFactory(prptr);
-
-cachePtr = systemPtr->create();
-PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
-//to create pool add either endpoints or add locators or servers
-//pool with endpoint, adding to pool factory
-//poolFacPtr->addServer("localhost", 12345 /*port number*/);
-//pool with locator, adding to pool factory
-poolFacPtr->addLocator("localhost", 34756 /*port number*/);
-PoolPtr pptr = NULLPTR;
-if ((PoolManager::find("examplePool")) == NULLPTR) {
- // Pool with this name does not exist
- pptr = poolFacPtr->create("examplePool");
-}
-RegionFactoryPtr regionFactory =
- cachePtr->createRegionFactory(CACHING_PROXY);
-regionPtr = regionFactory
- ->setPoolName("examplePool")
- ->create("regionName");
-QueryServicePtr qs = cachePtr->getQueryService("examplePool");
-```
-
-## Connection Pool Creation and Execution Using C\# .NET
-
-``` pre
-Properties prop = Properties.Create();
-CacheFactory cacheFactory = CacheFactory.CreateCacheFactory(prop);
-Cache cache = cacheFactory.Create();
-
-PoolFactory poolFact = PoolManager.CreateFactory();
-//to create pool add either endpoints or add locators
-//pool with endpoint, adding to pool factory.
-poolFact.AddServer("localhost", 40404 /*port number*/);
-//pool with locator, adding to pool factory
-//poolFact.AddLocator("hostname", 15000 /*port number*/);
-Pool pool = null;
-if (PoolManager.Find("poolName") == null) {
- pool = poolFact.Create("poolName");
-}
-int loadConditInterval = pool.LoadConditioningInterval;
-RegionFactory regionFactory =
- cache.CreateRegionFactory(RegionShortcut.CACHING_PROXY);
-IRegion<string, string> region =
- regionFactory.SetPoolName(poolName).Create<string, string>(regionName);
-```
-
-
diff --git a/docs/geode-native-docs-cpp/getting-started/getting-started-nc-client.html.md.erb b/docs/geode-native-docs-cpp/getting-started/getting-started-nc-client.html.md.erb
index a192d84..9d19505 100644
--- a/docs/geode-native-docs-cpp/getting-started/getting-started-nc-client.html.md.erb
+++ b/docs/geode-native-docs-cpp/getting-started/getting-started-nc-client.html.md.erb
@@ -37,36 +37,37 @@ To connect to a server, your application must follow these steps:
1. Instantiate a `CacheFactory`, setting characteristics of interest (for example, `log-level`).
1. Create a cache and use it to instantiate a `PoolFactory`, specifying the hostname and port for the server locator.
1. Create a named pool of network connections.
-1. Instantiate a region of the desired type (usually CACHING_PROXY or PROXY) and connect it by name to its counterpart on the server.
+1. Instantiate a region of the desired type (usually PROXY, sometimes CACHING_PROXY) and connect it by name to its counterpart on the server.
Once the connection pool and the shared region are in place, your client application is ready to share data with the server.
**Server Connection: C++ Example**
-This example of connecting to the server is taken from the C++ `put-get-remove` example.
-
-Instantiate a `CacheFactory` and set its characteristics:
+Create a cache and use it to instantiate a `CacheFactory` and set its characteristics:
``` cpp
- auto cacheFactory = CacheFactory(); // instantiate cache factory
- cacheFactory.set("log-level", "none"); // set cache log-level characteristics
+auto cache = CacheFactory()
+ .set("log-level", "debug")
+ .set("ssl-enabled", "true")
+ .set("ssl-truststore", clientTruststore.string())
+ .create();
```
-Create a cache and use it to instantiate a `PoolFactory`:
+Create a pool of network connections:
-``` cpp
- auto cache = cacheFactory.create(); // create cache
- auto poolFactory = cache.getPoolManager().createFactory(); // instantiate pool factory
- poolFactory.addLocator("localhost", 10334); // add locator to pool factory
+``` cpp
+cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
```
-Create a named pool of network connections, and instantiate a region of the desired type:
+Instantiate a region of the desired type and connect to the pool by name::
``` cpp
- auto pool = poolFactory.create("pool"); // create a pool called "pool" that knows where the server is
- auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY); // instantiate region factory with PROXY characteristics
- auto region = regionFactory.setPoolName("pool").create("example_userinfo"); // create a connection to the region "example_userinfo" on the server
+auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
+auto region = regionFactory.setPoolName("pool").create("exampleRegion");
```
See the _<%=vars.product_name%> User Guide_ section [Configuring a Client/Server System](serverman/topologies_and_comm/cs_configuration/setting_up_a_client_server_system.html)
diff --git a/docs/geode-native-docs-cpp/getting-started/put-get-example.html.md.erb b/docs/geode-native-docs-cpp/getting-started/put-get-example.html.md.erb
index e292ec5..a0b3763 100644
--- a/docs/geode-native-docs-cpp/getting-started/put-get-example.html.md.erb
+++ b/docs/geode-native-docs-cpp/getting-started/put-get-example.html.md.erb
@@ -46,13 +46,15 @@ For the complete source, see the example source directory.
The C++ example creates a cache, then uses it to create a connection pool and a region object (of class `Region`).
```cpp
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
- auto poolFactory = cache.getPoolManager().createFactory();
-
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("example_userinfo");
```
diff --git a/docs/geode-native-docs-cpp/regions/regions.html.md.erb b/docs/geode-native-docs-cpp/regions/regions.html.md.erb
index 4b6b0bb..357d499 100644
--- a/docs/geode-native-docs-cpp/regions/regions.html.md.erb
+++ b/docs/geode-native-docs-cpp/regions/regions.html.md.erb
@@ -37,27 +37,36 @@ Region creation is subject to attribute consistency checks.
To create a region:
-1. Instantiate a `CacheFactory` and use it to create a cache.
+1. Create a cache using `CacheFactory` to set its characteristics.
1. The cache includes an instance of `PoolManager`—use it to create a connection pool.
-1. Use cache to instantiate a `RegionFactory` and use it to create a region, specifying any desired attributes
+1. Use the cache to instantiate a `RegionFactory` and use it to create a region, specifying any desired attributes
and an association with the connection pool.
### C++ Region Creation Example
-The following example illustrates how to create two regions using C++.
+The following example illustrates how to create two regions with different characteristics using C++.
``` cpp
-auto cache = CacheFactory().create();
+auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
-auto examplePool = cache.getPoolManager()
+cache.getPoolManager()
.createFactory()
- .addLocator("localhost", 40404)
- .setSubscriptionEnabled(true)
- .create("examplePool");
+ .addLocator("localhost", 10334)
+ .create("pool");
-auto clientRegion1 = cache.createRegionFactory(RegionShortcut::PROXY)
- .setPoolName("examplePool")
- .create("clientRegion1");
+auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
+auto regionFactory2 = cache.createRegionFactory(RegionShortcut::CACHING_PROXY);
+
+auto region = regionFactory
+ .setPoolName("pool")
+ .create("example_userinfo");
+
+auto region2 = regionFactory2
+ .setPoolName("pool")
+ .setEntryTimeToLive(ExpirationAction::INVALIDATE, std::chrono::seconds(120))
+ .create("example_userinfo2");
```
## <a id="declarative-region-creation"></a>Declarative Region Creation
diff --git a/docs/geode-native-docs-cpp/security/authentication.html.md.erb b/docs/geode-native-docs-cpp/security/authentication.html.md.erb
index 483e566..6e19aa6 100644
--- a/docs/geode-native-docs-cpp/security/authentication.html.md.erb
+++ b/docs/geode-native-docs-cpp/security/authentication.html.md.erb
@@ -30,43 +30,22 @@ this means setting the authentication credentials when you create the CacheFacto
In this C++ authentication example, the `CacheFactory` creation process sets the authentication callback:
```cpp
- auto cacheFactory = CacheFactory(config);
- auto authInitialize = std::make_shared<UserPasswordAuthInit>();
- cacheFactory.set("log-level", "none");
- cacheFactory.setAuthInitialize(authInitialize);
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .setAuthInitialize(std::unique_ptr<ExampleAuthInitialize>(new ExampleAuthInitialize()))
+ .create();
```
-Credentials are implemented in the `getCredentials` member function of the `AuthInitialize` abstract class.
+Credentials are implemented in the `getCredentials` member function of the `ExampleAuthInitialize`, which is derived from the `AuthInitialize` abstract class.
```cpp
-class UserPasswordAuthInit : public AuthInitialize {
-public:
- UserPasswordAuthInit() = default;
-
- ~UserPasswordAuthInit() noexcept override = default;
-
- std::shared_ptr<Properties> getCredentials(
- const std::shared_ptr<Properties> &securityprops,
- const std::string &) override {
- std::shared_ptr<Cacheable> userName;
- if (securityprops == nullptr ||
- (userName = securityprops->find(SECURITY_USERNAME)) == nullptr) {
- throw AuthenticationFailedException(
- "UserPasswordAuthInit: user name "
- "property [SECURITY_USERNAME] not set.");
- }
-
- auto credentials = Properties::create();
- credentials->insert(SECURITY_USERNAME, userName->toString().c_str());
- auto passwd = securityprops->find(SECURITY_PASSWORD);
- if (passwd == nullptr) {
- passwd = CacheableString::create("");
- }
- credentials->insert(SECURITY_PASSWORD, passwd->value().c_str());
- return credentials;
- }
+std::shared_ptr<Properties> ExampleAuthInitialize::getCredentials(
+ const std::shared_ptr<Properties>& securityprops,
+ const std::string& /*server*/) {
- void close() override { return; }
-};
+ securityprops->insert("security-username", "root");
+ securityprops->insert("security-password", "root");
+ return securityprops;
+}
```
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/data-as-blob.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/data-as-blob.html.md.erb
deleted file mode 100644
index e3c45f2..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/data-as-blob.html.md.erb
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Serializing and Accessing Data as a Blob
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
-
-`CacheableBytes` also provides direct access to the blob data. Because it is not derived from the `CacheableKey` interface, `CacheableBytes` enables you to modify data in place and then put it into the region again to distribute the change.
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/object-graphs.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/object-graphs.html.md.erb
deleted file mode 100644
index 182b72d..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/object-graphs.html.md.erb
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: Serializing Object Graphs
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
deleted file mode 100644
index 1149494..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Configuring PDX to Ignore Unread Fields During Deserialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
-The default is to preserve unread fields by including their data during serialization. However, if you configure the cache to ignore unread fields then their data will be lost during serialization.
-
-You should only set this attribute to `true` if you know this member will only be reading cache data. In this use case you do not need to pay the cost of preserving unread fields since you will never reserialize the PDX data.
-
-For example:
-
-``` pre
-CacheFactoryPtr cfPtr = CacheFactory::createCacheFactory(PropertiesObj);
-cfPtr->setPdxReadSerialized(tue);
-cfPtr->setPdxIgnoreUnreadFields(false);
-cachePtr = cfPtr->create();
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-serialization.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-serialization.html.md.erb
deleted file mode 100644
index e39ab50..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-serialization.html.md.erb
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Serializing Data with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-PDX is a cross-language data format that can reduce the cost of
-distributing and serializing your objects. PDX stores data in named
-fields that you can access individually to avoid the cost of
-deserializing the entire data object. When you use PDX serialization
-with the C++ client API, you can implement PDX serialization for each
-domain object or register a `PdxSerializer` for the entire cache.
-
-You can also set the object preference of the cache to the `PdxInstance` type, which allows you to access fields of a PDX object without deserializing the entire object.
-
-- **[Serialize Using the PdxSerializable Class](pdxserializable-interface.html)**
-
- Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-
-- **[Serialize Your Domain Objects with PdxSerializer and PdxWrapper](using-pdxserializer.html)**
-
- For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
-- **[Programming Your Application to Use PdxInstances](using-pdxinstance.html)**
-
- A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
-- **[Configuring PDX to Ignore Unread Fields During Deserialization](pdx-ignore-unread-fields.html)**
-
- Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
-- **[Using PdxInstanceFactory to Create PdxInstances](using-pdxinstancefactory.html)**
-
- You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
-- **[Using C++ Enum Type with PDX Serialization](using-enum-type-with-pdx.html)**
-
- Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
-- **[Using PDX Serialization with Delta Propagation](pdx-with-delta-propagation.html)**
-
- To use delta propagation with PDX serialization, you must implement the `Delta` interface methods.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
deleted file mode 100644
index 4f9bbf4..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Using PDX Serialization with Delta Propagation
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<a id="concept_F33AC930A8F14F0A9EE07AC31FFD8C8F__section_6C08121D7A034993A7422985FBC9A0D9"></a>
-You can include delta propagation support with PDX serialization by implementing the `Delta` interface methods.
-However, using delta propagation with PDX will require that you implement Java side classes. The objects will remain in deserialized form at all times on the server and you will lose one of the main benefits of PDX.
-
-In addition, you must set `read-serialized` to `false`. Otherwise, Java objects will be deserialized to instances of `PdxInstance`, which never implements deltas.
-
-The following code snippet is a sample implementation of the Delta interface methods for using with PDX serialization.
-
-``` pre
-class PdxWithDelta : public PdxSerializable, public Delta
-{
-public:
-
- bool hasDelta();
- void toDelta(DataOutput& output);
- void fromDelta(DataInput& input);
- DeltaPtr clone();
-
-// other PdxSerializable methods here...
-
-};
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-example.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-example.html.md.erb
deleted file mode 100644
index 714980c..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-example.html.md.erb
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: PdxSerializable Example
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-## Order.cpp:
-
-Front matter:
-
- #include "Order.hpp"
-
-`PdxReader` & `PdxWriter` are used for `fromData()` & `toData()`:
-
- #include <geode/PdxReader.hpp>
- #include <geode/PdxWriter.hpp>
-
- namespace customserializable {
-
-- Must provide `fromData()` and `toData()`.
-- Specify the keys in the same order in `fromData()` and `toData()`. Use `PdxReader` and `PdxWriter`:
-
- ```
- void Order::fromData(PdxReader& pdxReader) {
- order_id_ = static_cast<uint32_t>(pdxReader.readLong(ORDER_ID_KEY_));
- name_ = pdxReader.readString(NAME_KEY_);
- quantity_ = static_cast<uint16_t>(pdxReader.readInt(QUANTITY_KEY_));
- }
-
- void Order::toData(PdxWriter& pdxWriter) const {
- pdxWriter.writeLong(ORDER_ID_KEY_, order_id_);
- pdxWriter.markIdentityField(ORDER_ID_KEY_);
-
- pdxWriter.writeString(NAME_KEY_, name_);
- pdxWriter.markIdentityField(NAME_KEY_);
-
- pdxWriter.writeInt(QUANTITY_KEY_, quantity_);
- pdxWriter.markIdentityField(QUANTITY_KEY_);
- }
- ```
-
-Optionally override and add detailed methods as needed. In this example, we override `toString()` and implement `size()` and `classname()`.
-
- std::string Order::toString() const {
- return "OrderID: " + std::to_string(order_id_) + " Product Name: " + name_ +
- " Quantity: " + std::to_string(quantity_);
- }
-
-
- size_t Order::objectSize() const {
- auto objectSize = sizeof(Order);
- objectSize += name_.capacity();
- return objectSize;
- }
-
-
- const std::string& Order::getClassName() const {
- static const std::string CLASS_NAME = "com.example.Order";
- return CLASS_NAME;
- }
-
-Provide a constructor in a parameter-less wrapper that can be called to create a prototypical instance (called `createDeserializable()` here).
-
- std::shared_ptr<PdxSerializable> Order::createDeserializable() {
- return std::make_shared<Order>(0, "", 0);
- }
-
- const std::string Order::ORDER_ID_KEY_ = "order_id";
- const std::string Order::NAME_KEY_ = "name";
- const std::string Order::QUANTITY_KEY_ = "quantity";
-
- } // namespace customserializable
-
-## main.cpp
-
-Front matter. You will need `TypeRegistry` to register your PdxSerializable class. Bring in the customary includes for I/O and cache, pool, and region creation.
-
- #include <iostream>
- #include <sstream>
-
- #include <geode/CacheFactory.hpp>
- #include <geode/PoolManager.hpp>
- #include <geode/RegionFactory.hpp>
- #include <geode/RegionShortcut.hpp>
- #include <geode/TypeRegistry.hpp>
-
- #include "Order.hpp"
-
- using namespace apache::geode::client;
- using namespace customserializable;
-
-
- int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
-
- auto poolFactory = cache.getPoolManager().createFactory();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
-
- auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
- auto region = regionFactory.setPoolName("pool").create("custom_orders");
-
-
- cache.getTypeRegistry().registerPdxType(Order::createDeserializable);
-
-
- std::cout << "Create orders" << std::endl;
- auto order1 = std::make_shared<Order>(1, "product x", 23);
- auto order2 = std::make_shared<Order>(2, "product y", 37);
-
- std::cout << "Storing orders in the region" << std::endl;
- region->put("Customer1", order1);
- region->put("Customer2", order2);
-
- std::cout << "Getting the orders from the region" << std::endl;
-
- if (auto order1retrieved =
- std::dynamic_pointer_cast<Order>(region->get("Customer1"))) {
- std::cout << "OrderID: " << order1retrieved->getOrderId() << std::endl;
- std::cout << "Product Name: " << order1retrieved->getName() << std::endl;
- std::cout << "Quantity: " << order1retrieved->getQuantity() << std::endl;
- } else {
- std::cout << "Order 1 not found." << std::endl;
- }
-
- if (auto order2retrieved = region->get("Customer2")) {
- std::cout << order2retrieved->toString() << std::endl;
- } else {
- std::cout << "Order 2 not found." << std::endl;
- }
-
-
- cache.close();
- }
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-interface.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
deleted file mode 100644
index 56cb7fa..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: Serialize Using the PdxSerializable Class
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object.
-
-When you run queries against the objects on the servers, only the fields you specify are deserialized.
-A domain class should serialize and de-serialize all its member fields in the same order in its `toData` and `fromData` methods.
-
-Use this procedure to program your domain object for PDX serialization using the `PdxSerializable` abstract class.
-
-1. In your domain class, implement `PdxSerializable`. Example:
-
- ``` pre
- class PdxObject: public PdxSerializable
- ```
-
-2. Program the `toData` function to serialize your object as required by your application.
- <br><br>
- If you also use PDX serialization in Java or .NET for the object, serialize the object in the same way for each language. Serialize the same fields in the same order and mark the same identity fields.
-
-3. Program the `fromData` method to read your data fields from the serialized form into the object's fields.
- <br><br>
- In your `fromData` implementation, use the same name as you did in `toData` and call the read operations in the same order as you called the write operations in your `toData` implementation.
-
-4. Optionally, program your domain object's `hashCode` and equality methods.
- <br><br>
- Use the `markIdentityField` method to indicate that the given field name should be included in `hashCode` and equality checks of this object on a server.
- <br><br>
- The fields that are marked as identity fields are used to generate the `hashCode` and equality methods of PdxInstance. Because of this, the identity fields should themselves either be primitives, or implement `hashCode` and equals.
- <br><br>
- If no fields are set as identity fields, then all fields will be used in `hashCode` and equality checks. The identity fields should make marked after they are written using a `write*` method.
-
-## <a class="no-quick-link" id="pdx-serializable-example"></a>PdxSerializable Example
-
-``` pre
-class PdxObject: public PdxSerializable {
-
-private:
- uint32_t m_id;
- char* m_str;
-
-public:
- PdxObject(){};
- PdxObject(uint32_t id, char* str);
- virtual ~PdxObject();
-
- uint32_t getID() {
- return m_id;
- }
-
- char* getStr(){
- return m_str;
- }
-
- virtual void toData(PdxWriterPtr pw) const;
- virtual void fromData(PdxReaderPtr pr);
- CacheableStringPtr toString() const;
- virtual char* getClassName() const;
- static Cacheable* createDeserializable() {
- return new PdxObject();
- }
-};
-
-PdxObject::PdxObject(uint32_t i, char* str) {
- m_id = i;
- m_str = str;
-}
-
-PdxObject::~PdxObject() {
-}
-
-void PdxObject::toData( PdxWriterPtr pw ) const {
- pw->writeInt("id", m_id);
- pw->markIdentityField("id");
- pw->writeString("str", m_str);
-}
-
-void PdxObject::fromData( PdxReaderPtr pr )
-{
- m_id = pr->readInt("id");
- m_str = pr->readString("str");
-}
-
-char* getClassName() const{
-{
- return "com.example.PdxType";
-}
-
-CacheableStringPtr PdxObject::toString() const {
- char idbuf[1024];
- sprintf(idbuf,"PdxObject: [ ID=%d ]",m_id);
- return CacheableString::create( idbuf );
-}
-```
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
deleted file mode 100644
index f9c8ec4..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: Performing put, get, and localDestroy Operations with a PDX Domain Object
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-This topic demonstrates how you can perform operations on a PDX domain object after you have implemented PDX serializable in your domain class.
-
-For example, you can perform operations like put, get, and localDestroy with the domain class you defined for PDX serialization in the [PdxSerializable Example](pdxserializable-interface.html#pdx-serializable-example).
-
-To perform operations, you could write the following application code:
-
-1. Register the PDX domain class.
-
- ``` pre
- Serializable::registerPdxType(PdxObject::createDeserializable);
- ```
-
-2. Create the PDX domain object `PdxObject`.
-
- ``` pre
- CacheablePtr pdxobj(new PdxObject(100, "Value-1"));
- CacheableKeyPtr keyport = CacheableKey::create("ABC");
- ```
-
-3. Here's an example of a put operation.
-
- ``` pre
- rptr->put(keyport, pdxobj);
- ```
-
-4. Here's an example of locally destroying the entry.
-
- ``` pre
- rptr->localDestroy(keyport);
- ```
-
-5. Here's an example of a get operation.
-
- ``` pre
- PdxObject *obj2 = dynamic_cast<PdxObject *> ((rptr->get(keyport)).ptr());
- LOGINFO("Debug:Returned ID = %d", obj2->getID());
- ```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-options.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-options.html.md.erb
deleted file mode 100644
index 1e49872..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-options.html.md.erb
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title: Data Serialization Options
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The C++ client API gives two serialization options: <%=vars.product_name%> PDX serialization and the `apache::geode::client::DataSerializable` interface.
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization is the recommended option. PDX
-serialization provides portability for PDX serializable objects so that clients can share data with
-Java servers and other non-C++ clients. PDX is a cross-language data format that can reduce the cost
-of distributing and serializing your objects. PDX stores data in named fields that you can access
-individually in order to avoid the cost of deserializing the entire data object. PDX also allows you
-to mix versions of objects where you have added or removed fields.
-
-When using PDX serialization, you can use either `PdxSerializable` (for a specific domain object) or `PdxSerializer` (for all your domain objects).
-
-`PdxSerializable` is used when the domain class that a user wants to serialize/deserialize is inherited from the `PdxSerializable` interface, and the user has registered the domain class using the `registerPdxType(domainClass)` API.
-
-`PdxSerializer` is used when a user has registered a domain class for serialization in the cache using the `registerPdxSerializer` API.
-
-The non-PDX serialization option is to use the `apache::geode::client::DataSerializable` interface. This
-`DataSerializable` interface can be a good option performance-wise if the size of your objects is
-small. `DataSerializable` is used whenever a user domain class is not inherited by `PdxSerializable`,
-but the user has registered the class with the `registerType` API.
-
-<table>
-<caption><span class="tablecap">Table 1. Serialization Options—Comparison of Features</span></caption>
-<colgroup>
-<col width="50%" />
-<col width="25%" />
-<col width="25%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Capability</th>
-<th>DataSerializable</th>
-<th>PdxSerializable</th>
-</tr>
-</thead>
-<tbody>
-<tr class="odd">
-<td><p>Handles multiple versions of domain objects</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Provides single field access on servers of serialized data, without full deserialization. Supported also for OQL queries.</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="odd">
-<td><p>Automatically ported to other languages by <%=vars.product_name%> - no need to program Java-side implementation</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Works with Geode delta propagation</p></td>
-<td>X</td>
-<td>X</td>
-</tr>
-</tbody>
-</table>
-
-<span class="tablecap">**Table 1.** Serialization Options—Comparison of Features</span>
-
-## Important points to remember when using DataSerializable
-
-1. Make sure to register the proper typeId when registering custom classes that have a corresponding server side jar (e.g. Portfolio and Position)
-2. Make sure to register any custom types in each process that uses those types. The cppcache framework uses four separate processes.
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-overview.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-overview.html.md.erb
deleted file mode 100644
index 6c5ba24..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-overview.html.md.erb
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: Data Serialization – C++
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-All data moving out of the client cache must be serializable.
-
-- **[Data Serialization Options](serialization-options.html)**
-
- The C++ client API provides two serialization options: <%=vars.product_name%> PDX serialization and the `apache::geode::client::DataSerializable` interface.
-
-- **[Using PDX Serialization](pdx-serialization.html)**
-
- PDX is a cross-language data format that can reduce the cost of distributing and serializing your
-objects. PDX stores data in named fields that you can access individually to avoid the cost of
-deserializing the entire data object. When you use PDX serialization with a C++ client, you can
-implement PDX serialization for each domain object or register a PdxSerializer for the entire cache.
-
-- **[Serializing Data with the DataSerializable Interface](serialization-using-serializable.html)**
-
- The C++ client API provides a `DataSerializable` interface that you can use for fast and compact data serialization. This section discusses the <%=vars.product_name%> DataSerializable interface and presents implementation examples.
-
-- **[Serializing Object Graphs](object-graphs.html)**
-
- If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
-
-- **[Serializing and Accessing Data as a Blob](data-as-blob.html)**
-
- If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-using-serializable.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
deleted file mode 100644
index 5ba377d..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
+++ /dev/null
@@ -1,271 +0,0 @@
----
-title: Serializing Data with the DataSerializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The C++ client API provides a `DataSerializable` interface that you can use for fast and compact
-data serialization.
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization is the recommended option,
-but the `DataSerializable` interface can be a good option performance-wise if the size of your objects
-is small.
-
-This section discusses the <%=vars.product_name%> `DataSerializable` interface, and
-presents implementation examples.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_8143F965A8C6495E8AB104FD36DA366A" class="no-quick-link"></a>How Serialization Works
-
-When your application puts an object into the cache for subsequent distribution, <%=vars.product_name%> serializes the data by taking these steps:
-
-1. Calls the appropriate `classId` function.
-2. Writes the full `typeId` using the `classId` for the instance.
-3. Invokes the instance’s `toData` function.
-
-When your application subsequently receives a byte array, <%=vars.product_name%> takes the following steps:
-
-1. Decodes the `typeId`, extracts the `classId` from the `typeId`, then creates an object of the designated type using the registered factory functions.
-
-2. Invokes the `fromData` function with input from the data stream.
-3. Decodes the data, then populates the data fields.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_786CF85FD80E4FE391135460E04D46CC" class="no-quick-link"></a>Implementing the DataSerializable Interface
-
-To store your own data types in the cache, you need to derive a new subclass from the `DataSerializable`
-interface. In practical terms, this means that you need to implement a small set of helper
-functions:
-
-1. Write a `toData` function that serializes your data.
-
- ``` pre
- void toData (DataOutput& output)
- ```
-
- The `toData` function is responsible for copying all of the object’s data fields to the object stream.
- The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order.
-
-2. Write a `fromData` function that consumes a data input stream and repopulates the object’s data fields.
-
- ``` pre
- void fromData (DataInput& input)
- ```
-
- The `DataInput` class represents the input stream and provides methods for reading input
- elements. The `fromData` function must read the elements of the input stream in the same order
- that they were written by `toData`.
-
-## Example 1. The Simple Class BankAccount
-
-This example demonstrates a simple `BankAccount` class that encapsulates two `ints`, `ownerId` and `accountId`:
-
-``` pre
-class BankAccount
-{
- private:
-
- int m_ownerId;
- int m_accountId;
-
- public:
-
- BankAccount( int owner, int account ): m_ownerId( owner ),
- m_accountId( account ) {}
-
- int getOwner( )
- {
- return m_ownerId;
- }
-
- int getAccount( )
- {
- return m_accountId;
- }
-
-};
-```
-
-To make `BankAccount` serializable, you would need to derive the class from `DataSerializable` and implement the following:
-
-- `toData` — a function to serialize the data.
-- `fromData` — a function to deserialize the data.
-- `getClassId` — a function to provide a unique integer for the class.
-- `TypeFactoryMethod` — a pointer to a function that returns a `DataSerializable*` to an uninitialized instance of the type.
-
-## Example 2. Implementing a DataSerializable Class
-
-This example shows a code sample that demonstrates how to implement a serializable class.
-
-``` pre
-class BankAccount : public DataSerializable
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Add the following for the DataSerializable interface
-// Our TypeFactoryMethod
-static DataSerializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t getClassId( )
-{
- return 10; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-DataSerializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_108942E549CE4DE68FF3956712DEC7AF" class="no-quick-link"></a>Registering the Type
-
-To be able to use the `BankAccount` type, you must register it with the type system so that when an
-incoming stream contains a `BankAccount`, it can be manufactured from the associated
-`TypeFactoryMethod`.
-
-``` pre
-DataSerializable::registerType( BankAccount::createInstance );
-```
-
-Typically, you would register the type before calling the function `DistributedSystem::connect`.
-
-**Note:**
-Type IDs must be unique to only one class.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_311C3661023C46328B406F26F4F16808" class="no-quick-link"></a>Custom Key Types
-
-If your application uses key types that are too complex to easily force into `CacheableString`, you
-can likely improve performance by deriving a new class from `CacheableKey`. If you have hybrid data
-types you can implement your own derivation of `CacheableKey` that encapsulates the data type.
-
-See below for information about implementing key types for a client that is used with a Java cache server.
-
-To extend a `DataSerializable` class to be a `CacheableKey`, you need to modify the class definition as follows:
-
-- Change the class so that it derives from `CacheableKey` rather than `DataSerializable`.
-
-- Implement `operator==` and `hashcode` functions.
-
-## Example 3. Extending a DataSerializable Class To Be a CacheableKey
-
-This example shows how to extend a serializable class to be a cacheable key.
-
-``` pre
-class BankAccount
-: public CacheableKey
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Our TypeFactoryMethod
-static DataSerializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t typeId( )
-{
- return 1000; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-DataSerializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-
-// Add the following for the CacheableKey interface
-bool operator == ( const CacheableKey& other ) const
-{
- const BankAccount& otherBA =
- static_cast<const BankAccount&>( other );
- return (m_ownerId == otherBA.m_ownerId) && (m_accountId == otherBA.m_accountId);
-}
-
-uint32_t hashcode( ) const
-{
- return m_ownerId;
-}
-
-virtual int32_t classId( )const
-{
- return 10; // must be unique per class.
-}
-
-virtual size_t objectSize() const
-{
- return 10;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274" class="no-quick-link"></a>Serialization in Native Client Mode with a Java Server
-
-Primitive object types supported in all languages (`CacheableInt32`, `CacheableString`,
-`CacheableBytes`) function without requiring custom definitions with the Java cache server. For the
-keys, the Java cache server has to deserialize them and locate the hashcode to be able to insert the
-internal maps. Because of this, key types for C++ clients used with a Java server are required to be
-registered on the Java server, but the value types do not need to be registered. This needs to be
-done even if there are no Java clients.
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
deleted file mode 100644
index b8d520e..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: Using C++ Enum Type with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
-To use the C++ enum type with PDX serialization, you have to wrap the `enum` in the `CacheableEnum` class type by specifying classname, enumname and ordinal.
-
-``` pre
-enum enumQuerytest { id1, id2, id3 };
- class TESTOBJECT_EXPORT PdxEnumTestClass :public PdxSerializable
- {
- private:
- int m_id;
- CacheableEnumPtr m_enumid;
-
- public:
- int getID(){
- return m_id;
- }
-
- CacheableEnumPtr getEnumID() {
- return m_enumid;
- }
-
- PdxEnumTestClass(int id)
- {
- m_id = id;
- switch (m_id) {
- case 0:
- m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
- break;
- case 1:
- m_enumid = CacheableEnum::create("enumQuerytest", "id2", id2);
- break;
- case 2:
- m_enumid = CacheableEnum::create("enumQuerytest", "id3", id3);
- break;
- default:
- m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
- break;
- }
- }
-
- PdxEnumTestClass() { }
-
- void toData(PdxWriterPtr pw) {
- pw->writeInt("m_id", m_id);
- pw->writeObject("m_enumid", m_enumid);
- }
-
- void fromData(PdxReaderPtr pr) {
- m_id = pr->readInt("m_id");
- m_enumid = pr->readObject("m_enumid");
- }
-
- CacheableStringPtr toString() const {
- return CacheableString::create("PdxEnumTestClass");
- }
-
- char* GetClassName() const {
- return "com.example.PdxEnumTestClass";
- }
-
- static PdxSerializable* createDeserializable() {
- return new PdxEnumTestClass();
- }
- };
-```
-
-## <a id="concept_F38FDBC327204B4EB1E0BC74B4C95409__section_3491F76DB8C0464D89418B89372BBAEA" class="no-quick-link"></a>How Puts and Queries Work on Enums
-
-The following code sample demonstrates how put and query operations work when using the C++ enum Type with PDX serialization:
-
-``` pre
-//Creating objects of type PdxEnumTestClass
-PdxEnumTestClassPtr pdxobj1(new PdxEnumTestClass(0));
-PdxEnumTestClassPtr pdxobj2(new PdxEnumTestClass(1));
-PdxEnumTestClassPtr pdxobj3(new PdxEnumTestClass(2));
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-
-//PUT Operations
-rptr->put( CacheableInt32::create(0), pdxobj1 );
-LOG( "pdxPut 1 completed " );
-
-rptr->put( CacheableInt32::create(1), pdxobj2 );
-LOG( "pdxPut 2 completed " );
-
-rptr->put( CacheableInt32::create(2), pdxobj3 );
-LOG( "pdxPut 3 completed " );
-
-
-//Query
-try {
- Serializable::registerPdxType(PdxEnumTestClass::createDeserializable);
- LOG("PdxEnumTestClass Registered Successfully....");
-} catch (geode::IllegalStateException&/* ex*/) {
- LOG("PdxEnumTestClass IllegalStateException");
-}
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-SelectResultsPtr results = rptr->query("m_enumid.name = 'id2'");
-ASSERT(results->size()== 1 , "query result should have one item");
-ResultSetPtr rsptr = dynCast<ResultSetPtr>(results);
-SelectResultsIterator iter = rsptr->getIterator();
-while (iter.moveNext()) {
- PdxEnumTestClassPtr re = dynCast<PdxEnumTestClassPtr>(iter.current());
- ASSERT(re->getID()== 1 , "query should have returned id 1");
-}
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstance.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstance.html.md.erb
deleted file mode 100644
index e152ee5..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstance.html.md.erb
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Programming Your Application to Use PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
-You can configure your cache to return a `PdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. Preventing deserialization saves both time and memory and does not require you deserialize the object to the domain class.
-
-This configuration can be done in cache.xml by setting the attribute `read-serialized` to `true` on the <pdx> element, or it can be done programmatically using the `CacheFactory::setPdxReadSerialized(bool)` method.
-
-After this preference is configured, any time a PDX object is deserialized, it is deserialized into a `PdxInstance`.
-
-The following is a code sample of using the `setField` API of `PdxInstance` to modify fields:
-
-``` pre
-RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
-CacheableKeyPtr keyport = CacheableKey::create("pdxput");
-CacheableKeyPtr keyport1 = CacheableKey::create("pdxput2");
-
-PdxInstancePtr pIPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-LOG( "modifyPdxInstance get complete." );
-
-WritablePdxInstancePtr wpiPtr( pIPtr->createWriter());
-
-ASSERT(pIPtr != NULLPTR, "pIPtr != NULLPTR expected");
-int val = 0;
-int newVal = 0;
-ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
-pIPtr->getField("m_int32", val);
-wpiPtr->setField("m_int32", val + 1);
-rptr->put(keyport, wpiPtr);
-PdxInstancePtr newPiPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
-newPiPtr->getField("m_int32", newVal);
-ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
-ASSERT((*pIPtr.ptr() == *newPiPtr.ptr()) == false,
- "PdxInstance should not be equal");
-```
-
-In addition to field access, `PdxInstance` also supports field modification using the `setField(fieldName)` method. The `setField` method has copy-on-write semantics. So for the modifications to be stored in the cache, the `PdxInstance` must be put into a region after `setField` has been called one or more times.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
deleted file mode 100644
index f1d755b..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Using PdxInstanceFactory to Create PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
-Creating a `PdxInstance` can be particularly useful when you need an instance of a domain class for plug-in code such as a function or a loader. If you have raw data for the domain object (the class name and each field's type and data), then you can explicitly create a `PdxInstance`. The `PdxInstanceFactory` API is very similar to the `PdxWriter` API except that after writing each field, you need to call the create method which returns the created `PdxInstance`.
-
-## PdxInstance Example
-
-The following is a code example of creating a `PdxInstance`.
-
-``` pre
-class Person
-{
-private:
- char* m_name;
- int m_id;
- int m_age;
-
-public:
- Person() { }
-
- Person(char* name, int id, int age)
- {
- m_name = name;
- m_id = id;
- m_age = age;
- }
-
- char* getName() const
- {
- return m_name;
- }
- int getID()
- {
- return m_id;
- }
- int getAge()
- {
- return m_age;
- }
-};
-
-int main(int argc, char ** argv)
-{
- try
- {
- // Create a Cache.
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
-
- CachePtr cachePtr = cacheFactory->set("cache-xml-file",
- "XMLs/clientPdxInstance.xml")->create();
-
- LOGINFO("Created the <%=vars.product_name%> Cache");
-
- // Get the example Region from the Cache which is declared in the
- // Cache XML file.
- RegionPtr regionPtr = cachePtr->getRegion("Person");
-
- LOGINFO("Obtained the Region from the Cache.");
-
- Person* p = new Person("Jack", 7, 21);
-
- //PdxInstanceFactory for Person class
- PdxInstanceFactoryPtr pif = cachePtr->createPdxInstanceFactory("Person");
- LOGINFO("Created PdxInstanceFactory for Person class");
-
- pif->writeString("m_name", p->getName());
- pif->writeInt("m_id", p->getID());
- pif->markIdentityField("m_id");
- pif->writeInt("m_age", p->getAge());
-
- PdxInstancePtr pdxInstance = pif->create();
-
- LOGINFO("Created PdxInstance for Person class");
-
- regionPtr->put("Key1", pdxInstance);
-
- LOGINFO("Populated PdxInstance Object");
-
- PdxInstancePtr retPdxInstance = regionPtr->get("Key1");
-
- LOGINFO("Got PdxInstance Object");
-
- int id = 0;
- retPdxInstance->getField("m_id", id);
-
- int age = 0;
- retPdxInstance->getField("m_age", age);
-
- char* name = NULL;
- retPdxInstance->getField("m_name", &name);
-
- if (id == p->getID()&& age == p->getAge() && strcmp(name, p->getName()) == 0
- && retPdxInstance->isIdentityField("m_id") == true)
- LOGINFO("PdxInstance returns all fields value expected");
- else
- LOGINFO("PdxInstance doesn't returns all fields value expected");
-
- delete p;
-
- // Close the Cache.
- cachePtr->close();
-
- LOGINFO("Closed the Cache");
-
- }
- // An exception should not occur
- catch(const Exception & geodeExcp)
- {
- LOGERROR("PdxInstance Exception: %s", geodeExcp.getMessage());
- }
-}
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserialization.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserialization.html.md.erb
deleted file mode 100644
index 23a5cd9..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserialization.html.md.erb
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title: Using PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization provides portability for PDX serializable objects so that clients can share data with
-Java servers and other non-C++ clients. PDX stores data in named fields that you can access
-individually in order to avoid the cost of deserializing the entire data object. PDX also allows you
-to mix versions of objects where you have added or removed fields.
-
-When using PDX serialization, you can use either `PdxSerializable` (for a specific domain object) or `PdxSerializer` (for all your domain objects).
-
-**Use `PdxSerializable`** when the object is one whose definition you control. You can embed the serialization/deserialization capability within
-the object, so its conversion from one format to the other is self-contained. You do this by defining an object that inherits from the `PdxSerializable`
-interface, and you register the domain class using the `registerPdxType(domainClass)` API.
-
-**Use `PdxSerializer`** when you cannot or do not wish to modify the object definition, for example, when the object is provided by a third-party.
-You define the serialization/deserialization capability in a separate place, then register the domain class for serialization in the cache using
-the `registerPdxSerializer` API.
-
-You can also set the object preference of the cache to the `PdxInstance` type, which allows you to access fields of a PDX object without deserializing the entire object.
-
-- **[Serialize Using the PdxSerializable Class](pdxserializable-interface.html)**
-
- Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-
-- **[Performing put, get, and localDestroy Operations with a PDX Domain Object](performing-ops-with-pdx-object.html)**
- This topic demonstrates how you can perform operations on a PDX domain object after you have implemented PDX serializable in your domain class.
-
-- **[Serialize Your Domain Objects with PdxSerializer and PdxWrapper](using-pdxserializer.html)**
-
- For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
-- **[Programming Your Application to Use PdxInstances](using-pdxinstance.html)**
-
- A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
-- **[Configuring PDX to Ignore Unread Fields During Deserialization](pdx-ignore-unread-fields.html)**
-
- Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
-- **[Using PdxInstanceFactory to Create PdxInstances](using-pdxinstancefactory.html)**
-
- You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
-- **[Using C++ Enum Type with PDX Serialization](using-enum-type-with-pdx.html)**
-
- Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
-- **[Using PDX Serialization with Delta Propagation](pdx-with-delta-propagation.html)**
-
- To use delta propagation with PDX serialization, you must implement the `Delta` interface methods.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserializer.html.md.erb b/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserializer.html.md.erb
deleted file mode 100644
index 20afe61..0000000
--- a/docs/geode-native-docs-cpp/serialization/cpp-serialization/using-pdxserializer.html.md.erb
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: Serialize Your Domain Objects with PdxSerializer and PdxWrapper
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
-You register a `PdxSerializer` implementation for the entire cache, programming it for all of the domain objects that you handle in this way. This way you do not have to implement the `PdxSerializable` interface for each domain class.
-
-The `PdxSerializer` allows domain classes to be serialized and deserialized as PDXs without modification of the domain class. It requires only that the domain class have a constructor accessible to the `PdxSerializer` to create an instance. The domain class will be held in a wrapper class, `PdxWrapper`.
-
-`PdxSerializer` has the following methods:
-
-- The `toData` method returns true if the PdxSerializer was able to serialize the user object, false if not.
-- If the PdxSerializer was able to deserialize the object, the `fromData` method returns a void pointer to the user object to be wrapped in a `PdxWrapper`.
-
-When you later reference the user object, use the `PdxWrapper` class. `PdxWrapper` holds a shared reference to the object in the local cache and is used during serialization and deserialization. `PdxWrapper` acts as a container for the user domain object and needs to wrap every instance of the object that uses a registered `PdxSerializer`. The object instance will not be modified. In addition, when using `PdxWrapper`, you will need to provide a function pointer to a "deallocator", which [...]
-
-The following code example defines a user object and a `PdxSerializer`. It then registers the new `PdxSerializer` and then uses `PdxWrapper` to put the object in a region and retrieve the object from a region.
-
-``` pre
-class UserClass
-{
-public:
-
- int m_int;
- string m_string;
-
- UserClass(int intVal, string stringVal)
- {
- m_int = intVal;
- m_string = stringVal;
- }
-
- static void deallocate(void * object, char * className)
- {
- if (strcmp(className, "com.example.UserClass") == 0) {
- UserClass * userObject = reinterpret_cast<UserClass*>(object);
- delete userObject;
- }
- }
-};
-
-class UserPdxSerializer : public PdxSerializer
-{
-public:
-
- void* fromData(char * className, PdxReaderPtr pdxReader)
- {
- if (strcmp(className, "com.example.UserClass") != 0) {
- return NULL;
- }
-
- int intVal = pdxReader->readInt("m_int");
- string stringVal = pdxReader->readString("m_string");
-
- UserClass * userObject = new UserClass(intVal, stringVal);
-
- return (void*) userObject;
- }
-
- bool toData(void * object, char * className, PdxWriterPtr pdxWriter)
- {
- if (strcmp(className, "com.example.UserClass") != 0) {
- return false;
- }
-
- UserClass * userObject = reinterpret_cast<UserClass*>(object);
-
- pdxWriter->writeInt("m_int", userObject->m_int);
- pdxWriter->writeString("m_string", userObject->m_string);
-
- return true;
- }
-
- UserDeallocator getDeallocator(char * className)
- {
- if (strcmp(className, "com.example.UserClass") == 0) {
- return UserClass::deallocate;
- } else {
- return NULL;
- }
- }
-};
-
-// Register a user PDX serializer
-
-Serializable::registerPdxSerializer(new UserPdxSerializer);
-
-// Put a user object into a region.
-
-UserClass * userObject = new UserClass(123, "someValue");
-PdxWrapperPtr pdxWrapper = new PdxWrapper(userObject, "com.example.UserClass",
- UserClass::deallocate);
-region->put("key", pdxWrapper);
-
-// Get a user object from a region.
-
-pdxWrapper = dynCast<PdxWrapperPtr>(region->get("key"));
-UserClass * userObject = reinterpret_cast<UserClass*>(pdxWrapper->getObject());
-```
-
-
diff --git a/docs/geode-native-docs-cpp/transactions.html.md.erb b/docs/geode-native-docs-cpp/transactions.html.md.erb
index b1950a9..b50a423 100644
--- a/docs/geode-native-docs-cpp/transactions.html.md.erb
+++ b/docs/geode-native-docs-cpp/transactions.html.md.erb
@@ -88,46 +88,37 @@ For the complete source, see the example source directory.
The C++ example creates a cache, then uses it to create a connection pool.
```cpp
- auto cache = CacheFactory().set("log-level", "none").create();
- auto poolFactory = cache.getPoolManager().createFactory();
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("exampleRegion");
```
-The example application gets a transaction manager from the cache and begins a transaction.
-
-```cpp
- auto transactionManager = cache.getCacheTransactionManager();
-
- transactionManager->begin();
-```
-
-Within the transaction, the client populates data store with 10 values associated with Key1 - Key10.
-
-```cpp
- for (auto& key : keys) {
- auto value = getValueFromExternalSystem();
- region->put(key, value);
- }
-```
-
+The example application gets a transaction manager from the cache and a five-attempt retry loop.
If all `put` operations succeed, the application commits the transaction. Otherwise, it retries up to 5 times if necessary.
```cpp
+ auto transactionManager = cache.getCacheTransactionManager();
auto retries = 5;
while (retries--) {
try {
transactionManager->begin();
- ... // PUT OPERATIONS ...
- transactionManager->commit();
- std::cout << "Committed transaction - exiting" << std::endl;
- break;
- } catch ( ... ) {
- transactionManager->rollback();
- std::cout << "Rolled back transaction - retrying(" << retries << ")" << std::endl;
- }
- }
+ for (auto& key : keys) {
+ auto value = getValueFromExternalSystem();
+ region->put(key, value);
+ }
+ transactionManager->commit();
+ std::cout << "Committed transaction - exiting" << std::endl;
+ break;
+ } catch ( ... ) {
+ if (transactionManager->exists()){
+ transactionManager->rollback();
+ }
```
diff --git a/examples/cpp/authinitialize/README.md b/examples/cpp/authinitialize/README.md
index b732b13..aaae460 100644
--- a/examples/cpp/authinitialize/README.md
+++ b/examples/cpp/authinitialize/README.md
@@ -37,11 +37,13 @@ handler on the client that authenticates against a server that was started with
1. Execute `cpp-authinitialize`, expect the following output:
- ExampleAuthInitialize::ExampleAuthInitialize called
- ExampleAuthInitialize::getCredentials called
- a = 1
- b = 2
-
+ ```
+ ExampleAuthInitialize::ExampleAuthInitialize called
+ ExampleAuthInitialize::getCredentials called
+ a = 1
+ b = 2
+ ```
+
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
For Windows cmd:
diff --git a/examples/cpp/continuousquery/README.md b/examples/cpp/continuousquery/README.md
index 379d860..94a923f 100644
--- a/examples/cpp/continuousquery/README.md
+++ b/examples/cpp/continuousquery/README.md
@@ -36,16 +36,18 @@ This is a simple example showing how to create a continuous query.
1. Execute `cpp-continuousquery`, expect the following output:
- Executing continuous query
- Create orders
- Putting and changing Order objects in the region
- MyCqListener::OnEvent called with CREATE, key[Order2], value(2, product y, 37)
- MyCqListener::OnEvent called with CREATE, key[Order4], value(4, product z, 102)
- MyCqListener::OnEvent called with CREATE, key[Order6], value(6, product z, 42)
- MyCqListener::OnEvent called with UPDATE, key[Order2], value(2, product y, 45)
- MyCqListener::OnEvent called with DESTROY, key[Order2], value(2, product y, 29)
- MyCqListener::OnEvent called with DESTROY, key[Order6], value is nullptr
- close called
+ ```
+ Executing continuous query
+ Create orders
+ Putting and changing Order objects in the region
+ MyCqListener::OnEvent called with CREATE, key[Order2], value(2, product y, 37)
+ MyCqListener::OnEvent called with CREATE, key[Order4], value(4, product z, 102)
+ MyCqListener::OnEvent called with CREATE, key[Order6], value(6, product z, 42)
+ MyCqListener::OnEvent called with UPDATE, key[Order2], value(2, product y, 45)
+ MyCqListener::OnEvent called with DESTROY, key[Order2], value(2, product y, 29)
+ MyCqListener::OnEvent called with DESTROY, key[Order6], value is nullptr
+ close called
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/continuousquery/main.cpp b/examples/cpp/continuousquery/main.cpp
index 93924ef..d93e920 100644
--- a/examples/cpp/continuousquery/main.cpp
+++ b/examples/cpp/continuousquery/main.cpp
@@ -76,14 +76,16 @@ public:
};
int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
- auto poolFactory = cache.getPoolManager().createFactory();
- auto pool = poolFactory.addLocator("localhost", 10334)
- .setSubscriptionEnabled(true)
- .create("pool");
-
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+
+ auto pool = cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .setSubscriptionEnabled(true)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("custom_orders");
diff --git a/examples/cpp/dataserializable/README.md b/examples/cpp/dataserializable/README.md
index 4eecb3b..75d8c35 100644
--- a/examples/cpp/dataserializable/README.md
+++ b/examples/cpp/dataserializable/README.md
@@ -36,16 +36,17 @@ This is a simple example showing how to register for serialization of custom obj
1. Execute `cpp-dataserializable`, expect the following output:
- Create orders
- Storing orders in the region
- Getting the orders from the region
- OrderID: 1
- Product Name: product x
- Quantity: 23
- OrderID: 2
- Product Name: product y
- Quantity: 37
-
+ ```
+ Create orders
+ Storing orders in the region
+ Getting the orders from the region
+ OrderID: 1
+ Product Name: product x
+ Quantity: 23
+ OrderID: 2
+ Product Name: product y
+ Quantity: 37
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/dataserializable/main.cpp b/examples/cpp/dataserializable/main.cpp
index c3e57c2..de66050 100644
--- a/examples/cpp/dataserializable/main.cpp
+++ b/examples/cpp/dataserializable/main.cpp
@@ -30,14 +30,15 @@ using namespace apache::geode::client;
using namespace customserializable;
int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
-
- auto poolFactory = cache.getPoolManager().createFactory();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("custom_orders");
diff --git a/examples/cpp/functionexecution/README.md b/examples/cpp/functionexecution/README.md
index a2d0c22..50e4cae 100644
--- a/examples/cpp/functionexecution/README.md
+++ b/examples/cpp/functionexecution/README.md
@@ -40,11 +40,13 @@ the example app executes those functions and prints out the result set(s).
1. Execute `cpp-functionexecution`, expect the following output:
- Result count = 3
+ ```
+ Result count = 3
- Result[0]=VALUE--1
- Result[1]=VALUE--2
- Result[2]=VALUE--3
+ Result[0]=VALUE--1
+ Result[1]=VALUE--2
+ Result[2]=VALUE--3
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/pdxserializable/README.md b/examples/cpp/pdxserializable/README.md
index bd3dd2e..14a9045 100644
--- a/examples/cpp/pdxserializable/README.md
+++ b/examples/cpp/pdxserializable/README.md
@@ -36,15 +36,17 @@ This is a simple example showing how to register for serialization of custom obj
1. Execute `cpp-pdxserializable`, expect the following output:
- Create orders
- Storing orders in the region
- Getting the orders from the region
- OrderID: 1
- Product Name: product x
- Quantity: 23
- OrderID: 2
- Product Name: product y
- Quantity: 373
+ ```
+ Create orders
+ Storing orders in the region
+ Getting the orders from the region
+ OrderID: 1
+ Product Name: product x
+ Quantity: 23
+ OrderID: 2
+ Product Name: product y
+ Quantity: 37
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/pdxserializable/main.cpp b/examples/cpp/pdxserializable/main.cpp
index ec14839..391c913 100644
--- a/examples/cpp/pdxserializable/main.cpp
+++ b/examples/cpp/pdxserializable/main.cpp
@@ -30,14 +30,15 @@ using namespace apache::geode::client;
using namespace customserializable;
int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
-
- auto poolFactory = cache.getPoolManager().createFactory();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("custom_orders");
diff --git a/examples/cpp/pdxserializer/README.md b/examples/cpp/pdxserializer/README.md
index 37cf822..1a07b6c 100644
--- a/examples/cpp/pdxserializer/README.md
+++ b/examples/cpp/pdxserializer/README.md
@@ -36,11 +36,13 @@ This is a simple example showing how to register for serialization of custom obj
1. Execute `cpp-pdxserializer`, expect the following output:
- Storing orders in the region
- Getting the orders from the region
- OrderID: 1
- Product Name: product x
- Quantity: 42
+ ```
+ Storing orders in the region
+ Getting the orders from the region
+ OrderID: 1
+ Product Name: product x
+ Quantity: 42
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/pdxserializer/main.cpp b/examples/cpp/pdxserializer/main.cpp
index c5ad221..6691e0a 100644
--- a/examples/cpp/pdxserializer/main.cpp
+++ b/examples/cpp/pdxserializer/main.cpp
@@ -32,13 +32,15 @@ using namespace apache::geode::client;
using namespace customserializer;
int main(int argc, char **argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
- auto poolFactory = cache.getPoolManager().createFactory();
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("custom_orders");
diff --git a/examples/cpp/putgetremove/README.md b/examples/cpp/putgetremove/README.md
index b2a5cbb..69c905c 100644
--- a/examples/cpp/putgetremove/README.md
+++ b/examples/cpp/putgetremove/README.md
@@ -38,12 +38,14 @@ We then put, get, and remove some primitive data in the region.
1. Execute `cpp-putgetremove`, expect the following output:
- Storing id and username in the region
- Getting the user info from the region
- rtimmons = Robert Timmons
- scharles = Sylvia Charles
- Removing rtimmons info from the region
- rtimmons's info successfully deleted3
+ ```
+ Storing id and username in the region
+ Getting the user info from the region
+ rtimmons = Robert Timmons
+ scharles = Sylvia Charles
+ Removing rtimmons info from the region
+ rtimmons's info successfully deleted
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/putgetremove/main.cpp b/examples/cpp/putgetremove/main.cpp
index 8005682..95cecc8 100644
--- a/examples/cpp/putgetremove/main.cpp
+++ b/examples/cpp/putgetremove/main.cpp
@@ -25,13 +25,15 @@
using namespace apache::geode::client;
int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
- auto poolFactory = cache.getPoolManager().createFactory();
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("example_userinfo");
diff --git a/examples/cpp/remotequery/README.md b/examples/cpp/remotequery/README.md
index a70affe..a347f83 100644
--- a/examples/cpp/remotequery/README.md
+++ b/examples/cpp/remotequery/README.md
@@ -34,15 +34,17 @@ This is a simple example showing how to create and execute a remote query.
$ ./startserver.sh
```
-1. Execute `cpp-remotequery`, expect the following output:
-
- Create orders
- Storing orders in the region
- Getting the orders from the region
- The following orders have a quantity greater than 30:
- OrderID: 2 Product Name: product y Quantity: 37
- OrderID: 4 Product Name: product z Quantity: 102
- OrderID: 6 Product Name: product z Quantity: 4
+1. Execute `cpp-remotequery`, expect the following output (quantities and order of presentation may differ):
+
+ ```
+ Create orders
+ Storing orders in the region
+ Getting the orders from the region
+ The following orders have a quantity greater than 30:
+ OrderID: 2 Product Name: product y Quantity: 37
+ OrderID: 4 Product Name: product z Quantity: 102
+ OrderID: 6 Product Name: product z Quantity: 4
+ ```
1. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/remotequery/main.cpp b/examples/cpp/remotequery/main.cpp
index 7bdd051..8e329c5 100644
--- a/examples/cpp/remotequery/main.cpp
+++ b/examples/cpp/remotequery/main.cpp
@@ -31,14 +31,15 @@ using namespace apache::geode::client;
using namespace remotequery;
int main(int argc, char** argv) {
- auto cacheFactory = CacheFactory();
- cacheFactory.set("log-level", "none");
- auto cache = cacheFactory.create();
-
- auto poolFactory = cache.getPoolManager().createFactory();
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
+ auto pool = cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("custom_orders");
diff --git a/examples/cpp/sslputget/README.md b/examples/cpp/sslputget/README.md
index ca1469e..6fc4178 100644
--- a/examples/cpp/sslputget/README.md
+++ b/examples/cpp/sslputget/README.md
@@ -35,18 +35,22 @@ This example illustrates how to use SSL encryption for all traffic between a cli
$ ./startserver.sh
```
-3. Execute `cpp-sslputget ./ClientSslKeys/`
+3. Execute (for Bash)
- For Windows:
+ `./cpp-sslputget ./ClientSslKeys/`
+
+ Or, for Windows:
`<build-type>/cpp-sslputget ./ClientSslKeys (where <build-type> = Debug or Release)`
- Expec the following output:
+ Expect the following output:
- Storing id and username in the region
- Getting the user info from the region
- rtimmons = Robert Timmons
- scharles = Sylvia Charles
+ ```
+ Storing id and username in the region
+ Getting the user info from the region
+ rtimmons = Robert Timmons
+ scharles = Sylvia Charles
+ ```
4. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/transaction/README.md b/examples/cpp/transaction/README.md
index cea019b..b0b38c5 100644
--- a/examples/cpp/transaction/README.md
+++ b/examples/cpp/transaction/README.md
@@ -64,6 +64,8 @@ Example execution ends when the transaction is successfully committed, or when t
Rolled back transaction - retrying(1)
Rolled back transaction - retrying(0)
```
+
+ You can execute `cpp-transaction` more than once, if you wish to see a variety of results.
4. Run the `stopserver` script to gracefully shutdown the Geode cluster.
diff --git a/examples/cpp/transaction/main.cpp b/examples/cpp/transaction/main.cpp
index 9104644..982b9c4 100644
--- a/examples/cpp/transaction/main.cpp
+++ b/examples/cpp/transaction/main.cpp
@@ -55,13 +55,17 @@ int getValueFromExternalSystem() {
}
int main(int argc, char** argv) {
- auto cache = CacheFactory().set("log-level", "none").create();
- auto poolFactory = cache.getPoolManager().createFactory();
+ auto cache = CacheFactory()
+ .set("log-level", "none")
+ .create();
std::cout << "Created cache" << std::endl;
- poolFactory.addLocator("localhost", 10334);
- auto pool = poolFactory.create("pool");
+ cache.getPoolManager()
+ .createFactory()
+ .addLocator("localhost", 10334)
+ .create("pool");
+
auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
auto region = regionFactory.setPoolName("pool").create("exampleRegion");