You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by km...@apache.org on 2016/10/12 17:12:18 UTC
[58/76] [abbrv] incubator-geode git commit: GEODE-1952: removed
native client docs,
set aside until native client code is merged in (see GEODE-1964)
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/pdx_auto_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/pdx_auto_serialization.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/pdx_auto_serialization.html.md.erb
deleted file mode 100644
index 0bdda28..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/pdx_auto_serialization.html.md.erb
+++ /dev/null
@@ -1,355 +0,0 @@
----
-title: Using Automatic PDX Serialization
----
-
-You can allow your native client C++ applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the `pdxautoserializer` command line tool provided with the native client.
-
-When using the native client C++ 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 Geode native client includes a command-line utility, `pdxautoserializer`, that 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
-
-**Prerequisites:**
-
-- Understand generally how to configure the Geode cache.
-
-- Understand how PDX serialization works and how to configure your application to use PdxSerializer.
-
-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 `gemfire::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(gemfire::PdxWriterPtr pw);
- virtual void fromData(gemfire::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 <gfcpp/PdxWriter.hpp>
-#include <gfcpp/PdxReader.hpp>
-#include <gfcpp/PdxAutoSerializer.hpp>
-namespace testobject
-{
- void PortfolioPdx::toData(gemfire::PdxWriterPtr var)
- {
- gemfire::PdxAutoSerializable::writePdxObject(var, "id", id);
- gemfire::PdxAutoSerializable::writePdxObject(var, "pkid", pkid);
- gemfire::PdxAutoSerializable::writePdxObject(var, "position1", position1);
- gemfire::PdxAutoSerializable::writePdxObject(var, "position2", position2);
- gemfire::PdxAutoSerializable::writePdxObject(var, "positions", positions);
- gemfire::PdxAutoSerializable::writePdxObject(var, "status", status);
- gemfire::PdxAutoSerializable::writePdxObject(var, "creationDate", creationDate);
- }
-
- void PortfolioPdx::fromData(PdxReaderPtr var)
- {
- gemfire::PdxAutoSerializable::readPdxObject(var, "id", id);
- gemfire::PdxAutoSerializable::readPdxObject(var, "pkid", pkid);
- gemfire::PdxAutoSerializable::readPdxObject(var, "position1", position1);
- gemfire::PdxAutoSerializable::readPdxObject(var, "position2", position2);
- gemfire::PdxAutoSerializable::readPdxObject(var, "positions", positions);
- gemfire::PdxAutoSerializable::readPdxObject(var, "status", status);
- gemfire::PdxAutoSerializable::readPdxObject(var, "creationDate", creationDate);
- }
-
- const char* PortfolioPdx::getClassName() const
- {
- return "PortfolioPdx";
- }
-}
-```
-
-## <a id="task_fs4_vkj_2l" class="no-quick-link"></a>Handling Arrays
-
-1. Define the following macro in your header file:
-
- ``` pre
- #define GFARRAYSIZE(x)
- ```
-
-2. Assuming that the following is the class member of type array:
-
- ``` pre
- int8_t* newVal;
- ```
-
- Then define a new variable which sets the length of the array:
-
- ``` pre
- int32_t newValSize;
- ```
-
-3. Tag the new variable with the `GFARRAYSIZE` macro as follows:
-
- ``` pre
- GFARRAYSIZE(newVal) int32_t newValSize;
- ```
-
-## Using a Single Variable as Length for Multiple Arrays
-
-You can use the GFARRAYSIZES to have single length for multiple arrays.
-
-Define the GFARRAYSIZES macro as follows:
-
-``` pre
-#define GFARRAYSIZES(x)
-```
-
-The following is an example usage:
-
-``` pre
-class ArrayOfSizes?
- {
- public:
- int32_t* array1;
- int32_t* array2;
- int32_t* array3;
- int32_t* array4;
- int32_t* array5;
-
- GFARRAYSIZE(array1) int32_t singleSize;
- GFARRAYSIZES("array2,array3,array4,array5") int32_t SingleSizeToMultipleArrays?;
- };\u200b
-```
-
-## <a id="task_hph_mrw_dl" class="no-quick-link"></a>Excluding Member Variables from Serialization
-
-1. Define the following macro in your header file:
-
- ``` pre
- #define GFEXCLUDE
- ```
-
-2. Tag your member variable with this macro:
-
- ``` pre
- GFEXCLUDE char* type;
- ```
-
-## <a id="task_en2_4rw_dl" class="no-quick-link"></a>Marking Identity Fields
-
-Identity fields are used when comparing objects using the `hashCode` and `equals` methods.
-
-1. Define the following macro in your header file.
-
- ``` pre
- #define GFID(x)
- ```
-
-2. Assuming that the following is the class member you want to use as IdentityField:
-
- ``` pre
- int8_t* newVal;
- ```
-
- Tag the member with the GFID macro as follows:
-
- ``` pre
- GFID(newVal)int8_t* newVal;
- ```
-
-## Ignoring User Defined Keywords
-
-You might have certain user defined keywords after the class name. Current C++ grammar does not support this. If you have some keywords user will have to ignore them by using the `GFIGNORE` macro.
-
-For example, consider the following class definition:
-
-``` pre
-#ifdef _WIN32
-#ifdef BUILD_TESTOBJECT
-#define TESTOBJECT_EXPORT LIBEXP
-#else
-#define TESTOBJECT_EXPORT LIBIMP
-#endif
-#else
-#define TESTOBJECT_EXPORT
-#endif
-
-namespace PdxAutoTests {
- class TESTOBJECT_EXPORT PdxAutoMegaType : public PdxSerializable {
- }
-```
-
-Currently, the `pdxautoserializer` tool will fail to recognize `TESTOBJECT_EXPORT`. Change your class by adding the `GFIGNORE` macro as follows:
-
-``` pre
-#ifdef _WIN32
-#ifdef BUILD_TESTOBJECT
-#define TESTOBJECT_EXPORT LIBEXP
-#else
-#define TESTOBJECT_EXPORT LIBIMP
-#endif
-#else
-#define TESTOBJECT_EXPORT
-#endif
-
-using namespace gemfire;
-
-#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 `$GFCPP/bin` where `$GFCPP` corresponds to the installation location of the native 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 GemFire Cache with the "clientPdxRemoteQuery.xml" Cache XML file.
- CachePtr cachePtr = cacheFactory->set("cache-xml-file", "XMLs\\clientPdxRemoteQuery.xml")
- ->create();
-
- LOGINFO("Created the Cache");
-
- // Get the example Region from the Cache which is declared in the Cache XML file.
- RegionPtr regionPtr = cachePtr->getRegion( "Portfolios");
-
- LOGINFO( "Obtained the Region from the Cache");
-
- // Register our Serializable/Cacheable Query objects, viz. PortfolioPdx and PositionPdx.
- Serializable::registerPdxType(PortfolioPdx::createDeserializable);
- PortfolioPdxPtr port1Ptr(new PortfolioPdx(1 /*ID*/, 10 /*size*/));
- PortfolioPdxPtr port2Ptr(new PortfolioPdx(2 /*ID*/, 20 /*size*/));
- PortfolioPdxPtr port3Ptr(new PortfolioPdx(3 /*ID*/, 30 /*size*/));
- regionPtr->put("Key1", port1Ptr);
- regionPtr->put("Key2", port2Ptr);
- regionPtr->put("Key3", port3Ptr);
-
- // Get the QueryService from the Cache.
- QueryServicePtr qrySvcPtr = cachePtr->getQueryService( "examplePool");
-
- LOGINFO( "Got the QueryService from the Cache");
-
- // Execute a Query which returns a ResultSet.
- QueryPtr qryPtr = qrySvcPtr->newQuery("SELECT DISTINCT * FROM /Portfolios");
- SelectResultsPtr resultsPtr = qryPtr->execute();
-
- LOGINFO( "ResultSet Query returned %d rows", resultsPtr->size());
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb
deleted file mode 100644
index 07093d1..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/pdx_ignore_unread_fields.html.md.erb
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Configuring PDX to Ignore Unread Fields During Deserialization
----
-
-Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
-The default is to preserve unread fields by including their data during serialization. However, if you configure the cache to ignore unread fields then their data will be lost during serialization.
-
-You should only set this attribute to `true` if you know this member will only be reading cache data. In this use case you do not need to pay the cost of preserving unread fields since you will never reserialize the PDX data.
-
-For example:
-
-``` pre
-CacheFactoryPtr cfPtr = CacheFactory::createCacheFactory(PropertiesObj);
-cfPtr->setPdxReadSerialized(tue);
-cfPtr->setPdxIgnoreUnreadFields(false);
-cachePtr = cfPtr->create();
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/pdx_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/pdx_serialization.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/pdx_serialization.html.md.erb
deleted file mode 100644
index 4e1c1d2..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/pdx_serialization.html.md.erb
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Serializing Data with PDX Serialization
----
-
-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 native client C++ API, you can register a `PdxSerializer` for the entire cache, implement PDX serialization for each domain object or use automatic PDX serialization by running the `pdxautoserializer` tool.
-
-You can also set the object preference of the cache to the `PdxInstance` type, which allows you to access fields of a PDX object without deserializing the entire object.
-
-When using the native client C++ API, you can opt to use PDX autoserialization. The Geode native client provides a command line tool called `pdxautoserializer` that will automatically generate C++ code to PDX serialize the class you want to serialize.
-
-- **[Serialize Your Domain Objects with PdxSerializer and PdxWrapper](../../nativeclient/cpp-caching-api/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](../../nativeclient/cpp-caching-api/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](../../nativeclient/cpp-caching-api/pdx_auto_serialization.html)**
-
- You can allow your native client C++ applications to automatically PDX serialize and deserialize domain objects without having to add any extra code by using the `pdxautoserializer` command line tool provided with the native client.
-
-- **[Programming Your Application to Use PdxInstances](../../nativeclient/cpp-caching-api/using_pdxinstance.html)**
-
- A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. Geode provides the implementation of the `PdxInstance` class.
-
-- **[Configuring PDX to Ignore Unread Fields During Deserialization](../../nativeclient/cpp-caching-api/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](../../nativeclient/cpp-caching-api/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](../../nativeclient/cpp-caching-api/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](../../nativeclient/cpp-caching-api/pdx_with_delta_propagation.html)**
-
- To use delta propagation with PDX serialization, you must implement the `Delta` interface methods.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/pdx_with_delta_propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/pdx_with_delta_propagation.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/pdx_with_delta_propagation.html.md.erb
deleted file mode 100644
index 492840c..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/pdx_with_delta_propagation.html.md.erb
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: Using PDX Serialization with Delta Propagation
----
-
-<a id="concept_F33AC930A8F14F0A9EE07AC31FFD8C8F__section_6C08121D7A034993A7422985FBC9A0D9"></a>
-You can include delta propagation support with PDX serialization by implementing the `Delta` interface methods.
-However, using delta propagation with PDX will requires that you implement Java side classes. The objects will remain in deserialized form at all times on the server and you will lose one of the main benefits of PDX.
-
-In addition, you must set `read-serialized` to `false`. Otherwise, Java objects will be deserialized to instances of `PdxInstance`, which never implements deltas.
-
-The following code snippet is a sample implementation of the Delta interface methods for using with PDX serialization.
-
-``` pre
-class PdxWithDelta : public PdxSerializable, public Delta
-{
-public:
-
- bool hasDelta();
- void toDelta(DataOutput& output);
- void fromDelta(DataInput& input);
- DeltaPtr clone();
-
-// other PdxSerializable methods here...
-
-};
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/pdxserializable_interface.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/pdxserializable_interface.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/pdxserializable_interface.html.md.erb
deleted file mode 100644
index b51ce39..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/pdxserializable_interface.html.md.erb
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: Serialize Using the PdxSerializable Class
----
-
-Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-
-When you run queries against the objects on the servers, only the fields you specify are deserialized. A domain class should serialize and de-serialize all its member fields in the same order in its `toData` and `fromData` method.
-
-Use this procedure to program your domain object for PDX serialization using the `PdxSerializable` abstract class.
-
-1. In your domain class, implement `PdxSerializable`. Example:
-
- ``` pre
- class PdxObject: public PdxSerializable
- ```
-
-2. Program the `toData` function to serialize your object as required by your application.
-
- If you also use PDX serialization in Java or .NET for the object, serialize the object in the same way for each language. Serialize the same fields in the same order and mark the same identity fields.
-
-3. Program the `fromData` method to read your data fields from the serialized form into the object's fields.
-
- In your `fromData` implementation, use the same name as you did in `toData` and call the read operations in the same order as you called the write operations in your `toData` implementation.
-
-4. Optionally, program your domain object's hashCode and equality methods.
-
- Use the `markIdentityField` method to indicate that the given field name should be included in hashCode and equality checks of this object on a server.
-
- The fields that are marked as identity fields are used to generate the hashCode and equality methods of PdxInstance. Because of this, the identity fields should themselves either be primitives, or implement hashCode and equals.
-
- If no fields are set as identity fields, then all fields will be used in hashCode and equality checks. The identity fields should make marked after they are written using a `write`\* method.
-
-## PdxSerializable Example
-
-``` pre
-class PdxObject: public PdxSerializable {
-
-private:
- uint32_t m_id;
- char* m_str;
-
-public:
- PdxObject(){};
- PdxObject(uint32_t id, char* str);
- virtual ~PdxObject();
-
- uint32_t getID() {
- return m_id;
- }
-
- char* getStr(){
- return m_str;
- }
-
- virtual void toData(PdxWriterPtr pw) const;
- virtual void fromData(PdxReaderPtr pr);
- CacheableStringPtr toString() const;
- virtual char* getClassName() const;
- static Cacheable* createDeserializable() {
- return new PdxObject();
- }
-};
-
-PdxObject::PdxObject(uint32_t i, char* str) {
- m_id = i;
- m_str = str;
-}
-
-PdxObject::~PdxObject() {
-}
-
-void PdxObject::toData( PdxWriterPtr pw ) const {
- pw->writeInt("id", m_id);
- pw->markIdentityField("id");
- pw->writeString("str", m_str);
-}
-
-void PdxObject::fromData( PdxReaderPtr pr )
-{
- m_id = pr->readInt("id");
- m_str = pr->readString("str");
-}
-
-char* getClassName() const{
-{
- return "com.example.PdxType";
-}
-
-CacheableStringPtr PdxObject::toString() const {
- char idbuf[1024];
- sprintf(idbuf,"PdxObject: [ ID=%d ]",m_id);
- return CacheableString::create( idbuf );
-}
-```
-
-- **[Performing put, get, and localDestroy Operations with a PDX Domain Object](../../nativeclient/cpp-caching-api/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.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb
deleted file mode 100644
index 50ed34a..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/performing_ops_with_pdx_object.html.md.erb
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Performing put, get, and localDestroy Operations with a PDX Domain Object
----
-
-This topic demonstrates how you can perform operations on a PDX domain object after you have implemented PDX serializable in your domain class.
-
-For example, you can perform operations like put, get, and localDestroy with the domain class you defined for PDX serialization in the [PdxSerializable Example](pdxserializable_interface.html#concept_79E4C10E5F634A7F84F96633694B3D69__example_70237026967A42898584AE644D437E69).
-
-To perform operations, you could write the following application code:
-
-1. Register the PDX domain class.
-
- ``` pre
- Serializable::registerPdxType(PdxObject::createDeserializable);
- ```
-
-2. Create the PDX domain object `PdxObject`.
-
- ``` pre
- CacheablePtr pdxobj(new PdxObject(100, "Value-1"));
- CacheableKeyPtr keyport = CacheableKey::create("ABC");
- ```
-
-3. Here's an example of a put operation.
-
- ``` pre
- rptr->put(keyport, pdxobj);
- ```
-
-4. Here's an example of locally destroying the entry.
-
- ``` pre
- rptr->localDestroy(keyport);
- ```
-
-5. Here's an example of a get operation.
-
- ``` pre
- PdxObject *obj2 = dynamic_cast<PdxObject *> ((rptr->get(keyport)).ptr());
- LOGINFO("Debug:Returned ID = %d", obj2->getID());
- ```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/region_data_requiring_serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/region_data_requiring_serialization.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/region_data_requiring_serialization.html.md.erb
deleted file mode 100644
index 13ee10b..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/region_data_requiring_serialization.html.md.erb
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Region Data Requiring Serialization
----
-
-Certain region types (including client regions) require serialization.
-
-Region data in the following types of regions must be serializable:
-
-- Partitioned regions (except functions that add data locally to a partitioned region use the deserialized form).
-- Distributed regions.
-- Regions that are persisted or overflowed to disk.
-- Server or client regions in a client/server installation.
-- Regions distributed between gateways in a multi-site installation.
-- Regions that receive events from remote caches.
-- Regions that provide function arguments and results.
-
-To minimize the cost of serialization and deserialization, Geode avoids changing the data format whenever possible. This means your data may be stored in the cache in serialized or deserialized form, depending on how you use it. For example, if a server acts only as a storage location for data distribution between clients, it makes sense to leave the data in serialized form, ready to be transmitted to clients that request it. Partitioned region data is always stored in serialized form with one exception\u2014functions that add data to a partitioned region locally use the deserialized form.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/removing-entry.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/removing-entry.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/removing-entry.html.md.erb
deleted file mode 100644
index d661f40..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/removing-entry.html.md.erb
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Removing an Entry
----
-
-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.
-
-The `remove` call not only removes the value, but also the key and entry from this region. The remove operation is propagated to the Geode cache server to which the native client is connected. If the destroy operation fails due to an exception on the server (for example, a `CacheServerException` or security exception), then the local entry is still removed.
-
-The `remove` operation updates `CacheStatistics::getLastAccessedTime` and `CacheStatistics::getLastModifiedTime` for this region and the entry.
-
-The `remove` API returns true if the entry (key, value) has been removed or false if the entry (key, value) has not been removed.
-
-## Bulk Remove Operations Using removeAll
-
-You can use the `Region::removeAll` API to remove all entries from the region for a collection of specified keys. The effect of this call is equivalent to that of calling `destroy` on this region once for each key in the specified collection. If an entry does not exist, then that key is skipped. Note that an `EntryNotFoundException` is not thrown.
-
-The `removeAll` API also supports providing a callback argument to any cache loaders or cache writers that are invoked in the operation. See the Region API documentation for more information about using `removeAll`.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/serialization_options.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/serialization_options.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/serialization_options.html.md.erb
deleted file mode 100644
index 386737a..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/serialization_options.html.md.erb
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: Data Serialization Options
----
-
-The native client C++ API gives you two serialization options: the `GemFire::Serializable` interface and GemFire PDX serialization.
-
-Geode Portable Data eXchange (PDX) serialization is the recommended option. PDX serialization provides portability for PDX serializable objects so that clients can share data with Java servers and other non-C++ clients. PDX is a cross-language data format that can reduce the cost of distributing and serializing your objects. PDX stores data in named fields that you can access individually in order to avoid the cost of deserializing the entire data object. PDX also allows you to mix versions of objects where you have added or removed fields.
-
-When using PDX serialization, you can use either `PdxSerializer` (for all your domain objects) or `PdxSerializable` (for a specific domain object).
-
-`PdxSerializer` is used when a user has registered a domain class for serialization in the cache using the `registerPdxSerializer` API.
-
-`PdxSerializable` is used when the domain class that a user wants to serialize/deserialize is inherited from the `PdxSerializable` interface, and the user has registered the domain class using the `registerPdxType(domainClass)` API.
-
-The non-PDX serialization option is to use the `GemFire::Serializable` interface. The `GemFire::Serializable` interface can be a good option performance-wise if the size of your objects is small. The `GemFire::Serializable` is used whenever a user domain class is not inherited by `PdxSerializable` but the user has registered his or her class with the `registerType` API. See [Serializing Data with the Serializable Interface](serialization_using_serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003) for more information.
-
-<a id="concept_7B6F272ACEA14753A723CB73B858ADBE__table_D61A94C4BFBE4712835F632F30BB488E"></a>
-
-<table>
-<caption><span class="tablecap">Table 1. Serialization Options\u2014Comparison of Features</span></caption>
-<colgroup>
-<col width="50%" />
-<col width="25%" />
-<col width="25%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Capability</th>
-<th>GemFire::Serializable</th>
-<th>GemFire::PdxSerializable</th>
-</tr>
-</thead>
-<tbody>
-<tr class="odd">
-<td><p>Handles multiple versions of domain objects*</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Provides single field access on servers of serialized data, without full deserialization. Supported also for OQL queries.</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="odd">
-<td><p>Automatically ported to other languages by Geode - no need to program Java-side implementation</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Works with GemFire delta propagation</p></td>
-<td>X</td>
-<td>X**</td>
-</tr>
-</tbody>
-</table>
-
-<span class="tablecap">**Table 1.** Serialization Options\u2014Comparison of Features</span>
-
-\* You can mix domain object versions where the differences between versions are the addition and removal of object fields.
-
-\*\* See [Using PDX Serialization with Delta Propagation](pdx_with_delta_propagation.html#concept_F33AC930A8F14F0A9EE07AC31FFD8C8F) for requirements.
-
-For detailed information on the interfaces, see the API documentation.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/serialization_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/serialization_overview.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/serialization_overview.html.md.erb
deleted file mode 100644
index 026136e..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/serialization_overview.html.md.erb
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Serializing Data
----
-
-All data that Geode moves out of the local cache must be serializable.
-
-- **[Region Data Requiring Serialization](../../nativeclient/cpp-caching-api/region_data_requiring_serialization.html)**
-
- Certain region types (including client regions) require serialization.
-
-- **[Data Serialization Options](../../nativeclient/cpp-caching-api/serialization_options.html)**
-
- The native client C++ API gives you two serialization options: the `GemFire::Serializable` interface and GemFire PDX serialization.
-
-- **[Serializing Data with PDX Serialization](../../nativeclient/cpp-caching-api/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 the native client C++ 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.
-
-- **[Serializing Data with the Serializable Interface](../../nativeclient/cpp-caching-api/serialization_using_serializable.html)**
-
- The native client C++ API provides a `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable interface, and presents implementation examples.
-
-- **[Serializing Object Graphs](../../nativeclient/cpp-caching-api/object-graphs.html)**
-
- If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
-
-- **[Serializing and Accessing Data as a Blob](../../nativeclient/cpp-caching-api/data-as-blob.html)**
-
- If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/serialization_using_serializable.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/serialization_using_serializable.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/serialization_using_serializable.html.md.erb
deleted file mode 100644
index 9993596..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/serialization_using_serializable.html.md.erb
+++ /dev/null
@@ -1,246 +0,0 @@
----
-title: Serializing Data with the Serializable Interface
----
-
-The native client C++ API provides a `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable interface, and presents implementation examples.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_8143F965A8C6495E8AB104FD36DA366A" class="no-quick-link"></a>How Serialization Works
-
-When your application puts an object into the cache for subsequent distribution, Geode serializes the data by taking these steps:
-
-1. Calls the appropriate `classId` function.
-2. Writes the full `typeId` using the `classId` for the instance.
-3. Invokes the instance\u2019s `toData` function.
-
-When your application subsequently receives a byte array, Geode takes the following steps:
-
-1. Decodes the `typeId`, extracts the `classId` from the `typeId`, then creates an object of the designated type using the registered factory functions.
-
-2. Invokes the `fromData` function with input from the data stream.
-3. Decodes the data, then populates the data fields.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_786CF85FD80E4FE391135460E04D46CC" class="no-quick-link"></a>Implementing the Serializable Interface
-
-To store your own data types in the cache, you need to derive a new subclass from the `Serializable` interface. In practical terms, this means that you need to implement a small set of helper functions:
-
-1. Write a `toData` function that serializes your data.
-
- ``` pre
- void toData (DataOutput& output)
- ```
-
- The `toData` function is responsible for copying all of the object\u2019s data fields to the object stream.
-
- The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order. For more about this, see the API documentation for `DataOutput` .
-
- The `toData` function is responsible for copying all of the object\u2019s data fields to the object stream.
-
- The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order. For more about this, see the API documentation for `DataOutput` .
-
-2. Write a `fromData` function that consumes a data input stream and repopulates the object\u2019s data fields.
-
- ``` pre
- void fromData (DataInput& input)
- ```
-
- The `DataInput` class represents the input stream and provides methods for reading input elements. The `fromData` function must read the elements of the input stream in the same order that they were written by `toData` . For more about this, see the API documentation for `DataInput`.
-
-## Example 1. The Simple Class BankAccount
-
-This example demonstrates a simple `BankAccount` class that encapsulates two `ints`: `ownerId` and `accountId`:
-
-``` pre
-class BankAccount
-{
- private:
-�
- int m_ownerId;
- int m_accountId;
-�
- public:
-�
- BankAccount( int owner, int account ): m_ownerId( owner ),
- m_accountId( account ) {}
-�
- int getOwner( )
- {
- return m_ownerId;
- }
-�
- int getAccount( )
- {
- return m_accountId;
- }
-�
-};
-```
-
-To make `BankAccount` serializable, you would need to derive the class from `Serializable` and implement the following:
-
-- `toData`\u2014a function to serialize the data.
-- `fromData`\u2014a function to deserialize the data.
-- `classId`\u2014a function to provide a unique integer for the class.
-- `TypeFactoryMethod`\u2014a pointer to a function that returns a `Serializable*` to an uninitialized instance of the type.
-
-## Example 2. Implementing a Serializable Class
-
-This example shows a code sample that demonstrates how to implement a serializable class.
-
-``` pre
-class BankAccount : public Serializable
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Add the following for the Serializable interface
-// Our TypeFactoryMethod
-static Serializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t classId( )
-{
- return 10; // must be unique per class.
-}
-
-virtual uint32_t objectSize() const
-{
- return 10;
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-Serializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_108942E549CE4DE68FF3956712DEC7AF" class="no-quick-link"></a>Registering the Type
-
-To be able to use the `BankAccount` type, you must register it with the type system so that when an incoming stream contains a `BankAccount` , it can be manufactured from the associated `TypeFactoryMethod`.
-
-``` pre
-Serializable::registerType( BankAccount::createInstance );
-```
-
-Typically, you would register the type before calling the function `DistributedSystem::connect`.
-
-**Note:**
-Type IDs must be unique to only one class.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_311C3661023C46328B406F26F4F16808" class="no-quick-link"></a>Custom Key Types
-
-If your application uses key types that are too complex to easily force into `CacheableString`, you can likely improve performance by deriving a new class from `CacheableKey`. If you have hybrid data types you can implement your own derivation of `CacheableKey` that encapsulates the data type.
-
-See [Serialization in Native Client Mode with a Java Server](serialization_using_serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274) for information about implementing key types for a native client that is used with a Java cache server.
-
-To extend a `Serializable` class to be a `CacheableKey`, you need to modify the class definition as follows:
-
-- Change the class so that it derives from `CacheableKey` rather than `Serializable`.
-
-- Implement `operator==` and `hashcode` functions.
-
-The next example demonstrates how to extend a `serializable` class to be a cacheable key.
-
-## Example 3. Extending a Serializable Class To Be a CacheableKey
-
-This example shows how to extend a serializable class to be a cacheable key.
-
-``` pre
-class BankAccount
-: public CacheableKey
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Our TypeFactoryMethod
-static Serializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t typeId( )
-{
- return 1000; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-Serializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-
-// Add the following for the CacheableKey interface
-bool operator == ( const CacheableKey& other ) const
-{
- const BankAccount& otherBA =
- static_cast<const BankAccount&>( other );
- return (m_ownerId == otherBA.m_ownerId) && (m_accountId == otherBA.m_accountId);
-}
-
-uint32_t hashcode( ) const
-{
- return m_ownerId;
-}
-
-virtual int32_t classId( )const
-{
- return 10; // must be unique per class.
-}
-�
-virtual uint32_t objectSize() const
-{
- return 10;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274" class="no-quick-link"></a>Serialization in Native Client Mode with a Java Server
-
-Primitive object types supported in all languages (`CacheableInt32`, `CacheableString`, `CacheableBytes`) function without requiring custom definitions with the Java cache server. For the keys, the Java cache server has to deserialize them and locate the hashcode to be able to insert the internal maps. Because of this, key types for C++ and .NET native 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. The Java serializable type should have the same `classId` as the .NET class, and it should serialize and deserialize the type in the same manner as the .NET implementation.
-
-See [Data Serialization](../dotnet-caching-api/dotnet-data-serialization.html#concept_28A7797A0342447ABF6A5014E0DCB05F) for more information about .NET data serialization.
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/type_interoperability.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/type_interoperability.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/type_interoperability.html.md.erb
deleted file mode 100644
index 135f81c..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/type_interoperability.html.md.erb
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Interoperability of C++ Types When Using PDX Serialization
----
-
-This topic table lists the mapping between C++ types and other language types when using PDX serialization.
-
-In addition, the table lists which PdxReader and PdxWriter C++ APIs to use when serializing and deserializing the types.
-
-| C++ Type | .NET Type | Java Type | PdxReader/PdxWriter API |
-|-----------------------------------|------------------------------------------------------------------|-------------------------|----------------------------------------------|
-| CacheableHashTable | System::Collections::Hashtable | java.util.Hashtable | readObject/writeObject |
-| CacheableHashMap | System::Collections ::Generic::IDictionary<Object, Object> | java.util.HashMap | readObject/writeObject |
-| CacheableVector | System::Collections::ArrayList | java.util.Vector | readObject/writeObject |
-| CacheableArrayList | System::Collections::�Generic::IList<Object> | java.util.ArrayList | readObject/writeObject |
-| bool | bool | boolean | readBoolean/writeBoolean |
-| int8\_t | sbyte | Byte | readByte/writeByte |
-| wchar\_t/char<sup>1</sup> | Char | Char | readChar/writeChar |
-| wchar\_t\*/char\*<sup>1</sup> | string | string | readString/writeString |
-| double | Double | double | readDouble/writeDouble |
-| float | float | float | readFloat/writeFloat |
-| int16\_t | short | short | readShort/writeShort |
-| int32\_t | Int32/int | int | readInt/writeInt |
-| int64\_t | Int64/long | long | readLong/writeLong |
-| int8\_t\* | System.Byte\[ \]/System.SByte\[ \] | Byte\[ \]<sup>2</sup> | readByteArray/writeByteArray |
-| double\* | System.Double\[ \] | Double\[ \] | readDoubleArray/writeDoubleArray |
-| float\* | System.float\[ \] | Float\[ \] | readFloatArray/writeFloatArray |
-| CacheableHashSet | CacheableHashSet | java.util.HashSet | readObject/writeObject |
-| CacheableLinkedHashSet | CacheableLinkedHashSet | java.util.LinkedHashSet | readObject/writeObject |
-| int16\_t\* | System.Int16\[ \] | Short\[ \] | readShortArray/writeShortArray |
-| int32\_t\* | System.Int32\[ \] | Int\[ \] | readIntArray/writeIntArray |
-| int64\_t\* | System.Int64\[ \] | Long\[ \] | readLongArray/writeLongArray |
-| bool\* | System.Boolean\[ \] | Boolean\[ \] | readBooleanArray/writeBooleanArray |
-| wchar\_t\*/char\*<sup>1</sup> | System.Char\[ \] | char\[ \] | readCharArray/writeCharArray |
-| enum<sup>3</sup> | enum | Enum | readObject/writeObject |
-| int8\_t\*\* | byte\[ \]\[ \]/Sbyte\[ \]\[ \] | Byte\[ \]\[ \] | readArrayOfByteArrays/writeArrayOfByteArrays |
-| wchar\_t\*\*/char\*\*<sup>1</sup> | System.String\[ \] | String\[ \] | readStringArray/writeStringArray |
-| CacheableDate | System.DateTime (UTC) | Java.util.date | readDate/writeDate |
-| CacheableObjectArray | object\[ \]/System.Object\[ \] | Object\[ \] | readObjectArray/writeObjectArray |
-| Cacheable/Serializable | object/System.Object | Object | readObject/writeObject |
-
-<sup>1</sup>C++ allows unicode and non-unicode characters, so C++ PDX will support both wchar\_t/char and wchar\_t\*/char\*.
-
-<sup>2</sup> For Pdx, only SByte is used, as Java Byte is signed. But for DataSerializable, Byte\[ \] array is used as a data container.
-
-<sup>3</sup>C++ allows explicit setting of ordinal numbers, but it is up to the developer to map the Java enumNames with C++ enumNames. See [Using C++ Enum Type with PDX Serialization](using_enum_type_with_pdx.html#concept_F38FDBC327204B4EB1E0BC74B4C95409).
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/user-defined-objects.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/user-defined-objects.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/user-defined-objects.html.md.erb
deleted file mode 100644
index e1914f8..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/user-defined-objects.html.md.erb
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Implementing User-Defined Objects in Java Clients
----
-
-You can use one of two methods to implement a user-defined object in a Java client that works with C++ clients: `Instantiator.register` and `DataSerializable`.
-
-## <a id="concept_3DE42CA33684403D8C3730E99C882B55__section_8AC81EE12D8F406DB7602AEAFFD33F2B" class="no-quick-link"></a>Instantiator.register
-
-With the `Instantiator.register` method, a client sends a `RegistrationMessage` to every Java VM in its distributed system. The message announces the mapping between a user-defined classId and class name. The other JVMs can deserialize the byte array with the correct class.
-
-If two clients are in different distributed systems, a `RegistrationMessage` cannot be sent between them. For example: a `put` made by a client in one distributed system will hang when a client in another distributed system performs a get in pure Java mode. Similarly, a `put` made by a C++ client will cause a Java client to hang.
-
-## <a id="concept_3DE42CA33684403D8C3730E99C882B55__section_3F42D06A70644030869D381D03D45CC8" class="no-quick-link"></a>DataSerializable
-
-Using the `DataSerializable` method, the user-defined object is serialized into the following byte array:
-
-``` pre
-45 <2-byte-length> <class-name>
-```
-
-A Java client can deserialize the byte array, but a C++ client cannot convert the Java class name to a C++ class name.
-
-## <a id="concept_3DE42CA33684403D8C3730E99C882B55__section_F3F13E1732EB4995B2C78B0BB1ED18BB" class="no-quick-link"></a>Implementation
-
-The `DataSerializable` method does not support using a nested object, while `Instantiator.register` does support the use of nested objects. A workaround is to let each Java client manually initiate an object for each possible user object class a C++ client provides, using the following code:
-
-``` pre
-User u = new User("", 0);
-```
-
-See [Java Serialization Example](../programming-examples/serialization-java.html#serialization-java) for a code sample that shows how to set up user object classes in a Java client.
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/using-custom-class.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/using-custom-class.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/using-custom-class.html.md.erb
deleted file mode 100644
index f89db20..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/using-custom-class.html.md.erb
+++ /dev/null
@@ -1,68 +0,0 @@
----
-title: Using a Custom Class
----
-
-This example shows how to use the defined `BankAccount` custom key type and the `AccountHistory` value type.
-
-The example takes you through these basic operations: registering, creating a cache, connecting to the distributed system, putting data, getting data, and closing the cache.
-
-## Using a BankAccount Object
-
-``` pre
-#include <gfcpp/GemfireCppCache.hpp>
-#include "BankAccount.hpp"
-#include "AccountHistory.hpp"
-using namespace gemfire;
-/*
-This example connects, registers types, creates the cache, creates a
-region, and then puts and gets user defined type BankAccount.
-*/
-int main( int argc, char** argv ) {
- // Register the user-defined serializable type.
- Serializable::registerType( AccountHistory::createDeserializable );
- Serializable::registerType( BankAccount::createDeserializable );
-�
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
- // Create a cache.
- CachePtr cachePtr = cacheFactory->setSubscriptionEnabled(true)
- ->addServer("localhost", 24680)
- ->create();
-�
- // Create a region.
- RegionFactoryPtr regionFactory =
- cachePtr->createRegionFactory(CACHING_PROXY);
- RegionPtr regionPtr = regionFactory->create("BankAccounts");
-�
- // Place some instances of BankAccount cache region.
- BankAccountPtr KeyPtr(new BankAccount(2309, 123091));
- AccountHistoryPtr ValPtr(new AccountHistory());
- ValPtr->addLog( "Created account" );
- regionPtr->put( KeyPtr, ValPtr );
- printf( "Put an AccountHistory in cache keyed with BankAccount.\n" );
- // Call custom behavior on instance of BankAccount.
- KeyPtr->showAccountIdentifier();
- // Call custom behavior on instance of AccountHistory.
- ValPtr->showAccountHistory();
- // Get a value out of the region.
- AccountHistoryPtr historyPtr =
- dynCast<AccountHistoryPtr>( regionPtr->get( KeyPtr ) );
- if ( historyPtr != NULLPTR ) {
- printf( "Found AccountHistory in the cache.\n" );
- historyPtr->showAccountHistory();
- historyPtr->addLog( "debit $1,000,000." );
- regionPtr->put( KeyPtr, historyPtr );
- printf( "Updated AccountHistory in the cache.\n" );
- }
- // Look up the history again.
- historyPtr = dynCast<AccountHistoryPtr>( regionPtr->get( KeyPtr ) );
- if ( historyPtr != NULLPTR ) {
- printf( "Found AccountHistory in the cache.\n" );
- historyPtr->showAccountHistory();
- }
- // Close the cache and disconnect from the servers
- cachePtr->close();
- return 0;
-}
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/using_enum_type_with_pdx.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
deleted file mode 100644
index df8cadf..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
+++ /dev/null
@@ -1,113 +0,0 @@
----
-title: Using C++ Enum Type with PDX Serialization
----
-
-Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
-To use the C++ enum type with PDX serialization, you have to wrap the `enum` in the `CacheableEnum` class type by specifying classname, enumname and ordinal.
-
-``` pre
-enum enumQuerytest { id1, id2, id3 };
- class TESTOBJECT_EXPORT PdxEnumTestClass :public PdxSerializable
- {
- private:
- int m_id;
- CacheableEnumPtr m_enumid;
-
- public:
- int getID(){
- return m_id;
- }
-
- CacheableEnumPtr getEnumID() {
- return m_enumid;
- }
-
- PdxEnumTestClass(int id)
- {
- m_id = id;
- switch (m_id) {
- case 0:
- m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
- break;
- case 1:
- m_enumid = CacheableEnum::create("enumQuerytest", "id2", id2);
- break;
- case 2:
- m_enumid = CacheableEnum::create("enumQuerytest", "id3", id3);
- break;
- default:
- m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
- break;
- }
- }
-
- PdxEnumTestClass() { }
-
- void toData(PdxWriterPtr pw) {
- pw->writeInt("m_id", m_id);
- pw->writeObject("m_enumid", m_enumid);
- }
-
- void fromData(PdxReaderPtr pr) {
- m_id = pr->readInt("m_id");
- m_enumid = pr->readObject("m_enumid");
- }
-
- CacheableStringPtr toString() const {
- return CacheableString::create("PdxEnumTestClass");
- }
-
- char* GetClassName() const {
- return "com.example.PdxEnumTestClass";
- }
-
- static PdxSerializable* createDeserializable() {
- return new PdxEnumTestClass();
- }
- };
-```
-
-## <a id="concept_F38FDBC327204B4EB1E0BC74B4C95409__section_3491F76DB8C0464D89418B89372BBAEA" class="no-quick-link"></a>How Puts and Queries Work on Enums
-
-The following code sample demonstrates how put and query operations work when using the C++ enum Type with PDX serialization:
-
-``` pre
-//Creating objects of type PdxEnumTestClass
-PdxEnumTestClassPtr pdxobj1(new PdxEnumTestClass(0));
-PdxEnumTestClassPtr pdxobj2(new PdxEnumTestClass(1));
-PdxEnumTestClassPtr pdxobj3(new PdxEnumTestClass(2));
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-
-//PUT Operations
-rptr->put( CacheableInt32::create(0), pdxobj1 );
-LOG( "pdxPut 1 completed " );
-
-rptr->put( CacheableInt32::create(1), pdxobj2 );
-LOG( "pdxPut 2 completed " );
-
-rptr->put( CacheableInt32::create(2), pdxobj3 );
-LOG( "pdxPut 3 completed " );
-
-
-//Query
-try {
- Serializable::registerPdxType(PdxEnumTestClass::createDeserializable);
- LOG("PdxEnumTestClass Registered Successfully....");
-} catch (gemfire::IllegalStateException&/* ex*/) {
- LOG("PdxEnumTestClass IllegalStateException");
-}
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-SelectResultsPtr results = rptr->query("m_enumid.name = 'id2'");
-ASSERT(results->size()== 1 , "query result should have one item");
-ResultSetPtr rsptr = dynCast<ResultSetPtr>(results);
-SelectResultsIterator iter = rsptr->getIterator();
-while (iter.moveNext()) {
- PdxEnumTestClassPtr re = dynCast<PdxEnumTestClassPtr>(iter.current());
- ASSERT(re->getID()== 1 , "query should have returned id 1");
-}
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/using_pdxinstance.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/using_pdxinstance.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/using_pdxinstance.html.md.erb
deleted file mode 100644
index 8e76a74..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/using_pdxinstance.html.md.erb
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Programming Your Application to Use PdxInstances
----
-
-A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. Geode provides the implementation of the `PdxInstance` class.
-
-You can configure your cache to return a `PdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. Preventing deserialization saves both time and memory and does not require you deserialize the object to the domain class.
-
-This configuration can be done in cache.xml by setting the attribute `read-serialized` to `true` on the <pdx>element. Or it can be done programmatically using the `CacheFactory::setPdxReadSerialized(bool)` method.
-
-After this preference is configured, any time a PDX object is deserialized, it is deserialized into a `PdxInstance`.
-
-The following is a code sample of using the setField API of PdxInstance to modify fields:
-
-``` pre
-RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
-CacheableKeyPtr keyport = CacheableKey::create("pdxput");
-CacheableKeyPtr keyport1 = CacheableKey::create("pdxput2");
-
-PdxInstancePtr pIPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-LOG( "modifyPdxInstance get complete." );
-
-WritablePdxInstancePtr wpiPtr( pIPtr->createWriter());
-
-ASSERT(pIPtr != NULLPTR, "pIPtr != NULLPTR expected");
-int val = 0;
-int newVal = 0;
-ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
-pIPtr->getField("m_int32", val);
-wpiPtr->setField("m_int32", val + 1);
-rptr->put(keyport, wpiPtr);
-PdxInstancePtr newPiPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
-newPiPtr->getField("m_int32", newVal);
-ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
-ASSERT((*pIPtr.ptr() == *newPiPtr.ptr()) == false,
- "PdxInstance should not be equal");
-```
-
-In addition to field access, `PdxInstance` also supports field modification using the `setField(fieldName)` method. The `setField` method has copy-on-write semantics. So for the modifications to be stored in the cache, the `PdxInstance` must be put into a region after `setField` has been called one or more times.
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/using_pdxinstancefactory.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/using_pdxinstancefactory.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/using_pdxinstancefactory.html.md.erb
deleted file mode 100644
index 80e55f0..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/using_pdxinstancefactory.html.md.erb
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: Using PdxInstanceFactory to Create PdxInstances
----
-
-You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
-Creating a `PdxInstance` can be particularly useful when you need an instance of a domain class for plug-in code such as a function or a loader. If you have raw data for the domain object (the class name and each field's type and data), then you can explicitly create a `PdxInstance`. The `PdxInstanceFactory` API is very similar to the `PdxWriter` API except that after writing each field, you need to call the create method which returns the created `PdxInstance`.
-
-## PdxInstance Example
-
-The following is a code example of creating a `PdxInstance`.
-
-``` pre
-class Person
-{
-private:
- char* m_name;
- int m_id;
- int m_age;
-
-public:
- Person() { }
-
- Person(char* name, int id, int age)
- {
- m_name = name;
- m_id = id;
- m_age = age;
- }
-
- char* getName() const
- {
- return m_name;
- }
- int getID()
- {
- return m_id;
- }
- int getAge()
- {
- return m_age;
- }
-};
-
-int main(int argc, char ** argv)
-{
- try
- {
- // Create a Cache.
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
-
- CachePtr cachePtr = cacheFactory->set("cache-xml-file",
- "XMLs/clientPdxInstance.xml")->create();
-
- LOGINFO("Created the GemFire Cache");
-
- // Get the example Region from the Cache which is declared in the
- // Cache XML file.
- RegionPtr regionPtr = cachePtr->getRegion("Person");
-
- LOGINFO("Obtained the Region from the Cache.");
-
- Person* p = new Person("Jack", 7, 21);
-
- //PdxInstanceFactory for Person class
- PdxInstanceFactoryPtr pif = cachePtr->createPdxInstanceFactory("Person");
- LOGINFO("Created PdxInstanceFactory for Person class");
-
- pif->writeString("m_name", p->getName());
- pif->writeInt("m_id", p->getID());
- pif->markIdentityField("m_id");
- pif->writeInt("m_age", p->getAge());
-
- PdxInstancePtr pdxInstance = pif->create();
-
- LOGINFO("Created PdxInstance for Person class");
-
- regionPtr->put("Key1", pdxInstance);
-
- LOGINFO("Populated PdxInstance Object");
-
- PdxInstancePtr retPdxInstance = regionPtr->get("Key1");
-
- LOGINFO("Got PdxInstance Object");
-
- int id = 0;
- retPdxInstance->getField("m_id", id);
-
- int age = 0;
- retPdxInstance->getField("m_age", age);
-
- char* name = NULL;
- retPdxInstance->getField("m_name", &name);
-
- if (id == p->getID()&& age == p->getAge() && strcmp(name, p->getName()) == 0
- && retPdxInstance->isIdentityField("m_id") == true)
- LOGINFO("PdxInstance returns all fields value expected");
- else
- LOGINFO("PdxInstance doesn't returns all fields value expected");
-
- delete p;
-
- // Close the Cache.
- cachePtr->close();
-
- LOGINFO("Closed the Cache");
-
- }
- // An exception should not occur
- catch(const Exception & gemfireExcp)
- {
- LOGERROR("PdxInstance Exception: %s", gemfireExcp.getMessage());
- }
-}
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/cpp-caching-api/using_pdxserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/cpp-caching-api/using_pdxserializer.html.md.erb b/geode-docs/nativeclient/cpp-caching-api/using_pdxserializer.html.md.erb
deleted file mode 100644
index 475a6e0..0000000
--- a/geode-docs/nativeclient/cpp-caching-api/using_pdxserializer.html.md.erb
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: Serialize Your Domain Objects with PdxSerializer and PdxWrapper
----
-
-For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
-You register a `PdxSerializer` implementation for the entire cache, programming it for all of the domain objects that you handle in this way. This way you do not have to implement the `PdxSerializable` interface for each domain class.
-
-The `PdxSerializer` allows domain classes to be serialized and deserialized as PDXs without modification of the domain class. It requires only that the domain class have a constructor accessible to the `PdxSerializer` to create an instance. The domain class will be held in a wrapper class, `PdxWrapper`.
-
-`PdxSerializer` has the following methods:
-
-- The `toData` method returns true if the PdxSerializer was able to serialize the user object, false if not.
-- If the PdxSerializer was able to deserialize the object, the `fromData` method returns a void pointer to the user object to be wrapped in a `PdxWrapper`.
-
-When you later reference the user object, use the `PdxWrapper` class. `PdxWrapper` holds a shared reference to the object in the local cache and is used during serialization and deserialization. `PdxWrapper` acts as a container for the user domain object and needs to wrap every instance of the object that uses a registered `PdxSerializer`. The object instance will not be modified. In addition, when using `PdxWrapper`, you will need to provide a function pointer to a "de-allocator", which will delete the user object when the reference is no longer held.
-
-The following code example defines a user object and a `PdxSerializer`. It then registers the new `PdxSerializer` and then uses `PdxWrapper` to put the object in a region and retrieve the object from a region.
-
-``` pre
-class UserClass
-{
-public:
-
- int m_int;
- string m_string;
-
- UserClass(int intVal, string stringVal)
- {
- m_int = intVal;
- m_string = stringVal;
- }
-
- static void deallocate(void * object, char * className)
- {
- if (strcmp(className, "com.example.UserClass") == 0) {
- UserClass * userObject = reinterpret_cast<UserClass*>(object);
- delete userObject;
- }
- }
-};
-
-class UserPdxSerializer : public PdxSerializer
-{
-public:
-
- void* fromData(char * className, PdxReaderPtr pdxReader)
- {
- if (strcmp(className, "com.example.UserClass") != 0) {
- return NULL;
- }
-
- int intVal = pdxReader->readInt("m_int");
- string stringVal = pdxReader->readString("m_string");
-
- UserClass * userObject = new UserClass(intVal, stringVal);
-
- return (void*) userObject;
- }
-
- bool toData(void * object, char * className, PdxWriterPtr pdxWriter)
- {
- if (strcmp(className, "com.example.UserClass") != 0) {
- return false;
- }
-
- UserClass * userObject = reinterpret_cast<UserClass*>(object);
-
- pdxWriter->writeInt("m_int", userObject->m_int);
- pdxWriter->writeString("m_string", userObject->m_string);
-
- return true;
- }
-
- UserDeallocator getDeallocator(char * className)
- {
- if (strcmp(className, "com.example.UserClass") == 0) {
- return UserClass::deallocate;
- } else {
- return NULL;
- }
- }
-};
-
-// Register a user PDX serializer
-
-Serializable::registerPdxSerializer(new UserPdxSerializer);
-
-// Put a user object into a region.
-
-UserClass * userObject = new UserClass(123, "someValue");
-PdxWrapperPtr pdxWrapper = new PdxWrapper(userObject, "com.example.UserClass",
- UserClass::deallocate);
-region->put("key", pdxWrapper);
-
-// Get a user object from a region.
-
-pdxWrapper = dynCast<PdxWrapperPtr>(region->get("key"));
-UserClass * userObject = reinterpret_cast<UserClass*>(pdxWrapper->getObject());
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/delta-propagation/delta-propagation-api.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/delta-propagation/delta-propagation-api.html.md.erb b/geode-docs/nativeclient/delta-propagation/delta-propagation-api.html.md.erb
deleted file mode 100644
index 5ff7781..0000000
--- a/geode-docs/nativeclient/delta-propagation/delta-propagation-api.html.md.erb
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: Delta Propagation API
----
-
-Delta propagation uses configuration properties and a simple API to send and receive deltas.
-
-## <a id="delta-propagation-api__section_5787FD2053544B2AB6E7DCC3CEC14204" class="no-quick-link"></a>.NET
-
-Your application class must implement:
-
-- `GemStone::GemFire::Cache::IGFDelta `
-- `GemStone::GemFire::Cache::IGFSerializable `
-
-`IGFDelta` provides the methods, `HasDelta`, `ToDelta`, and `FromDelta`, which you program to report on, send, and receive deltas for your class.
-
-Additionally, for cloning, your class must implement the standard .NET `IClonable` interface and its `Clone` method. See [Cloning](delta-propagation-properties.html#delta-propagation-properties).
-
-## <a id="delta-propagation-api__section_F3F89A01A4084D3092B88D16E43D8B37" class="no-quick-link"></a>C++
-
-Your application must publicly derive from:
-
-- `gemfire::Delta `
-- `gemfire::Cacheable `
-
-`Delta` provides the methods, `hasDelta`, `toDelta`, `fromDelta`, which you program to report on, send, and receive deltas for your class.
-
-For cloning, use the `clone` method provided in the Delta interface. See [Cloning](delta-propagation-properties.html#delta-propagation-properties).
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/delta-propagation/delta-propagation-examples.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/delta-propagation/delta-propagation-examples.html.md.erb b/geode-docs/nativeclient/delta-propagation/delta-propagation-examples.html.md.erb
deleted file mode 100644
index bd84047..0000000
--- a/geode-docs/nativeclient/delta-propagation/delta-propagation-examples.html.md.erb
+++ /dev/null
@@ -1,335 +0,0 @@
----
-title: Examples of Delta Propagation
----
-
-Examples describe delta propagation operations and provide implementation code for .NET and C++.
-
-## <a id="examples__section_B94DCD0A4B4142A88166E5011475AB7C" class="no-quick-link"></a>Delta Propagation in the Client/Server
-
-In this example, the feeder client is connected to the first server, and the receiver client is connected to the second. The servers are peers to each other.
-
-<a id="examples__fig_09CF542F4AB2471FB67287A05305DAA2"></a>
-<span class="figtitleprefix">Figure: </span>Example of Delta Propagation in the Client/Server
-
-<img src="../common/images/delta-propagation-in-client-server.gif" id="examples__image_6A18D7CE07C243D6B03C5EE82786C36C" class="image" />
-
-These are the main operations shown in the example:
-
-1. In the Feeder client, the application updates the entry object and puts the entry. In response to the `put`, Geode calls `hasDelta`, which returns true.
-2. Geode calls `toDelta` and forwards the extracted delta to the server. If `hasDelta` returned false, Geode would distribute the full entry value.
-3. In Server1, Geode applies the delta to the cache, distributes the received delta to the server\u2019s peers, and forwards it to any other clients with interest in the entry (there are no other clients to Server1 in this example).
-4. In Server2, Geode applies the delta to the cache and forwards it to its interested clients, which in this case is just Receiver client.
-
-## <a id="examples__section_C6CB9DB1EB684CD48A38002EF59E54F0" class="no-quick-link"></a>Client Example Files
-
-These example files, from the product `quickstart` examples, show the basic approach to programming a delta propagation implementation for an entry value object, named `DeltaExample` in this example.
-
-**XML file used for the examples**
-
-``` pre
-<cache>
- <region name="root" refid="CACHING_PROXY">
- <region-attributes cloning-enabled="true" pool-name="examplePool"/>
- </region>
- <pool name="examplePool" subscription-enabled="true" server-group="ServerGroup1">
- <locator host="localhost" port="34756"/>
- </pool>
-</cache>
-```
-
-**Delta Example Implementation (C\# .NET)**
-
-``` pre
-using System;
-using GemStone.GemFire.Cache;
-
-namespace GemStone.GemFire.Cache.QuickStart
-{
- public class DeltaExample : IGFDelta, IGFSerializable, ICloneable
- {
- // data members
- private Int32 m_field1;
- private Int32 m_field2;
- private Int32 m_field3;
-
- // delta indicators
- private bool m_f1set;
- private bool m_f2set;
- private bool m_f3set;
-
- public DeltaExample(Int32 field1, Int32 field2, Int32 field3)
- {
- m_field1 = field1;
- m_field2 = field2;
- m_field3 = field3;
- reset();
- }
-
- public DeltaExample()
- {
- reset();
- }
-
- public DeltaExample(DeltaExample copy)
- {
- m_field1 = copy.m_field1;
- m_field2 = copy.m_field2;
- m_field3 = copy.m_field3;
- reset();
- }
-
- private void reset()
- {
- m_f1set = false;
- m_f2set = false;
- m_f3set = false;
- }
-
- public Int32 getField1()
- {
- return m_field1;
- }
- // REPEAT FOR OTHER FIELDS
-
- public void setField1(Int32 val)
- {
- lock(this)
- {
- m_field1 = val;
- m_f1set = true;
- }
- }
- // REPEAT FOR OTHER FIELDS
-
- public bool HasDelta()
- {
- return m_f1set || m_f2set || m_f3set;
- }
-
- public void ToDelta(DataOutput DataOut)
- {
- lock(this)
- {
- DataOut.WriteBoolean(m_f1set);
- if (m_f1set)
- {
- DataOut.WriteInt32(m_field1);
- }
- // REPEAT FOR OTHER FIELDS
-
- reset();
- }
- }
-
- public void FromDelta(DataInput DataIn)
- {
- lock(this)
- {
- m_f1set = DataIn.ReadBoolean();
- if (m_f1set)
- {
- m_field1 = DataIn.ReadInt32();
- }
- // REPEAT FOR OTHER FIELDS
-
- }
- }
-
- public void ToData(DataOutput DataOut)
- {
- DataOut.WriteInt32(m_field1);
- DataOut.WriteInt32(m_field2);
- DataOut.WriteInt32(m_field3);
- }
-
- public IGFSerializable FromData(DataInput DataIn)
- {
- m_field1 = DataIn.ReadInt32();
- m_field2 = DataIn.ReadInt32();
- m_field3 = DataIn.ReadInt32();
- return this;
- }
-
- public UInt32 ClassId
- {
- get
- {
- return 0x02;
- }
- }
- public UInt32 ObjectSize
- {
- get
- {
- UInt32 objectSize = 0;
- return objectSize;
- }
- }
-
- public static IGFSerializable create()
- {
- return new DeltaExample();
- }
-
- public Object Clone()
- {
- return new DeltaExample(this);
- }
- }
-}
-```
-
-**Delta Example Implementation (C++)**
-
-``` pre
-#ifndef __Delta_Example__
-#define __Delta_Example__
-
-#include <gfcpp/GemfireCppCache.hpp>
-
-using namespace gemfire;
-
-class DeltaExample: public Cacheable, public Delta
-{
-
-private:
-
- // data members
- int32_t m_field1;
- int32_t m_field2;
- int32_t m_field3;
-
- // delta indicators
- mutable bool m_f1set;
- mutable bool m_f2set;
- mutable bool m_f3set;
-
-public:
-
- DeltaExample(int32_t field1, int32_t field2, int32_t field3) :
- m_field1(field1), m_field2(field2), m_field3(field3)
- {
- reset();
- }
-
- DeltaExample()
- {
- reset();
- }
-
- DeltaExample(DeltaExample * copy)
- {
- m_field1 = copy->m_field1;
- m_field2 = copy->m_field2;
- m_field3 = copy->m_field3;
- reset();
- }
-
- void reset() const
- {
- m_f1set = false;
- m_f2set = false;
- m_f3set = false;
- }
-
- int getField1()
- {
- return m_field1;
- }
- // REPEAT FOR OTHER FIELDS
-
- void setField1(int val)
- {
- lock();
- m_field1 = val;
- m_f1set = true;
- unlock();
- }
- // REPEAT FOR OTHER FIELDS
-
- virtual bool hasDelta()
- {
- return m_f1set || m_f2set || m_f3set;
- }
-
- virtual void toDelta(DataOutput& out) const
- {
- lock();
-
- out.writeBoolean(m_f1set);
- if (m_f1set)
- {
- out.writeInt(m_field1);
- }
- // REPEAT FOR OTHER FIELDS
-
- reset();
-
- unlock();
- }
-
- virtual void fromDelta(DataInput& in)
- {
- lock();
-
- in.readBoolean(&m_f1set);
- if (m_f1set)
- {
- in.readInt(&m_field1);
- }
- // REPEAT FOR OTHER FIELDS
-
- reset();
-
- unlock();
- }
-
- virtual void toData(DataOutput& output) const
- {
- lock();
- output.writeInt(m_field1);
- output.writeInt(m_field2);
- output.writeInt(m_field3);
- unlock();
- }
-
- virtual Serializable* fromData(DataInput& input)
- {
- lock();
- input.readInt(&m_field1);
- input.readInt(&m_field2);
- input.readInt(&m_field3);
- unlock();
- return this;
- }
-
- virtual int32_t classId() const
- {
- return 2;
- }
-
- virtual uint32_t objectSize() const
- {
- return 0;
- }
-
- DeltaPtr clone()
- {
- return DeltaPtr(new DeltaExample(this));
- }
-
- virtual ~DeltaExample()
- {
- }
-
- static Serializable* create()
- {
- return new DeltaExample();
- }
-
- void lock() const { /* add platform dependent synchronization code here */ }
-
- void unlock() const { /* add platform dependent synchronization code here */ }
-};
-#endif
-```
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/delta-propagation/delta-propagation-properties.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/delta-propagation/delta-propagation-properties.html.md.erb b/geode-docs/nativeclient/delta-propagation/delta-propagation-properties.html.md.erb
deleted file mode 100644
index 3738402..0000000
--- a/geode-docs/nativeclient/delta-propagation/delta-propagation-properties.html.md.erb
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Cloning
----
-
-With cloning enabled, Geode does a deep copy of the object, using serialization. You can improve performance by implementing the appropriate `clone` method for your API, making a deep copy of anything to which a delta may be applied.
-
-The goal is to significantly reduce the overhead of copying the object while still retaining the isolation needed for your deltas.
-
-You configure delta propagation on the server side as well as client. For information on the server and delta propagation, see [Delta Propagation](../../developing/delta_propagation/chapter_overview.html).
-
-## <a id="delta-propagation-properties__section_4096D0697BD24A04867B8555B3D1843F" class="no-quick-link"></a>cloning-enabled
-
-The `cloning-enabled` property is a region attributes boolean, configured in the `cache.xml`, that affects how `fromDelta` applies deltas to the local client cache. When `true`, the updates are applied to a clone of the value and then the clone is saved to the cache. When `false`, the value is modified in place in the cache. The default value is `false`.
-
-Cloning can be expensive, but it ensures that the new object is fully initialized with the delta before any application code sees it.
-
-Without cloning:
-
-- It is possible for application code to read the entry value as it is being modified, possibly seeing the value in an intermediate, inconsistent state, with just part of the delta applied. You may choose to resolve this issue by having your application code synchronize on reads and writes.
-- Geode loses any reference to the old value because the old value is transformed in place into the new value. Because of this, your `CacheListener` sees the same new value returned for `EntryEvent.getOldValue` and `EntryEvent.getNewValue`.
-- Exceptions thrown from `fromDelta` may leave your cache in an inconsistent state. Without cloning, any interruption of the delta application could leave you with some fields in your cached object changed and others unchanged. If you do not use cloning, keep this in mind when you program your error handling in your `fromDelta` implementation.
-
-## Enabling Cloning in cache.xml
-
-``` pre
-<region name="exampleRegion">
- <region-attributes refid="CACHING_PROXY" cloning-enabled="true"
- pool-name="examplePool"/>
-</region>
-```
-
-## Enabling Cloning (C++)
-
-``` pre
-RegionFactoryPtr regionFactory =
- cachePtr->createRegionFactory(CACHING_PROXY);
-RegionPtr regionPtr = regionFactory
- ->setCloningEnabled(true)
- ->create("myRegion");
-```
-
-
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/381d0faa/geode-docs/nativeclient/delta-propagation/delta-propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/nativeclient/delta-propagation/delta-propagation.html.md.erb b/geode-docs/nativeclient/delta-propagation/delta-propagation.html.md.erb
deleted file mode 100644
index 8b714db..0000000
--- a/geode-docs/nativeclient/delta-propagation/delta-propagation.html.md.erb
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: Delta Propagation
----
-
-*Delta Propagation* describes how deltas (updates to data) are propagated and how to implement delta propagation. It also analyzes performance limitations.
-
-In most distributed data management systems, stored data is created once and updated frequently. Updates are sent to other members for event propagation, redundancy management, and cache consistency in general. Tracking only the changes in an updated object and sending only the updates, or deltas, mean lower network transmission costs and lower object serialization/deserialization costs. Generally, the larger your objects and the smaller the deltas, the greater the performance benefits of delta propagation. Partitioned regions generally benefit more with higher redundancy levels.
-
-- **[How Delta Propagation Works](../../nativeclient/delta-propagation/how-delta-propagation-works.html)**
-
- Geode propagates object deltas using methods that you program on the client side. The methods are in the delta interface, which you implement in your cached objects\u2019 classes.
-
-- **[Delta Propagation API](../../nativeclient/delta-propagation/delta-propagation-api.html)**
-
- Delta propagation uses configuration properties and a simple API to send and receive deltas.
-
-- **[Cloning](../../nativeclient/delta-propagation/delta-propagation-properties.html)**
-
- With cloning enabled, Geode does a deep copy of the object, using serialization. You can improve performance by implementing the appropriate `clone` method for your API, making a deep copy of anything to which a delta may be applied.
-
-- **[Implementing Delta Propagation](../../nativeclient/delta-propagation/implementing-delta-propagation.html)**
-
- By default, delta propagation is enabled in your distributed system and is used for objects that implement the delta interface. You program the client-side methods to extract delta information for your entries and to apply received delta information.
-
-- **[Exceptions and Limitations](../../nativeclient/delta-propagation/performance.html)**
-
-- **[Examples of Delta Propagation](../../nativeclient/delta-propagation/delta-propagation-examples.html)**
-
- Examples describe delta propagation operations and provide implementation code for C\# .NET and C++.
-
-