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?;
-  };​
-```
-
-## <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—functions 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—Comparison 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—Comparison 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’s `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’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. For more about this, see 
the API documentation for `DataOutput` .
-
-    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. 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’s data fields.
-
-    ``` pre
-    void fromData (DataInput& input)
-    ```
-
-    The `DataInput` class represents the input stream and provides methods for 
reading input elements. The `fromData` function must read the elements of the 
input stream in the same order that they were written by `toData` . 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`—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.
-
-## 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&lt;Object, Object&gt; | java.util.HashMap       | 
readObject/writeObject                       |
-| CacheableVector                   | System::Collections::ArrayList           
                        | java.util.Vector        | readObject/writeObject      
                 |
-| CacheableArrayList                | System::Collections:: 
Generic::IList&lt;Object&gt;               | 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 &lt;pdx&gt;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’s 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’ 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++.
-
-


Reply via email to