This is an automated email from the ASF dual-hosted git repository.
dbarnes pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git
The following commit(s) were added to refs/heads/develop by this push:
new 9c58ab7 GEODE-4728: update serialization docs
9c58ab7 is described below
commit 9c58ab7f86f935e484b3dd547578c47039e5ef3f
Author: Dave Barnes <[email protected]>
AuthorDate: Tue Jul 17 15:41:26 2018 -0700
GEODE-4728: update serialization docs
---
.../source/subnavs/geode-nc-nav.erb | 113 ++++++-
.../about-client-users-guide.html.md.erb | 2 +-
.../cpp-caching-api/cpp-caching-api.html.md.erb | 2 +-
.../pdx-auto-serialization.html.md.erb | 366 ---------------------
...region-data-requiring-serialization.html.md.erb | 36 --
.../data-serialization.html.md.erb | 35 --
.../dotnet-caching-api.html.md.erb | 2 +-
.../dotnet-data-serialization.html.md.erb | 35 --
.../cpp-serialization}/data-as-blob.html.md.erb | 0
.../cpp-serialization}/object-graphs.html.md.erb | 0
.../pdx-ignore-unread-fields.html.md.erb | 0
.../pdx-serialization.html.md.erb | 17 +-
.../pdx-with-delta-propagation.html.md.erb | 0
.../pdxserializable-interface.html.md.erb | 26 +-
.../performing-ops-with-pdx-object.html.md.erb | 2 +-
.../serialization-options.html.md.erb | 25 +-
.../serialization-overview.html.md.erb | 17 +-
.../serialization-using-serializable.html.md.erb | 77 +++--
.../using-enum-type-with-pdx.html.md.erb | 0
.../using-pdxinstance.html.md.erb | 4 +-
.../using-pdxinstancefactory.html.md.erb | 0
.../using-pdxserializer.html.md.erb | 2 +-
.../serialization/data-serialization.html.md.erb | 83 +++++
.../custom-class-igfserializable.html.md.erb | 8 +-
.../dotnet-data-serialization-options.html.md.erb | 4 +-
.../dotnet-data-serialization.html.md.erb | 55 ++++
.../dotnet-pdx-autoserializer.html.md.erb | 2 +-
.../dotnet-pdx-serialization-features.html.md.erb | 0
.../dotnet-pdx-serialization.html.md.erb | 11 +-
.../extending-pdx-autoserializer.html.md.erb | 0
.../how-igfserializable-works.html.md.erb | 2 +-
.../implementing-igfserializable.html.md.erb | 12 +-
.../mapping-dotnet-domain-type-names.html.md.erb | 2 +-
.../programming-ipdxinstance.html.md.erb | 0
.../registering-the-type.html.md.erb | 2 +-
.../serializable-types.html.md.erb | 6 +-
.../serialize-using-igfserializable.html.md.erb | 10 +-
.../serialize-using-ipdxserializable.html.md.erb | 0
.../serializing-domain-objects.html.md.erb | 0
.../serialization/dotnet-serialization/t.tmp | 23 ++
.../using-ipdxinstancefactory.html.md.erb | 1 -
docs/geode-native-docs/transactions.html.md.erb | 22 --
42 files changed, 407 insertions(+), 597 deletions(-)
diff --git
a/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
b/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
index 9a750c8..2d3491b 100644
--- a/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
+++ b/docs/geode-native-book/master_middleman/source/subnavs/geode-nc-nav.erb
@@ -58,10 +58,119 @@ limitations under the License.
</ul>
</li>
- <li>
- <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/data-serialization.html">Data
Serialization</a>
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/data-serialization.html">Serializing
Data</a>
+ <ul>
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/serialization-overview.html">Data
Serialization - C++</a>
+ <ul>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/serialization-options.html">Data
Serialization Options</a>
+ </li>
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/data-serialization.html#pdx-serialization">Using
PDX Serialization</a>
+ <ul>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/pdxserializable-interface.html">Serialize
Using the PdxSerializable Class</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/performing-ops-with-pdx-object.html">Performing
put, get, and localDestroy Operations with a PDX Domain Object</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/using-pdxserializer.html">Serialize
Your Domain Objects with PdxSerializer and PdxWrapper</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/using-pdxinstance.html">Programming
Your Application to Use PdxInstances</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/pdx-ignore-unread-fields.html">Configuring
PDX to Ignore Unread Fields During Deserialization</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/using-pdxinstancefactory.html">Using
PdxInstanceFactory to Create PdxInstances</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/using-enum-type-with-pdx.html">Using
C++ Enum Type with PDX Serialization</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/pdx-with-delta-propagation.html">Using
PDX Serialization with Delta Propagation</a>
+ </li>
+ </ul>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/serialization-using-serializable.html">Serializing
Data with the DataSerializable Interface</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/object-graphs.html">Serializing
Object Graphs</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/cpp-serialization/data-as-blob.html">Serializing
and Accessing Data as a Blob</a>
+ </li>
+ </ul>
+ </li>
+
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/dotnet-data-serialization.html">Data
Serialization - .NET</a>
+ <ul>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/dotnet-data-serialization-options.html">Data
Serialization Options</a>
+ </li>
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/dotnet-pdx-serialization.html">Serialize
with PDX Serialization</a>
+ <ul>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html">Geode
PDX Serialization Features</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html">Serialize
Using the Geode PDX Autoserializer</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/extending-pdx-autoserializer.html">Extend
the PDX Autoserializer</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/serializing-domain-objects.html">Serialize
Your Domain Objects with IPdxSerializer</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/serialize-using-ipdxserializable.html">Serialize
Using the IPdxSerializable Interface</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/programming-ipdxinstance.html">Program
Your Application to Use IPdxInstance</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/using-ipdxinstancefactory.html">Use
the IPdxInstanceFactory to Create IPdxInstances</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html">Map
.NET Domain Type Names to PDX Type Names with IPdxTypeMapper</a>
+ </li>
+ </ul>
+ </li>
+ <li class="has_submenu">
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/serialize-using-igfserializable.html">Serialize
with the IGeodeSerializable Interface</a>
+ <ul>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/serializable-types.html">Generic
and Custom Serializable Types</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/how-igfserializable-works.html">How
Serialization Works with IGeodeSerializable</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/implementing-igfserializable.html">Implement
the IGeodeSerializable Interface</a>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/registering-the-type.html">Register
the Type</a>
+ </li>
+ </ul>
+ </li>
+ <li>
+ <a
href="/docs/guide-native/<%=vars.product_version_nodot%>/serialization/dotnet-serialization/custom-class-igfserializable.html">Using
a Custom Class With IGeodeSerializable</a>
+ </li>
+ </ul>
+ </li>
+
+
+ </ul>
</li>
+
<li class="has_submenu">
<a
href="/docs/guide-native/<%=vars.product_version_nodot%>/transactions/transactions.html">Transactions</a>
<ul>
diff --git a/docs/geode-native-docs/about-client-users-guide.html.md.erb
b/docs/geode-native-docs/about-client-users-guide.html.md.erb
index 87db624..89db895 100644
--- a/docs/geode-native-docs/about-client-users-guide.html.md.erb
+++ b/docs/geode-native-docs/about-client-users-guide.html.md.erb
@@ -17,7 +17,7 @@ See the License for the specific language governing
permissions and
limitations under the License.
-->
-Published March 6, 2018
+Published July 17, 2018
This documentation describes the <%=vars.product_name_long%> Native Client.
diff --git a/docs/geode-native-docs/cpp-caching-api/cpp-caching-api.html.md.erb
b/docs/geode-native-docs/cpp-caching-api/cpp-caching-api.html.md.erb
index b3765bd..b3e7df1 100644
--- a/docs/geode-native-docs/cpp-caching-api/cpp-caching-api.html.md.erb
+++ b/docs/geode-native-docs/cpp-caching-api/cpp-caching-api.html.md.erb
@@ -49,7 +49,7 @@ Several example API programs are included in the `SampleCode`
directory. See [Qu
The standard `Region::remove` API removes the entry with the specified key
and provides a user-defined parameter object to any `CacheWriter` or
`CacheListener` invoked in the process.
-- **[Serializing Data](serialization-overview.html)**
+- **[Serializing
Data](../serialization/cpp-serialization/serialization-overview.html)**
All data moved out of the local cache must be serializable.
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 a7ccdd0..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?;
- };
-```
-
-## <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 _GEODE_LIBEXP
-#else
-#define TESTOBJECT_EXPORT _GEODE_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 _GEODE_LIBEXP
-#else
-#define TESTOBJECT_EXPORT _GEODE_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());
-```
-
-
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 648d0dc..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,
<%=vars.product_name%> 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 s [...]
-
-
diff --git a/docs/geode-native-docs/data-serialization.html.md.erb
b/docs/geode-native-docs/data-serialization.html.md.erb
deleted file mode 100644
index 10c4823..0000000
--- a/docs/geode-native-docs/data-serialization.html.md.erb
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Data 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.
--->
-
-All data moving out of the client cache must be serializable.
-
-Region data that must be serializable falls under the following categories:
-
-- 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,
<%=vars.product_name%> 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 s [...]
-
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
index 3a11b01..2047990 100644
--- a/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
@@ -61,7 +61,7 @@ This section describes the primary classes, usage
conventions, and C++ to .NET c
The standard `Region::Remove` API removes the entry with specified key and
provides a user-defined parameter object to any `CacheWriter` or
`CacheListener` invoked in the process.
-- **[Data Serialization](dotnet-data-serialization.html)**
+- **[Data
Serialization](../serialization/dotnet-serialization/dotnet-data-serialization.html)**
All data that <%=vars.product_name%> moves out of the local cache must be
serializable.
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
b/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
deleted file mode 100644
index 10c4823..0000000
---
a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: Data 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.
--->
-
-All data moving out of the client cache must be serializable.
-
-Region data that must be serializable falls under the following categories:
-
-- 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,
<%=vars.product_name%> 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 s [...]
-
diff --git a/docs/geode-native-docs/cpp-caching-api/data-as-blob.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/data-as-blob.html.md.erb
similarity index 100%
rename from docs/geode-native-docs/cpp-caching-api/data-as-blob.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/data-as-blob.html.md.erb
diff --git a/docs/geode-native-docs/cpp-caching-api/object-graphs.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/object-graphs.html.md.erb
similarity index 100%
rename from docs/geode-native-docs/cpp-caching-api/object-graphs.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/object-graphs.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/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/cpp-caching-api/pdx-ignore-unread-fields.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
diff --git
a/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/pdx-serialization.html.md.erb
similarity index 76%
rename from docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/pdx-serialization.html.md.erb
index aacb1fa..e39ab50 100644
--- a/docs/geode-native-docs/cpp-caching-api/pdx-serialization.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/pdx-serialization.html.md.erb
@@ -19,23 +19,22 @@ 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.
+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.
-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)**
+- **[Serialize Your Domain Objects with PdxSerializer and
PdxWrapper](using-pdxserializer.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.
+ 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)**
diff --git
a/docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/cpp-caching-api/pdx-with-delta-propagation.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
diff --git
a/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
similarity index 76%
rename from
docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
index 72dfbbf..56cb7fa 100644
---
a/docs/geode-native-docs/cpp-caching-api/pdxserializable-interface.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
@@ -19,9 +19,11 @@ 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 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` method.
+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.
@@ -32,22 +34,22 @@ Use this procedure to program your domain object for PDX
serialization using the
```
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.
-
- 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.
+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.
-## PdxSerializable Example
+## <a class="no-quick-link" id="pdx-serializable-example"></a>PdxSerializable
Example
``` pre
class PdxObject: public PdxSerializable {
diff --git
a/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
similarity index 95%
rename from
docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
index 42e0d9f..f9c8ec4 100644
---
a/docs/geode-native-docs/cpp-caching-api/performing-ops-with-pdx-object.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
@@ -21,7 +21,7 @@ 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).
+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:
diff --git
a/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-options.html.md.erb
similarity index 67%
rename from
docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/serialization-options.html.md.erb
index a642700..b0cc016 100644
--- a/docs/geode-native-docs/cpp-caching-api/serialization-options.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-options.html.md.erb
@@ -19,17 +19,28 @@ 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 <%=vars.product_name%> PDX
serialization.
+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 [...]
+<%=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 `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.
+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.
-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_696AB5206C3E45898CC1A24CDD93D00
[...]
+`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. See
[Serializing Data with the
+DataSerializable
+Interface](serialization-using-serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003)
for more
+information.
<a
id="concept_7B6F272ACEA14753A723CB73B858ADBE__table_D61A94C4BFBE4712835F632F30BB488E"></a>
@@ -43,7 +54,7 @@ The non-PDX serialization option is to use the
`apache::geode::client::Serializa
<thead>
<tr class="header">
<th>Capability</th>
-<th>Serializable</th>
+<th>DataSerializable</th>
<th>PdxSerializable</th>
</tr>
</thead>
diff --git
a/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-overview.html.md.erb
similarity index 63%
rename from
docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/serialization-overview.html.md.erb
index b55c568..86fa1fe 100644
--- a/docs/geode-native-docs/cpp-caching-api/serialization-overview.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-overview.html.md.erb
@@ -1,5 +1,5 @@
---
-title: Serializing Data
+title: Data Serialization – C++
---
<!--
@@ -21,21 +21,20 @@ 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 <%=vars.product_name%> PDX
serialization.
-- **[Serializing Data with PDX Serialization](pdx-serialization.html)**
+- **[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 register a
PdxSerializer for the entire cache, implement PDX serialization for each domain
object or use automatic PDX serialization by running the `pdxautoserializer`
tool.
+ 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 Serializable
Interface](serialization-using-serializable.html)**
+- **[Serializing Data with the DataSerializable
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
<%=vars.product_name%> serializable interface, and presents implementation
examples.
+ 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)**
diff --git
a/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
similarity index 68%
rename from
docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
index f9b12f6..5ba377d 100644
---
a/docs/geode-native-docs/cpp-caching-api/serialization-using-serializable.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
@@ -1,5 +1,5 @@
---
-title: Serializing Data with the Serializable Interface
+title: Serializing Data with the DataSerializable Interface
---
<!--
@@ -19,7 +19,15 @@ 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
<%=vars.product_name%> serializable interface, and presents implementation
examples.
+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
@@ -36,9 +44,11 @@ When your application subsequently receives a byte array,
<%=vars.product_name%>
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
+## <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 `Serializable` interface. In practical terms, this means that you need
to implement a small set of helper functions:
+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.
@@ -47,7 +57,6 @@ To store your own data types in the cache, you need to derive
a new subclass fro
```
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.
@@ -56,7 +65,9 @@ To store your own data types in the cache, you need to derive
a new subclass fro
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`.
+ 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
@@ -88,19 +99,19 @@ class BankAccount
};
```
-To make `BankAccount` serializable, you would need to derive the class from
`Serializable` and implement the following:
+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.
-- `classId`—a function to provide a unique integer for the class.
-- `TypeFactoryMethod`—a pointer to a function that returns a `Serializable*`
to an uninitialized instance of the type.
+- `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 Serializable Class
+## Example 2. Implementing a DataSerializable Class
This example shows a code sample that demonstrates how to implement a
serializable class.
``` pre
-class BankAccount : public Serializable
+class BankAccount : public DataSerializable
{
private:
int m_ownerId;
@@ -119,30 +130,25 @@ int getAccount( )
return m_accountId;
}
-// Add the following for the Serializable interface
+// Add the following for the DataSerializable interface
// Our TypeFactoryMethod
-static Serializable* createInstance( )
+static DataSerializable* createInstance( )
{
return new BankAccount( 0, 0 );
}
-int32_t classId( )
+int32_t getClassId( )
{
return 10; // must be unique per class.
}
-virtual size_t objectSize() const
-{
- return 10;
-}
-
void toData( DataOutput& output )
{
output.writeInt( m_ownerId );
output.writeInt( m_accountId );
}
-Serializable* fromData( DataInput& input )
+DataSerializable* fromData( DataInput& input )
{
input.readInt( &m_ownerId );
input.readInt( &m_accountId );
@@ -153,10 +159,12 @@ Serializable* fromData( DataInput& input )
## <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`.
+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 );
+DataSerializable::registerType( BankAccount::createInstance );
```
Typically, you would register the type before calling the function
`DistributedSystem::connect`.
@@ -166,17 +174,19 @@ 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.
+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:
+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
`Serializable`.
+- Change the class so that it derives from `CacheableKey` rather than
`DataSerializable`.
- Implement `operator==` and `hashcode` functions.
-## Example 3. Extending a Serializable Class To Be a CacheableKey
+## Example 3. Extending a DataSerializable Class To Be a CacheableKey
This example shows how to extend a serializable class to be a cacheable key.
@@ -202,7 +212,7 @@ int getAccount( )
}
// Our TypeFactoryMethod
-static Serializable* createInstance( )
+static DataSerializable* createInstance( )
{
return new BankAccount( 0, 0 );
}
@@ -218,7 +228,7 @@ void toData( DataOutput& output )
output.writeInt( m_accountId );
}
-Serializable* fromData( DataInput& input )
+DataSerializable* fromData( DataInput& input )
{
input.readInt( &m_ownerId );
input.readInt( &m_accountId );
@@ -252,5 +262,10 @@ virtual size_t objectSize() const
## <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 [...]
+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-caching-api/using-enum-type-with-pdx.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/cpp-caching-api/using-enum-type-with-pdx.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
diff --git
a/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/using-pdxinstance.html.md.erb
similarity index 91%
rename from docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/using-pdxinstance.html.md.erb
index 4153dc4..e152ee5 100644
--- a/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/using-pdxinstance.html.md.erb
@@ -23,11 +23,11 @@ A `PdxInstance` is a lightweight wrapper around the raw
bytes of the PDX seriali
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.
+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:
+The following is a code sample of using the `setField` API of `PdxInstance` to
modify fields:
``` pre
RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
diff --git
a/docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
diff --git
a/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
b/docs/geode-native-docs/serialization/cpp-serialization/using-pdxserializer.html.md.erb
similarity index 97%
rename from
docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
rename to
docs/geode-native-docs/serialization/cpp-serialization/using-pdxserializer.html.md.erb
index 7df9135..20afe61 100644
--- a/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
+++
b/docs/geode-native-docs/serialization/cpp-serialization/using-pdxserializer.html.md.erb
@@ -30,7 +30,7 @@ The `PdxSerializer` allows domain classes to be serialized
and deserialized as P
- 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 "de-allocator", which [...]
+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.
diff --git
a/docs/geode-native-docs/serialization/data-serialization.html.md.erb
b/docs/geode-native-docs/serialization/data-serialization.html.md.erb
new file mode 100644
index 0000000..3449af1
--- /dev/null
+++ b/docs/geode-native-docs/serialization/data-serialization.html.md.erb
@@ -0,0 +1,83 @@
+---
+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.
+-->
+
+Data in your client application's <%=vars.product_name%> cache must be
serializable to be shared with <%=vars.product_name%> servers and other
+<%=vars.product_name%> clients.
+<%=vars.product_name%> provides multiple data serialization options for
storage and transmittal
+between processes, of which **<%=vars.product_name%> Portable Data eXchange
(PDX) serialization** offers
+the best combination of versatility and ease-of-use for most applications.
+
+To learn more about other serialization options, see the subtopics in this
section describing serialization for the C++ and .NET APIs,
+[Data Serialization - C++](cpp-serialization/serialization-overview.html) and
+[Data Serialization -
.NET](dotnet-serialization/dotnet-data-serialization.html),
+and the [Data Serialization section in the _<%=vars.product_name_long%> User
Guide_](/serverman/developing/data_serialization/chapter_overview.html).
+
+# <a id="pdx-serialization" class="no-quick-link"></a>Using PDX Serialization
+
+<%=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](cpp-serialization/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](cpp-serialization/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](cpp-serialization/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](cpp-serialization/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](cpp-serialization/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](cpp-serialization/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](cpp-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](cpp-serialization/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/dotnet-caching-api/custom-class-igfserializable.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb
similarity index 96%
rename from
docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb
index a5f8cdb..1489566 100644
---
a/docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb
@@ -1,5 +1,5 @@
---
-title: Using a Custom Class With IGeodeSerializable
+title: Using a Custom Class With IDataSerializable
---
<!--
@@ -24,7 +24,7 @@ An example shows how to use the `BankAccount` custom key type
and the `AccountHi
## Using a BankAccount Object
``` pre
-class AccountHistory : IGeodeSerializable
+class AccountHistory : IDataSerializable
{
#region Private members
private List<string> m_history;
@@ -44,11 +44,11 @@ class AccountHistory : IGeodeSerializable
{
m_history.Add(entry);
}
- public static IGeodeSerializable CreateInstance()
+ public static IDataSerializable CreateInstance()
{
return new AccountHistory();
}
- #region IGeodeSerializable Members
+ #region IDataSerializable Members
public void FromData(DataInput input)
{
int len = input.ReadInt32();
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb
similarity index 97%
rename from
docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb
index 8326260..3c92503 100644
---
a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb
@@ -25,7 +25,7 @@ The options give good performance and flexibility for data
storage, transfers, a
The simplest option is to use perform automatic serialization by registering
the <%=vars.product_name%> .NET PDX reflection-based autoserializer in your
application. When you have this registered, <%=vars.product_name%> uses it for
all domain objects that are not custom serialized.
-You can also custom serialize your objects by implementing one of the
<%=vars.product_name%> .NET interfaces, `Apache.Geode.Client.IPdxSerializable`
or `Apache.Geode.Client.IGeodeSerializable`.
+You can also custom serialize your objects by implementing one of the
<%=vars.product_name%> .NET interfaces, `Apache.Geode.Client.IPdxSerializable`
or `Apache.Geode.Client.IDataSerializable`.
You also have the option of using default .NET serialization, but you cannot
use it unless you also use helper classes. The helper classes you must use are
`CacheableObject` and `CacheableObjectXml`.
@@ -43,7 +43,7 @@ You also have the option of using default .NET serialization,
but you cannot use
<thead>
<tr class="header">
<th>Capability</th>
-<th>IGeodeSerializable</th>
+<th>IDataSerializable</th>
<th>IPdxSerializable and PDX reflection-based autoserializer</th>
</tr>
</thead>
diff --git
a/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb
new file mode 100644
index 0000000..6e4de50
--- /dev/null
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb
@@ -0,0 +1,55 @@
+---
+title: Data Serialization – .NET
+---
+
+<!--
+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.
+
+
+ - <%=vars.product_name%> Portable Data eXchange (PDX) serialization
+ - `DataSerializable` interface serialization
+
+The `DataSerializable` interface can be a good option performance-wise if the
size of your objects
+is small, but do not as readily support code that executes on the server, such
as queries and functions.
+
+Each of these serialization methods provides two options:
+
+ - PDXSerializable / DataSerializable for objects under your control, that
is, objects you can modify to incorporate their own serialization and
deserialization code
+ - PDXSerializer / DataSerializer for objects not under your control, that
is, objects for which serialization and deserialization must be specified
separately from the objects themselves.
+
+For .NET, a reflection-based autoserialization option is also available, but
it is limited to cases in which the objects being serialized (a) contain no
transient state and (b) are composed only of primitive types.
+
+
+# .NET Data Serialization Options
+
+The .NET client API provides an option not available to the C++ API, as .NET
objects are capable of reflection.
+The recommended choice is iPDXSerializable.
+
+With reflection-based autoserialization, built-in .NET types are serialized
automatically into the
+cache and can be retrieved by <%=vars.product_name%> servers and other
<%=vars.product_name%> clients. For domain
+objects that are not simple types, you have three <%=vars.product_name%>
serialization options.
+
+ - The simplest option is to use automatic serialization by registering the
<%=vars.product_name%> .NET PDX
+reflection-based autoserializer in your application. When you have this
registered, <%=vars.product_name%> uses it
+for all domain objects that are not custom serialized.
+
+ - You can custom serialize your objects by implementing the
<%=vars.product_name%> `IDataSerializable` .NET interface.
+
+ - You also have the option of using default .NET serialization, but you
cannot use it unless you also
+use helper classes. The helper classes you must use are `CacheableObject` and
`CacheableObjectXml`.
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb
similarity index 95%
rename from
docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb
index 19c2112..3019187 100644
---
a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb
@@ -17,7 +17,7 @@ See the License for the specific language governing
permissions and
limitations under the License.
-->
-When you register the reflection-based serializer, <%=vars.product_name%> uses
it to serialize all objects that do not implement `IPdxSerializable` or
`IGeodeSerializable`. You can customize the auto-serialization behavior for
your domain objects by adding serialization attributes to your object’s fields.
+When you register the reflection-based serializer, <%=vars.product_name%> uses
it to serialize all objects that do not implement `IPdxSerializable` or
`IDataSerializable`. You can customize the auto-serialization behavior for your
domain objects by adding serialization attributes to your object’s fields.
**Procedure**
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html.md.erb
diff --git
a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb
similarity index 63%
rename from
docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb
index 30751b9..2818d86 100644
---
a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb
@@ -23,4 +23,13 @@ limitations under the License.
You have two options for <%=vars.product_name%> PDX serialization when using
the .NET caching API. You can program your domain objects using the
`IPdxSerializable` interface, or you can use <%=vars.product_name%>’s
reflection-based autoserializer.
-
+- [Geode PDX Serialization Features](dotnet-pdx-serialization-features.html)
+- [Serialize Using the Geode PDX
Autoserializer](dotnet-pdx-autoserializer.html)
+- [Extend the PDX Autoserializer](extending-pdx-autoserializer.html)
+- [Serialize Your Domain Objects with
IPdxSerializer](serializing-domain-objects.html)
+- [Serialize Using the IPdxSerializable
Interface](serialize-using-ipdxserializable.html)
+- [Program Your Application to Use IPdxInstance](programming-ipdxinstance.html)
+- [Use the IPdxInstanceFactory to Create
IPdxInstances](using-ipdxinstancefactory.html)
+- [Map .NET Domain Type Names to PDX Type Names with
IPdxTypeMapper](mapping-dotnet-domain-type-names.html)
+- [Data Serialization Options](dotnet-data-serialization-options.html)
+- [Serialize with PDX Serialization](dotnet-pdx-serialization.html)
diff --git
a/docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/extending-pdx-autoserializer.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/extending-pdx-autoserializer.html.md.erb
diff --git
a/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb
similarity index 96%
rename from
docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb
index d524eb8..5efba97 100644
---
a/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb
@@ -1,5 +1,5 @@
---
-title: How Serialization Works with IGeodeSerializable
+title: How Serialization Works with IDataSerializable
---
<!--
diff --git
a/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb
similarity index 90%
rename from
docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb
index 505955d..aa069c1 100644
---
a/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb
@@ -1,5 +1,5 @@
---
-title: Implement the IGeodeSerializable Interface
+title: Implement the IDataSerializable Interface
---
<!--
@@ -19,7 +19,7 @@ See the License for the specific language governing
permissions and
limitations under the License.
-->
-To store your own data types in the cache, you implement the
<%=vars.product_name%> `IGeodeSerializable` interface.
+To store your own data types in the cache, you implement the
<%=vars.product_name%> `IDataSerializable` interface.
Examples follow the procedure.
@@ -76,10 +76,10 @@ public class BankAccount
## Implementing a Serializable Class
-To make `BankAccount` serializable, you implement the `IGeodeSerializable`
interface as shown in this example:
+To make `BankAccount` serializable, you implement the `IDataSerializable`
interface as shown in this example:
``` pre
-public class BankAccount : IGeodeSerializable
+public class BankAccount : IDataSerializable
{
private int m_customerId;
private int m_accountId;
@@ -103,11 +103,11 @@ public class BankAccount : IGeodeSerializable
m_accountId = account;
}
// Our TypeFactoryMethod
- public static IGeodeSerializable CreateInstance()
+ public static IDataSerializable CreateInstance()
{
return new BankAccount(0, 0);
}
- #region IGeodeSerializable Members
+ #region IDataSerializable Members
public void ToData(DataOutput output)
{
output.WriteInt32(m_customerId);
diff --git
a/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb
similarity index 89%
rename from
docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb
index 7cf2707..c925faa 100644
---
a/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb
@@ -21,7 +21,7 @@ limitations under the License.
PDX serialized instances in Java map to .NET types with the same name. If you
need to adjust the .NET name, then you need to use the IPdxTypeMapper.
-See the [Java to .NET Type Mapping
Table](java-to-dotnet-type-mapping.html#concept_24D0AAC71FF1483AB47A7772DA018966)
for current mappings.
+See the [Java to .NET Type Mapping
Table](../../dotnet-caching-api/java-to-dotnet-type-mapping.html#concept_24D0AAC71FF1483AB47A7772DA018966)
for current mappings.
## Using IPdxTypeMapper
diff --git
a/docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/programming-ipdxinstance.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/programming-ipdxinstance.html.md.erb
diff --git
a/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/registering-the-type.html.md.erb
similarity index 94%
rename from
docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/registering-the-type.html.md.erb
index a42f725..846ce56 100644
--- a/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/registering-the-type.html.md.erb
@@ -41,4 +41,4 @@ If your application uses its own key types that are too
complex to easily force
See [Serialization in Native Client Mode with a Java
Server](../cpp-caching-api/serialization-using-serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274)
for information about implementing key types for a client that is used with a
Java cache server.
-To extend a type that implements `IPdxSerializable` or `IGeodeSerializable`
for your key, override and implement the `HashCode` and `Equals` methods in the
key as needed.
+To extend a type that implements `IPdxSerializable` or `IDataSerializable` for
your key, override and implement the `HashCode` and `Equals` methods in the key
as needed.
diff --git
a/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/serializable-types.html.md.erb
similarity index 80%
rename from
docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/serializable-types.html.md.erb
index 081d21d..f213da6 100644
--- a/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/serializable-types.html.md.erb
@@ -21,16 +21,16 @@ limitations under the License.
All built-in generics are automatically registered at initialization. You have
a couple of options for complex key types.
-If your application uses more complex key types that you want to make more
accessible or easier to handle, you can derive a new class from
`IGeodeSerializable`. Another option is for the application to do its own
object serialization using `Byte[]` or a custom type.
+If your application uses more complex key types that you want to make more
accessible or easier to handle, you can derive a new class from
`IDataSerializable`. Another option is for the application to do its own object
serialization using `Byte[]` or a custom type.
## <a
id="concept_5D520C87F65B48AFA4240615190B0150__section_DA3BCFFFCB974C65BEE953DF3FAA8442"
class="no-quick-link"></a>Blobs
-If you have data that is best handled as a blob, such as structs that do not
contain pointers, use a `Byte[]` or, if you need something more complex than
`Byte[]`, implement a custom type using either `IPdxSerializable` or
`IGeodeSerializable`.
+If you have data that is best handled as a blob, such as structs that do not
contain pointers, use a `Byte[]` or, if you need something more complex than
`Byte[]`, implement a custom type using either `IPdxSerializable` or
`IDataSerializable`.
## <a
id="concept_5D520C87F65B48AFA4240615190B0150__section_D49865F1CF5F467A9FFAD244D990F3F5"
class="no-quick-link"></a>Object Graphs
If you have a graph of objects in which each node can be serializable, the
parent node calls `DataOutput.WriteObject` to delegate the serialization
responsibility to its child nodes. Similarly, your application calls
`DataInput.ReadObject` to deserialize the object graph.
**Note:**
-The <%=vars.product_name%> `IGeodeSerializable` interface does not support
object graphs with multiple references to the same object. If your application
uses these types of circular graphs, you must address this design concern
explicitly.
+The <%=vars.product_name%> `IDataSerializable` interface does not support
object graphs with multiple references to the same object. If your application
uses these types of circular graphs, you must address this design concern
explicitly.
diff --git
a/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb
similarity index 79%
rename from
docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb
index a90a7b9..7f2bd8d 100644
---
a/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb
@@ -1,5 +1,5 @@
---
-title: Serialize with the IGeodeSerializable Interface
+title: Serialize with the IDataSerializable Interface
---
<!--
@@ -19,19 +19,19 @@ See the License for the specific language governing
permissions and
limitations under the License.
-->
-The .NET `IGeodeSerializable` interface provides fast and compact data
serialization.
+The .NET `IDataSerializable` interface provides fast and compact data
serialization.
- **[Generic and Custom Serializable Types](serializable-types.html)**
All built-in generics are automatically registered at initialization. You
have a couple of options for complex key types.
-- **[How Serialization Works with
IGeodeSerializable](how-igfserializable-works.html)**
+- **[How Serialization Works with
IDataSerializable](how-igfserializable-works.html)**
When your application puts an object into the cache for distribution,
<%=vars.product_name%> serializes the data by taking these steps.
-- **[Implement the IGeodeSerializable
Interface](implementing-igfserializable.html)**
+- **[Implement the IDataSerializable
Interface](implementing-igfserializable.html)**
- To store your own data types in the cache, you implement the
<%=vars.product_name%> `IGeodeSerializable` interface.
+ To store your own data types in the cache, you implement the
<%=vars.product_name%> `IDataSerializable` interface.
- **[Register the Type](registering-the-type.html)**
diff --git
a/docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/serialize-using-ipdxserializable.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/serialize-using-ipdxserializable.html.md.erb
diff --git
a/docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/serializing-domain-objects.html.md.erb
similarity index 100%
rename from
docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/serializing-domain-objects.html.md.erb
diff --git a/docs/geode-native-docs/serialization/dotnet-serialization/t.tmp
b/docs/geode-native-docs/serialization/dotnet-serialization/t.tmp
new file mode 100644
index 0000000..a2b297b
--- /dev/null
+++ b/docs/geode-native-docs/serialization/dotnet-serialization/t.tmp
@@ -0,0 +1,23 @@
+./
+../
+custom-class-igfserializable.html.md.erb
+dotnet-data-serialization-options.html.md.erb
+dotnet-data-serialization.html.md.erb
+dotnet-data-serialization.html.md.erb~
+dotnet-pdx-autoserializer.html.md.erb
+dotnet-pdx-serialization-features.html.md.erb
+dotnet-pdx-serialization.html.md.erb
+extending-pdx-autoserializer.html.md.erb
+how-igfserializable-works.html.md.erb
+implementing-igfserializable.html.md.erb
+mapping-dotnet-domain-type-names.html.md.erb
+mapping-dotnet-domain-type-names.html.md.erb~
+programming-ipdxinstance.html.md.erb
+registering-the-type.html.md.erb
+serializable-types.html.md.erb
+serialize-using-igfserializable.html.md.erb
+serialize-using-ipdxserializable.html.md.erb
+serializing-domain-objects.html.md.erb
+t.tmp
+using-ipdxinstancefactory.html.md.erb
+using-ipdxinstancefactory.html.md.erb~
diff --git
a/docs/geode-native-docs/dotnet-caching-api/using-ipdxinstancefactory.html.md.erb
b/docs/geode-native-docs/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb
similarity index 96%
rename from
docs/geode-native-docs/dotnet-caching-api/using-ipdxinstancefactory.html.md.erb
rename to
docs/geode-native-docs/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb
index bd46115..6534090 100644
---
a/docs/geode-native-docs/dotnet-caching-api/using-ipdxinstancefactory.html.md.erb
+++
b/docs/geode-native-docs/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb
@@ -23,5 +23,4 @@ You can use the `IPdxInstanceFactory` to create an
`IPdxInstance` from raw data
This option can be useful when you need an instance of a domain class for
plug-in code such as a function or a loader. If you have the raw data for the
domain object (the class name and each field's type and data), then you can
explicitly create a `IPdxInstance`. The `IPdxInstanceFactory` is very similar
to the `IPdxWriter` except that after writing each field, you need to call the
create method which returns the created `IPdxInstance.`
-View the PdxInstance QuickStart for an example.
diff --git a/docs/geode-native-docs/transactions.html.md.erb
b/docs/geode-native-docs/transactions.html.md.erb
deleted file mode 100644
index 67471d7..0000000
--- a/docs/geode-native-docs/transactions.html.md.erb
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: Transactions
----
-
-<!--
-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 page is a placeholder - it needs further expansion.
