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 2017/04/04 16:26:37 UTC
[6/7] geode-native git commit: GEODE-2513: Rename and reorganize
client doc sources This closes #85
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx-auto-serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx-auto-serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx-auto-serialization.html.md.erb
new file mode 100644
index 0000000..1bcd19a
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/pdx-auto-serialization.html.md.erb
@@ -0,0 +1,366 @@
+---
+title: Using Automatic 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.
+-->
+
+You can allow your C++ client applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the provided `pdxautoserializer` command line tool.
+
+When using the C++ client API, you can automatically serialize and deserialize domain objects without making any code changes to those objects or having to implement a `PdxSerializer` or `PdxSerializable` interface and their related `fromData` and `toData` methods. The `pdxautoserializer` command-line utility allows you to generate C++ code that will serialize your domain objects in the PDX format for you.
+
+## <a id="task_czj_wnw_dl" class="no-quick-link"></a>How to Use Automatic PDX Serialization
+
+The procedure below uses the following sample class:
+
+``` pre
+class PortfolioPdx
+{
+ private:
+ int32_t id;
+ char* pkid;
+ PositionPdxPtr position1;
+ PositionPdxPtr position2;
+ CacheableHashMapPtr positions;
+ char** names;
+ int8_t* newVal;
+ CacheableDatePtr creationDate;
+ int8_t* arrayNull;
+ int8_t* arrayZeroSize;
+ public:
+ // CTOR
+ // DTORS
+ // Other Methods declarations
+```
+
+For each domain class you provide, all fields are considered for serialization except those defined as static or transient and those you explicitly exclude using macros.
+
+1. Inherit your class from `apache::geode::client::PdxSerializable`.
+
+ ``` pre
+ class PortfolioPdx : public PdxSerializable
+ ```
+
+2. Add the following method declarations in the public part of the class.
+
+ ``` pre
+ const char* getClassName() const;
+ virtual void toData(apache::geode::client::PdxWriterPtr pw);
+ virtual void fromData(apache::geode::client::PdxReaderPtr pr);
+ static PdxSerializable* createDeserializable();
+ ```
+
+3. In your pre-build environment (for example in your **makefiles**), call `pdxautoserializer` as follows:
+
+ ``` pre
+ <GFCPP>/bin/pdxautoserializer.exe --outDir=<location to generate files> <SOURCE_DIR>/PortfolioPdx.hpp
+ ```
+
+4. Include the generated file in your project and compile.
+
+The following is an example of a generated file:
+
+``` pre
+#include "PortfolioPdx.hpp"
+#include <geode/PdxWriter.hpp>
+#include <geode/PdxReader.hpp>
+#include <geode/PdxAutoSerializer.hpp>
+namespace testobject
+{
+ void PortfolioPdx::toData(apache::geode::client::PdxWriterPtr var)
+ {
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "id", id);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "pkid", pkid);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "position1", position1);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "position2", position2);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "positions", positions);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "status", status);
+ apache::geode::client::PdxAutoSerializable::writePdxObject(var, "creationDate", creationDate);
+ }
+
+ void PortfolioPdx::fromData(PdxReaderPtr var)
+ {
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "id", id);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "pkid", pkid);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "position1", position1);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "position2", position2);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "positions", positions);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "status", status);
+ apache::geode::client::PdxAutoSerializable::readPdxObject(var, "creationDate", creationDate);
+ }
+
+ const char* PortfolioPdx::getClassName() const
+ {
+ return "PortfolioPdx";
+ }
+}
+```
+
+## <a id="task_fs4_vkj_2l" class="no-quick-link"></a>Handling Arrays
+
+1. Define the following macro in your header file:
+
+ ``` pre
+ #define GFARRAYSIZE(x)
+ ```
+
+2. Assuming that the following is the class member of type array:
+
+ ``` pre
+ int8_t* newVal;
+ ```
+
+ Then define a new variable which sets the length of the array:
+
+ ``` pre
+ int32_t newValSize;
+ ```
+
+3. Tag the new variable with the `GFARRAYSIZE` macro as follows:
+
+ ``` pre
+ GFARRAYSIZE(newVal) int32_t newValSize;
+ ```
+
+## Using a Single Variable as Length for Multiple Arrays
+
+You can use the GFARRAYSIZES to have single length for multiple arrays.
+
+Define the GFARRAYSIZES macro as follows:
+
+``` pre
+#define GFARRAYSIZES(x)
+```
+
+The following is an example usage:
+
+``` pre
+class ArrayOfSizes?
+ {
+ public:
+ int32_t* array1;
+ int32_t* array2;
+ int32_t* array3;
+ int32_t* array4;
+ int32_t* array5;
+
+ GFARRAYSIZE(array1) int32_t singleSize;
+ GFARRAYSIZES("array2,array3,array4,array5") int32_t SingleSizeToMultipleArrays?;
+ };\u200b
+```
+
+## <a id="task_hph_mrw_dl" class="no-quick-link"></a>Excluding Member Variables from Serialization
+
+1. Define the following macro in your header file:
+
+ ``` pre
+ #define GFEXCLUDE
+ ```
+
+2. Tag your member variable with this macro:
+
+ ``` pre
+ GFEXCLUDE char* type;
+ ```
+
+## <a id="task_en2_4rw_dl" class="no-quick-link"></a>Marking Identity Fields
+
+Identity fields are used when comparing objects using the `hashCode` and `equals` methods.
+
+1. Define the following macro in your header file.
+
+ ``` pre
+ #define GFID(x)
+ ```
+
+2. Assuming that the following is the class member you want to use as IdentityField:
+
+ ``` pre
+ int8_t* newVal;
+ ```
+
+ Tag the member with the GFID macro as follows:
+
+ ``` pre
+ GFID(newVal)int8_t* newVal;
+ ```
+
+## Ignoring User Defined Keywords
+
+You might have certain user defined keywords after the class name. Current C++ grammar does not support this. If you have some keywords user will have to ignore them by using the `GFIGNORE` macro.
+
+For example, consider the following class definition:
+
+``` pre
+#ifdef _WIN32
+#ifdef BUILD_TESTOBJECT
+#define TESTOBJECT_EXPORT LIBEXP
+#else
+#define TESTOBJECT_EXPORT LIBIMP
+#endif
+#else
+#define TESTOBJECT_EXPORT
+#endif
+
+namespace PdxAutoTests {
+ class TESTOBJECT_EXPORT PdxAutoMegaType : public PdxSerializable {
+ }
+```
+
+Currently, the `pdxautoserializer` tool will fail to recognize `TESTOBJECT_EXPORT`. Change your class by adding the `GFIGNORE` macro as follows:
+
+``` pre
+#ifdef _WIN32
+#ifdef BUILD_TESTOBJECT
+#define TESTOBJECT_EXPORT LIBEXP
+#else
+#define TESTOBJECT_EXPORT LIBIMP
+#endif
+#else
+#define TESTOBJECT_EXPORT
+#endif
+
+using namespace apache::geode::client;
+
+#define GFIGNORE(X) X
+#define GFID
+
+namespace PdxAutoTests {
+ class GFIGNORE(TESTOBJECT_EXPORT) PdxAutoMegaType : public PdxSerializable {
+```
+
+## <a id="topic_d3q_v3c_2l" class="no-quick-link"></a>Additional Usage Information for the pdxautoserializer Tool
+
+The `pdxautoserializer` tool takes classes as input and generates code that will serialize the class into the PDX format for you.
+
+The `pdxautoserializer` tool is located in `$GEODE/bin` where `$GEODE` corresponds to the installation location of the client.
+
+Some additional notes about using the `pdxautoserializer` tool:
+
+- Any const type in the class members are ignored by the `pdxserializer` tool.
+- Generated files will have namespace in the file name.
+
+To view the command-line help for the tool, type:
+
+``` pre
+prompt> pdxautoserializer.exe --help
+```
+
+Help returns the following syntax and usage information:
+
+``` pre
+Usage: pdxautoserializer.exe [OPTIONS] <resources e.g. header> ...
+
+Resource name should be the path to the header containing the classes to be
+auto-serialized.
+
+[OPTIONS] may be one of those given below.
+
+SINGLE denotes that the option should be specified only once.
+MULTIPLE denotes that the option can be specified more than once.
+OPTIONAL denotes that the option may be skipped in which case the default
+for that shall be chosen.
+
+--className=VALUE Name of the class for which to generate auto-serialization code (MULTIPLE,OPTIONAL)
+--classNameStr=VALUE Name of the class in string (MULTIPLE,OPTIONAL)
+--help This help message.
+--outDir The output directory of the generated files (SINGLE,OPTIONAL)
+--suffix The suffix of the generated filenames -- default is 'Serializable' (SINGLE,OPTIONAL)
+--usage This usage message.
+
+Examples:
+pdxautoserializer -outDir=<DIR NAME> <RESOURCE>
+pdxautoserializer -outDir=<DIR NAME> --className=<CLASSNAME1> --className=<CLASSNAME2> <RESOURCE>
+pdxautoserializer -outDir=<DIR NAME> --classNameStr=<CLASSNAME1:User defined String> --classNameStr=<CLASSNAME:User defined String> <RESOURCE>
+
+Helper Macros to be defined in Input Header File :
+GFINCLUDE for including a specific member for serialization
+GFEXCLUDE for excluding a specific member for serialization
+GFID for considering a member as Identify Field
+GFARRAYSIZE for specifying a array length member
+GFIGNORE for ignoring certain keywords
+For more details refer to documentation on this utility.
+```
+
+## Generating Automatic Code for a Single Class
+
+Many times there are multiple classes in a single header file. For example:
+
+``` pre
+#ifndef HEADER_HEADER
+#define HEADER_HEADER
+
+class class1{
+};
+class class2{
+};
+class class3 : public PdxSerializable{
+};
+#endif
+```
+
+If you want to generate code for only one of the classes, then use the `--className` option. For example, if you only want to generate code for class3, then you would use the following command:
+
+``` pre
+pdxautoserializer --outDir=<outDir> --className=class3
+```
+
+## Choosing Your Own Suffix to Identify the Generated Files.
+
+The `pdxserializer` tool also provides the option to choose your own suffix for the generated C++ files. This can help you write less code in your makefiles. Here's an example command:
+
+``` pre
+pdxautoserializer --outDir=<outDir> --className=CharTypes --suffix="generated"
+```
+
+## <a id="topic_f33_fsw_dl" class="no-quick-link"></a>Example of Using PDX Serialization in Your Application
+
+``` pre
+CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
+ // Create a cache with the "clientPdxRemoteQuery.xml" Cache XML file.
+ CachePtr cachePtr = cacheFactory->set("cache-xml-file", "XMLs\\clientPdxRemoteQuery.xml")
+ ->create();
+
+ LOGINFO("Created the Cache");
+
+ // Get the example Region from the Cache which is declared in the Cache XML file.
+ RegionPtr regionPtr = cachePtr->getRegion( "Portfolios");
+
+ LOGINFO( "Obtained the Region from the Cache");
+
+ // Register our Serializable/Cacheable Query objects, viz. PortfolioPdx and PositionPdx.
+ Serializable::registerPdxType(PortfolioPdx::createDeserializable);
+ PortfolioPdxPtr port1Ptr(new PortfolioPdx(1 /*ID*/, 10 /*size*/));
+ PortfolioPdxPtr port2Ptr(new PortfolioPdx(2 /*ID*/, 20 /*size*/));
+ PortfolioPdxPtr port3Ptr(new PortfolioPdx(3 /*ID*/, 30 /*size*/));
+ regionPtr->put("Key1", port1Ptr);
+ regionPtr->put("Key2", port2Ptr);
+ regionPtr->put("Key3", port3Ptr);
+
+ // Get the QueryService from the Cache.
+ QueryServicePtr qrySvcPtr = cachePtr->getQueryService( "examplePool");
+
+ LOGINFO( "Got the QueryService from the Cache");
+
+ // Execute a Query which returns a ResultSet.
+ QueryPtr qryPtr = qrySvcPtr->newQuery("SELECT DISTINCT * FROM /Portfolios");
+ SelectResultsPtr resultsPtr = qryPtr->execute();
+
+ LOGINFO( "ResultSet Query returned %d rows", resultsPtr->size());
+```
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx-ignore-unread-fields.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx-ignore-unread-fields.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx-ignore-unread-fields.html.md.erb
new file mode 100644
index 0000000..1149494
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/pdx-ignore-unread-fields.html.md.erb
@@ -0,0 +1,37 @@
+---
+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();
+```
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
new file mode 100644
index 0000000..df656b9
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
@@ -0,0 +1,60 @@
+---
+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 register a `PdxSerializer` for the entire cache, implement PDX serialization for each domain object or use automatic PDX serialization by running the `pdxautoserializer` tool.
+
+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.
+
+When using the C++ client API, you can opt to use PDX autoserialization. The command line tool `pdxautoserializer` will automatically generate C++ code to PDX serialize the class you want to serialize.
+
+- **[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.
+
+- **[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.
+
+- **[Using Automatic PDX Serialization](pdx-auto-serialization.html)**
+
+ You can allow your C++ client applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the `pdxautoserializer` command line tool.
+
+- **[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. Geode 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.
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb
new file mode 100644
index 0000000..4f9bbf4
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb
@@ -0,0 +1,45 @@
+---
+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...
+
+};
+```
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx_auto_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx_auto_serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx_auto_serialization.html.md.erb
deleted file mode 100644
index 1bcd19a..0000000
--- a/docs/geode-native-docs/cpp-caching-api/pdx_auto_serialization.html.md.erb
+++ /dev/null
@@ -1,366 +0,0 @@
----
-title: Using Automatic 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.
--->
-
-You can allow your C++ client applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the provided `pdxautoserializer` command line tool.
-
-When using the C++ client API, you can automatically serialize and deserialize domain objects without making any code changes to those objects or having to implement a `PdxSerializer` or `PdxSerializable` interface and their related `fromData` and `toData` methods. The `pdxautoserializer` command-line utility allows you to generate C++ code that will serialize your domain objects in the PDX format for you.
-
-## <a id="task_czj_wnw_dl" class="no-quick-link"></a>How to Use Automatic PDX Serialization
-
-The procedure below uses the following sample class:
-
-``` pre
-class PortfolioPdx
-{
- private:
- int32_t id;
- char* pkid;
- PositionPdxPtr position1;
- PositionPdxPtr position2;
- CacheableHashMapPtr positions;
- char** names;
- int8_t* newVal;
- CacheableDatePtr creationDate;
- int8_t* arrayNull;
- int8_t* arrayZeroSize;
- public:
- // CTOR
- // DTORS
- // Other Methods declarations
-```
-
-For each domain class you provide, all fields are considered for serialization except those defined as static or transient and those you explicitly exclude using macros.
-
-1. Inherit your class from `apache::geode::client::PdxSerializable`.
-
- ``` pre
- class PortfolioPdx : public PdxSerializable
- ```
-
-2. Add the following method declarations in the public part of the class.
-
- ``` pre
- const char* getClassName() const;
- virtual void toData(apache::geode::client::PdxWriterPtr pw);
- virtual void fromData(apache::geode::client::PdxReaderPtr pr);
- static PdxSerializable* createDeserializable();
- ```
-
-3. In your pre-build environment (for example in your **makefiles**), call `pdxautoserializer` as follows:
-
- ``` pre
- <GFCPP>/bin/pdxautoserializer.exe --outDir=<location to generate files> <SOURCE_DIR>/PortfolioPdx.hpp
- ```
-
-4. Include the generated file in your project and compile.
-
-The following is an example of a generated file:
-
-``` pre
-#include "PortfolioPdx.hpp"
-#include <geode/PdxWriter.hpp>
-#include <geode/PdxReader.hpp>
-#include <geode/PdxAutoSerializer.hpp>
-namespace testobject
-{
- void PortfolioPdx::toData(apache::geode::client::PdxWriterPtr var)
- {
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "id", id);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "pkid", pkid);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "position1", position1);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "position2", position2);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "positions", positions);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "status", status);
- apache::geode::client::PdxAutoSerializable::writePdxObject(var, "creationDate", creationDate);
- }
-
- void PortfolioPdx::fromData(PdxReaderPtr var)
- {
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "id", id);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "pkid", pkid);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "position1", position1);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "position2", position2);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "positions", positions);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "status", status);
- apache::geode::client::PdxAutoSerializable::readPdxObject(var, "creationDate", creationDate);
- }
-
- const char* PortfolioPdx::getClassName() const
- {
- return "PortfolioPdx";
- }
-}
-```
-
-## <a id="task_fs4_vkj_2l" class="no-quick-link"></a>Handling Arrays
-
-1. Define the following macro in your header file:
-
- ``` pre
- #define GFARRAYSIZE(x)
- ```
-
-2. Assuming that the following is the class member of type array:
-
- ``` pre
- int8_t* newVal;
- ```
-
- Then define a new variable which sets the length of the array:
-
- ``` pre
- int32_t newValSize;
- ```
-
-3. Tag the new variable with the `GFARRAYSIZE` macro as follows:
-
- ``` pre
- GFARRAYSIZE(newVal) int32_t newValSize;
- ```
-
-## Using a Single Variable as Length for Multiple Arrays
-
-You can use the GFARRAYSIZES to have single length for multiple arrays.
-
-Define the GFARRAYSIZES macro as follows:
-
-``` pre
-#define GFARRAYSIZES(x)
-```
-
-The following is an example usage:
-
-``` pre
-class ArrayOfSizes?
- {
- public:
- int32_t* array1;
- int32_t* array2;
- int32_t* array3;
- int32_t* array4;
- int32_t* array5;
-
- GFARRAYSIZE(array1) int32_t singleSize;
- GFARRAYSIZES("array2,array3,array4,array5") int32_t SingleSizeToMultipleArrays?;
- };\u200b
-```
-
-## <a id="task_hph_mrw_dl" class="no-quick-link"></a>Excluding Member Variables from Serialization
-
-1. Define the following macro in your header file:
-
- ``` pre
- #define GFEXCLUDE
- ```
-
-2. Tag your member variable with this macro:
-
- ``` pre
- GFEXCLUDE char* type;
- ```
-
-## <a id="task_en2_4rw_dl" class="no-quick-link"></a>Marking Identity Fields
-
-Identity fields are used when comparing objects using the `hashCode` and `equals` methods.
-
-1. Define the following macro in your header file.
-
- ``` pre
- #define GFID(x)
- ```
-
-2. Assuming that the following is the class member you want to use as IdentityField:
-
- ``` pre
- int8_t* newVal;
- ```
-
- Tag the member with the GFID macro as follows:
-
- ``` pre
- GFID(newVal)int8_t* newVal;
- ```
-
-## Ignoring User Defined Keywords
-
-You might have certain user defined keywords after the class name. Current C++ grammar does not support this. If you have some keywords user will have to ignore them by using the `GFIGNORE` macro.
-
-For example, consider the following class definition:
-
-``` pre
-#ifdef _WIN32
-#ifdef BUILD_TESTOBJECT
-#define TESTOBJECT_EXPORT LIBEXP
-#else
-#define TESTOBJECT_EXPORT LIBIMP
-#endif
-#else
-#define TESTOBJECT_EXPORT
-#endif
-
-namespace PdxAutoTests {
- class TESTOBJECT_EXPORT PdxAutoMegaType : public PdxSerializable {
- }
-```
-
-Currently, the `pdxautoserializer` tool will fail to recognize `TESTOBJECT_EXPORT`. Change your class by adding the `GFIGNORE` macro as follows:
-
-``` pre
-#ifdef _WIN32
-#ifdef BUILD_TESTOBJECT
-#define TESTOBJECT_EXPORT LIBEXP
-#else
-#define TESTOBJECT_EXPORT LIBIMP
-#endif
-#else
-#define TESTOBJECT_EXPORT
-#endif
-
-using namespace apache::geode::client;
-
-#define GFIGNORE(X) X
-#define GFID
-
-namespace PdxAutoTests {
- class GFIGNORE(TESTOBJECT_EXPORT) PdxAutoMegaType : public PdxSerializable {
-```
-
-## <a id="topic_d3q_v3c_2l" class="no-quick-link"></a>Additional Usage Information for the pdxautoserializer Tool
-
-The `pdxautoserializer` tool takes classes as input and generates code that will serialize the class into the PDX format for you.
-
-The `pdxautoserializer` tool is located in `$GEODE/bin` where `$GEODE` corresponds to the installation location of the client.
-
-Some additional notes about using the `pdxautoserializer` tool:
-
-- Any const type in the class members are ignored by the `pdxserializer` tool.
-- Generated files will have namespace in the file name.
-
-To view the command-line help for the tool, type:
-
-``` pre
-prompt> pdxautoserializer.exe --help
-```
-
-Help returns the following syntax and usage information:
-
-``` pre
-Usage: pdxautoserializer.exe [OPTIONS] <resources e.g. header> ...
-
-Resource name should be the path to the header containing the classes to be
-auto-serialized.
-
-[OPTIONS] may be one of those given below.
-
-SINGLE denotes that the option should be specified only once.
-MULTIPLE denotes that the option can be specified more than once.
-OPTIONAL denotes that the option may be skipped in which case the default
-for that shall be chosen.
-
---className=VALUE Name of the class for which to generate auto-serialization code (MULTIPLE,OPTIONAL)
---classNameStr=VALUE Name of the class in string (MULTIPLE,OPTIONAL)
---help This help message.
---outDir The output directory of the generated files (SINGLE,OPTIONAL)
---suffix The suffix of the generated filenames -- default is 'Serializable' (SINGLE,OPTIONAL)
---usage This usage message.
-
-Examples:
-pdxautoserializer -outDir=<DIR NAME> <RESOURCE>
-pdxautoserializer -outDir=<DIR NAME> --className=<CLASSNAME1> --className=<CLASSNAME2> <RESOURCE>
-pdxautoserializer -outDir=<DIR NAME> --classNameStr=<CLASSNAME1:User defined String> --classNameStr=<CLASSNAME:User defined String> <RESOURCE>
-
-Helper Macros to be defined in Input Header File :
-GFINCLUDE for including a specific member for serialization
-GFEXCLUDE for excluding a specific member for serialization
-GFID for considering a member as Identify Field
-GFARRAYSIZE for specifying a array length member
-GFIGNORE for ignoring certain keywords
-For more details refer to documentation on this utility.
-```
-
-## Generating Automatic Code for a Single Class
-
-Many times there are multiple classes in a single header file. For example:
-
-``` pre
-#ifndef HEADER_HEADER
-#define HEADER_HEADER
-
-class class1{
-};
-class class2{
-};
-class class3 : public PdxSerializable{
-};
-#endif
-```
-
-If you want to generate code for only one of the classes, then use the `--className` option. For example, if you only want to generate code for class3, then you would use the following command:
-
-``` pre
-pdxautoserializer --outDir=<outDir> --className=class3
-```
-
-## Choosing Your Own Suffix to Identify the Generated Files.
-
-The `pdxserializer` tool also provides the option to choose your own suffix for the generated C++ files. This can help you write less code in your makefiles. Here's an example command:
-
-``` pre
-pdxautoserializer --outDir=<outDir> --className=CharTypes --suffix="generated"
-```
-
-## <a id="topic_f33_fsw_dl" class="no-quick-link"></a>Example of Using PDX Serialization in Your Application
-
-``` pre
-CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
- // Create a cache with the "clientPdxRemoteQuery.xml" Cache XML file.
- CachePtr cachePtr = cacheFactory->set("cache-xml-file", "XMLs\\clientPdxRemoteQuery.xml")
- ->create();
-
- LOGINFO("Created the Cache");
-
- // Get the example Region from the Cache which is declared in the Cache XML file.
- RegionPtr regionPtr = cachePtr->getRegion( "Portfolios");
-
- LOGINFO( "Obtained the Region from the Cache");
-
- // Register our Serializable/Cacheable Query objects, viz. PortfolioPdx and PositionPdx.
- Serializable::registerPdxType(PortfolioPdx::createDeserializable);
- PortfolioPdxPtr port1Ptr(new PortfolioPdx(1 /*ID*/, 10 /*size*/));
- PortfolioPdxPtr port2Ptr(new PortfolioPdx(2 /*ID*/, 20 /*size*/));
- PortfolioPdxPtr port3Ptr(new PortfolioPdx(3 /*ID*/, 30 /*size*/));
- regionPtr->put("Key1", port1Ptr);
- regionPtr->put("Key2", port2Ptr);
- regionPtr->put("Key3", port3Ptr);
-
- // Get the QueryService from the Cache.
- QueryServicePtr qrySvcPtr = cachePtr->getQueryService( "examplePool");
-
- LOGINFO( "Got the QueryService from the Cache");
-
- // Execute a Query which returns a ResultSet.
- QueryPtr qryPtr = qrySvcPtr->newQuery("SELECT DISTINCT * FROM /Portfolios");
- SelectResultsPtr resultsPtr = qryPtr->execute();
-
- LOGINFO( "ResultSet Query returned %d rows", resultsPtr->size());
-```
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb
deleted file mode 100644
index 1149494..0000000
--- a/docs/geode-native-docs/cpp-caching-api/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();
-```
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx_serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx_serialization.html.md.erb
deleted file mode 100644
index 58c0a3a..0000000
--- a/docs/geode-native-docs/cpp-caching-api/pdx_serialization.html.md.erb
+++ /dev/null
@@ -1,60 +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 register a `PdxSerializer` for the entire cache, implement PDX serialization for each domain object or use automatic PDX serialization by running the `pdxautoserializer` tool.
-
-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.
-
-When using the C++ client API, you can opt to use PDX autoserialization. The command line tool `pdxautoserializer` will automatically generate C++ code to PDX serialize the class you want to serialize.
-
-- **[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.
-
-- **[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.
-
-- **[Using Automatic PDX Serialization](pdx_auto_serialization.html)**
-
- You can allow your C++ client applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the `pdxautoserializer` command line tool.
-
-- **[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. Geode 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.
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdx_with_delta_propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdx_with_delta_propagation.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdx_with_delta_propagation.html.md.erb
deleted file mode 100644
index 4f9bbf4..0000000
--- a/docs/geode-native-docs/cpp-caching-api/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...
-
-};
-```
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
new file mode 100644
index 0000000..72dfbbf
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
@@ -0,0 +1,112 @@
+---
+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.
+-->
+
+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.
+
+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` method.
+
+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.
+
+ 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.
+
+ 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.
+
+ 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.
+
+ 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.
+
+ 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.
+
+## 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 );
+}
+```
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/pdxserializable_interface.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/pdxserializable_interface.html.md.erb b/docs/geode-native-docs/cpp-caching-api/pdxserializable_interface.html.md.erb
deleted file mode 100644
index 72dfbbf..0000000
--- a/docs/geode-native-docs/cpp-caching-api/pdxserializable_interface.html.md.erb
+++ /dev/null
@@ -1,112 +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.
--->
-
-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.
-
-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` method.
-
-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.
-
- 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.
-
- 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.
-
- 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.
-
- 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.
-
- 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.
-
-## 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 );
-}
-```
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb b/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
new file mode 100644
index 0000000..42e0d9f
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
@@ -0,0 +1,60 @@
+---
+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#concept_79E4C10E5F634A7F84F96633694B3D69__example_70237026967A42898584AE644D437E69).
+
+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());
+ ```
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb b/docs/geode-native-docs/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb
deleted file mode 100644
index 5962129..0000000
--- a/docs/geode-native-docs/cpp-caching-api/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#concept_79E4C10E5F634A7F84F96633694B3D69__example_70237026967A42898584AE644D437E69).
-
-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());
- ```
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/region-data-requiring-serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/region-data-requiring-serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/region-data-requiring-serialization.html.md.erb
new file mode 100644
index 0000000..3a78e94
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/region-data-requiring-serialization.html.md.erb
@@ -0,0 +1,36 @@
+---
+title: Region Data Requiring 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.
+-->
+
+Certain region types (including client regions) require serialization.
+
+Region data in the following types of regions must be serializable:
+
+- Partitioned regions (except functions that add data locally to a partitioned region use the deserialized form).
+- Distributed regions.
+- Regions that are persisted or overflowed to disk.
+- Server or client regions in a client/server installation.
+- Regions distributed between gateways in a multi-site installation.
+- Regions that receive events from remote caches.
+- Regions that provide function arguments and results.
+
+To minimize the cost of serialization and deserialization, Geode avoids changing the data format whenever possible. This means your data may be stored in the cache in serialized or deserialized form, depending on how you use it. For example, if a server acts only as a storage location for data distribution between clients, it makes sense to leave the data in serialized form, ready to be transmitted to clients that request it. Partitioned region data is always stored in serialized form with one exception\u2014functions that add data to a partitioned region locally use the deserialized form.
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/region_data_requiring_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/region_data_requiring_serialization.html.md.erb b/docs/geode-native-docs/cpp-caching-api/region_data_requiring_serialization.html.md.erb
deleted file mode 100644
index 3a78e94..0000000
--- a/docs/geode-native-docs/cpp-caching-api/region_data_requiring_serialization.html.md.erb
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Region Data Requiring 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.
--->
-
-Certain region types (including client regions) require serialization.
-
-Region data in the following types of regions must be serializable:
-
-- Partitioned regions (except functions that add data locally to a partitioned region use the deserialized form).
-- Distributed regions.
-- Regions that are persisted or overflowed to disk.
-- Server or client regions in a client/server installation.
-- Regions distributed between gateways in a multi-site installation.
-- Regions that receive events from remote caches.
-- Regions that provide function arguments and results.
-
-To minimize the cost of serialization and deserialization, Geode avoids changing the data format whenever possible. This means your data may be stored in the cache in serialized or deserialized form, depending on how you use it. For example, if a server acts only as a storage location for data distribution between clients, it makes sense to leave the data in serialized form, ready to be transmitted to clients that request it. Partitioned region data is always stored in serialized form with one exception\u2014functions that add data to a partitioned region locally use the deserialized form.
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
new file mode 100644
index 0000000..b640c3e
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
@@ -0,0 +1,79 @@
+---
+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: the `apache::geode::client::Serializable` interface and Geode PDX serialization.
+
+Geode 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 `PdxSerializer` (for all your domain objects) or `PdxSerializable` (for a specific domain object).
+
+`PdxSerializer` is used when a user has registered a domain class for serialization in the cache using the `registerPdxSerializer` API.
+
+`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.
+
+The non-PDX serialization option is to use the `apache::geode::client::Serializable` interface. This `Serializable` interface can be a good option performance-wise if the size of your objects is small. `Serializable` is used whenever a user domain class is not inherited by `PdxSerializable`, but the user has registered the class with the `registerType` API. See [Serializing Data with the Serializable Interface](serialization-using-serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003) for more information.
+
+<a id="concept_7B6F272ACEA14753A723CB73B858ADBE__table_D61A94C4BFBE4712835F632F30BB488E"></a>
+
+<table>
+<caption><span class="tablecap">Table 1. Serialization Options\u2014Comparison of Features</span></caption>
+<colgroup>
+<col width="50%" />
+<col width="25%" />
+<col width="25%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Capability</th>
+<th>Serializable</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 Geode - no need to program Java-side implementation</p></td>
+<td></td>
+<td>X</td>
+</tr>
+<tr class="even">
+<td><p>Works with GemFire delta propagation</p></td>
+<td>X</td>
+<td>X**</td>
+</tr>
+</tbody>
+</table>
+
+<span class="tablecap">**Table 1.** Serialization Options\u2014Comparison of Features</span>
+
+\* You can mix domain object versions where the differences between versions are the addition and removal of object fields.
+
+\*\* See [Using PDX Serialization with Delta Propagation](pdx-with-delta-propagation.html#concept_F33AC930A8F14F0A9EE07AC31FFD8C8F) for requirements.
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
new file mode 100644
index 0000000..7b530b6
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
@@ -0,0 +1,48 @@
+---
+title: Serializing Data
+---
+
+<!--
+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.
+
+- **[Region Data Requiring Serialization](region-data-requiring-serialization.html)**
+
+ Certain region types (including client regions) require serialization.
+
+- **[Data Serialization Options](serialization-options.html)**
+
+ The C++ client API provides two serialization options: the `apache::geode::client::Serializable` interface and Geode PDX serialization.
+
+- **[Serializing Data with 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 register a PdxSerializer for the entire cache, implement PDX serialization for each domain object or use automatic PDX serialization by running the `pdxautoserializer` tool.
+
+- **[Serializing Data with the Serializable Interface](serialization-using-serializable.html)**
+
+ The C++ client API provides a `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable 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.
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
new file mode 100644
index 0000000..9b95e77
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
@@ -0,0 +1,256 @@
+---
+title: Serializing Data with the Serializable 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 `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable 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, Geode 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\u2019s `toData` function.
+
+When your application subsequently receives a byte array, Geode 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 Serializable Interface
+
+To store your own data types in the cache, you need to derive a new subclass from the `Serializable` 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\u2019s 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\u2019s 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 `Serializable` and implement the following:
+
+- `toData`\u2014a function to serialize the data.
+- `fromData`\u2014a function to deserialize the data.
+- `classId`\u2014a function to provide a unique integer for the class.
+- `TypeFactoryMethod`\u2014a pointer to a function that returns a `Serializable*` to an uninitialized instance of the type.
+
+## Example 2. Implementing a Serializable Class
+
+This example shows a code sample that demonstrates how to implement a serializable class.
+
+``` pre
+class BankAccount : public Serializable
+{
+ 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 Serializable interface
+// Our TypeFactoryMethod
+static Serializable* createInstance( )
+{
+ return new BankAccount( 0, 0 );
+}
+
+int32_t classId( )
+{
+ return 10; // must be unique per class.
+}
+
+virtual uint32_t objectSize() const
+{
+ return 10;
+}
+
+void toData( DataOutput& output )
+{
+ output.writeInt( m_ownerId );
+ output.writeInt( m_accountId );
+}
+
+Serializable* 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
+Serializable::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 `Serializable` 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 `Serializable`.
+
+- Implement `operator==` and `hashcode` functions.
+
+## Example 3. Extending a Serializable 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 Serializable* 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 );
+}
+
+Serializable* 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 uint32_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.
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
deleted file mode 100644
index 9b4d546..0000000
--- a/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
+++ /dev/null
@@ -1,79 +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: the `apache::geode::client::Serializable` interface and Geode PDX serialization.
-
-Geode 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 `PdxSerializer` (for all your domain objects) or `PdxSerializable` (for a specific domain object).
-
-`PdxSerializer` is used when a user has registered a domain class for serialization in the cache using the `registerPdxSerializer` API.
-
-`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.
-
-The non-PDX serialization option is to use the `apache::geode::client::Serializable` interface. This `Serializable` interface can be a good option performance-wise if the size of your objects is small. `Serializable` is used whenever a user domain class is not inherited by `PdxSerializable`, but the user has registered the class with the `registerType` API. See [Serializing Data with the Serializable Interface](serialization_using_serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003) for more information.
-
-<a id="concept_7B6F272ACEA14753A723CB73B858ADBE__table_D61A94C4BFBE4712835F632F30BB488E"></a>
-
-<table>
-<caption><span class="tablecap">Table 1. Serialization Options\u2014Comparison of Features</span></caption>
-<colgroup>
-<col width="50%" />
-<col width="25%" />
-<col width="25%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Capability</th>
-<th>Serializable</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 Geode - no need to program Java-side implementation</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Works with GemFire delta propagation</p></td>
-<td>X</td>
-<td>X**</td>
-</tr>
-</tbody>
-</table>
-
-<span class="tablecap">**Table 1.** Serialization Options\u2014Comparison of Features</span>
-
-\* You can mix domain object versions where the differences between versions are the addition and removal of object fields.
-
-\*\* See [Using PDX Serialization with Delta Propagation](pdx_with_delta_propagation.html#concept_F33AC930A8F14F0A9EE07AC31FFD8C8F) for requirements.
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
deleted file mode 100644
index e8fc4ca..0000000
--- a/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: Serializing Data
----
-
-<!--
-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.
-
-- **[Region Data Requiring Serialization](region_data_requiring_serialization.html)**
-
- Certain region types (including client regions) require serialization.
-
-- **[Data Serialization Options](serialization_options.html)**
-
- The C++ client API provides two serialization options: the `apache::geode::client::Serializable` interface and Geode PDX serialization.
-
-- **[Serializing Data with 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 register a PdxSerializer for the entire cache, implement PDX serialization for each domain object or use automatic PDX serialization by running the `pdxautoserializer` tool.
-
-- **[Serializing Data with the Serializable Interface](serialization_using_serializable.html)**
-
- The C++ client API provides a `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable 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.
-
-