geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbar...@apache.org
Subject [17/22] geode git commit: GEODE-1964 Move doc files to geode-native subdirectory, add geode-native-book directory, update User Guide sources for donation 2
Date Thu, 09 Feb 2017 23:56:48 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
new file mode 100644
index 0000000..386737a
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_options.html.md.erb
@@ -0,0 +1,65 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
new file mode 100644
index 0000000..32f7e0c
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_overview.html.md.erb
@@ -0,0 +1,31 @@
+---
+title:  Serializing Data
+---
+
+All data that Geode moves out of the local cache must be serializable.
+
+-   **[Region Data Requiring Serialization](region_data_requiring_serialization.html)**
+
+    Certain region types (including client regions) require serialization.
+
+-   **[Data Serialization Options](serialization_options.html)**
+
+    The native client C++ API gives you two serialization options: the `GemFire::Serializable` interface and GemFire PDX serialization.
+
+-   **[Serializing Data with PDX Serialization](pdx_serialization.html)**
+
+    PDX is a cross-language data format that can reduce the cost of distributing and serializing your objects. PDX stores data in named fields that you can access individually to avoid the cost of deserializing the entire data object. When you use PDX serialization with 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](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](object-graphs.html)**
+
+    If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
+
+-   **[Serializing and Accessing Data as a Blob](data-as-blob.html)**
+
+    If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
new file mode 100644
index 0000000..9993596
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
@@ -0,0 +1,246 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
new file mode 100644
index 0000000..135f81c
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
@@ -0,0 +1,46 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/user-defined-objects.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/user-defined-objects.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/user-defined-objects.html.md.erb
new file mode 100644
index 0000000..a56a8de
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/user-defined-objects.html.md.erb
@@ -0,0 +1,29 @@
+---
+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.
+
+## <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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/using-custom-class.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/using-custom-class.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/using-custom-class.html.md.erb
new file mode 100644
index 0000000..f89db20
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/using-custom-class.html.md.erb
@@ -0,0 +1,68 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
new file mode 100644
index 0000000..df8cadf
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
@@ -0,0 +1,113 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
new file mode 100644
index 0000000..8e76a74
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
@@ -0,0 +1,42 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
new file mode 100644
index 0000000..80e55f0
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
@@ -0,0 +1,117 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
new file mode 100644
index 0000000..475a6e0
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
@@ -0,0 +1,102 @@
+---
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-api.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-api.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-api.html.md.erb
new file mode 100644
index 0000000..5c3779b
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-api.html.md.erb
@@ -0,0 +1,27 @@
+---
+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 - for C&#35;
+
+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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-examples.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-examples.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-examples.html.md.erb
new file mode 100644
index 0000000..63fe34b
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-examples.html.md.erb
@@ -0,0 +1,335 @@
+---
+title:  Examples of Delta Propagation
+---
+
+Examples describe delta propagation operations and provide implementation code for C\# .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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-properties.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-properties.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-properties.html.md.erb
new file mode 100644
index 0000000..ec63319
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation-properties.html.md.erb
@@ -0,0 +1,40 @@
+---
+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](geodeman/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/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation.html.md.erb
new file mode 100644
index 0000000..8711083
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/delta-propagation.html.md.erb
@@ -0,0 +1,31 @@
+---
+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](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](delta-propagation-api.html)**
+
+    Delta propagation uses configuration properties and a simple API to send and receive deltas.
+
+-   **[Cloning](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](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](performance.html)**
+
+-   **[Examples of Delta Propagation](delta-propagation-examples.html)**
+
+    Examples describe delta propagation operations and provide implementation code for C\# .NET and C++.
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/how-delta-propagation-works.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/how-delta-propagation-works.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/how-delta-propagation-works.html.md.erb
new file mode 100644
index 0000000..eac1907
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/how-delta-propagation-works.html.md.erb
@@ -0,0 +1,19 @@
+---
+title:  How Delta Propagation Works
+---
+
+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.
+
+This figure shows delta propagation for a change to an entry with key, `k`, and value object, `v`.
+
+<a id="how-delta-propagation-works__fig_C4846E7C4C0E4D6097736B5BFBBF93A7"></a>
+<span class="figtitleprefix">Figure: </span>Delta Propagation
+
+<img src="../common/images/delta-propagation.gif" alt="Delta Propagation" id="how-delta-propagation-works__image_69D664D2A4344785A52AC2D492E4B557" class="image" />
+
+1.  **get operation**. The `get` works as usual; the cache returns the full entry object from the local cache or, if it is unavailable there, from a server cache or from a loader.
+2.  **update methods**. You need to add code to the object’s update methods so that they save delta information for object updates, in addition to the work they were already doing.
+3.  **put operation**. The `put` works as usual in the local cache, using the full value, then calls `hasDelta` to check for deltas and `toDelta` to serialize the information.
+4.  **receipt of delta**. `fromDelta` extracts the delta information that was serialized by `toDelta` and applies it to the object in the local cache. The delta is applied directly to the existing value or to a clone, depending on how you configure it for the region.
+5.  **additional distributions**. As with full distributions, receiving members forward the delta according to their configurations and connections to other members. In the example, the server would forward the delta to its peers and its other clients as needed. Receiving members do not recreate the delta; `toDelta` is only called in the originating member.
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/implementing-delta-propagation.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/implementing-delta-propagation.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/implementing-delta-propagation.html.md.erb
new file mode 100644
index 0000000..6d1c3ee
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/implementing-delta-propagation.html.md.erb
@@ -0,0 +1,41 @@
+---
+title:  Implementing Delta Propagation
+---
+
+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.
+
+For more information, see [Delta Propagation API](delta-propagation-api.html#delta-propagation-api).
+
+**Prerequisites**
+
+-   Study your object types and expected application behavior to determine which objects should use delta propagation. Delta propagation is not beneficial for all data and data modification scenarios. See [Exceptions and Limitations](performance.html#performance).
+-   Decide whether to enable cloning. Cloning is disabled by default. See [cloning-enabled](delta-propagation-properties.html#delta-propagation-properties).
+-   If you enable cloning, consider providing your own implementation, to optimize performance.
+-   If you do not enable cloning, be sure to synchronize your delta code.
+-   If you do not enable cloning, review all associated listener code for dependencies on the entry event old value. Without cloning, Geode modifies the entry in place and so loses its reference to the old value. For delta events, the `EntryEvent` methods to retrieve the old and new values both return the new value.
+
+**Procedure**
+
+For every class in which you want delta propagation, implement the delta interface and update your methods to support delta propagation. Exactly how you do this depends on your application and object needs, but these steps describe the basic approach.
+
+1.  Study the object contents to decide how to handle delta changes.
+
+    Delta propagation has the same issues of distributed concurrency control as the distribution of full objects, but on a more detailed level. Some parts of your objects may be able to change independent of one another while others may always need to change together. Send deltas large enough to keep your data logically consistent. If, for example, field A and field B depend on each other, then your delta distributions should either update both fields or neither. As with regular updates, the fewer producers you have on a data region, the lower your likelihood of concurrency issues.
+
+2.  In the application code that puts entries, put the fully populated object into the local cache. This usually means doing a `get` on the entry, unless you are sure it does not already exist anywhere in the distributed region.
+
+    Even though you are planning to send only deltas, errors on the receiving end could cause Geode to request the full object, so you must provide it to the originating put method. Do this even in empty producers, with regions configured for no local data storage.
+
+3.  Change each field’s update method to record information about the update.
+
+    The information must be sufficient for `toDelta` to encode the delta and any additional required delta information when it is invoked.
+
+4.  Write `hasDelta` to report on whether a delta is available.
+5.  When writing your serialization methods, `toDelta`, `fromDelta`, `toData`, `fromData`, be sure to exclude any fields used to manage delta state, which do not need to be sent.
+6.  Write `toDelta` to create a byte stream with the changes to the object and any other information that `fromDelta` will need to apply the changes. Before returning from `toDelta`, reset your delta state to indicate that there are no delta changes waiting to be sent.
+7.  Write `fromDelta` to decode the byte stream that `toDelta` creates and update the object.
+8.  Make sure you provide adequate synchronization to your object to maintain a consistent object state.
+
+    If you do not use cloning, you will probably need to synchronize on reads and writes to avoid reading partially written updates from the cache. This might involve `toDelta`, `fromDelta`, and other object access and update methods. Additionally, your implementation should take into account the possibility of concurrent invocations of `fromDelta` and one or more of the object's update methods.
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/delta-propagation/performance.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/delta-propagation/performance.html.md.erb b/geode-docs/docs/geode-native-docs/delta-propagation/performance.html.md.erb
new file mode 100644
index 0000000..435997e
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/delta-propagation/performance.html.md.erb
@@ -0,0 +1,48 @@
+---
+title:  Exceptions and Limitations
+---
+
+In some application scenarios, delta propagation does not show any significant performance benefits. On occasion it results in degradation. There are other limitations and exceptions related to delta propagation.
+
+## <a id="performance__section_26DE70BF948F4B55A36A7B91C9AE2751" class="no-quick-link"></a>Errors in Delta Propagation
+
+Errors in delta propagation fall into two categories based on how they are handled:
+
+-   **Problems applying the delta that can be remedied if the originating member sends the full value in place of the delta.** Your put operation does not see errors or exceptions related to the failed delta propagation. The system automatically does a full value distribution to the receiver where the problem occurs. This type of error includes:
+
+    -   Unavailable entry value in the receiving cache, either because the entry is missing or its value is null. In both cases, there is nothing to apply the delta to and the full value must be sent. This is most likely to occur if you destroy or invalidate your entries locally, either through application calls or through configured actions like eviction or entry expiration.
+    -   `InvalidDeltaException` thrown by `fromDelta` method, programmed by you. This exception enables you to avoid applying deltas that would violate data consistency checks or other application requirements. Throwing this exception causes Geode to send the full value.
+    -   Any error applying the delta in a client in server-to-client propagation. The client retrieves the full value from the server.
+-   **Problems creating or distributing the delta that cannot be fixed by distributing the full value.** These problems are caused by errors or exceptions in `hasDelta` or `toDelta`. In these cases, your `put` operation fails with an exception.
+
+## <a id="performance__section_39CE903E2C0C412E891C420C59AB4588" class="no-quick-link"></a>Performance Limitations
+
+Consider the following situations in which delta propagation adversely affects performance:
+
+-   **Added costs of deserializing your objects to apply deltas**. Applying a delta requires the entry value to be deserialized. Once this is done, the object is stored back in the cache in deserialized form. This aspect of delta propagation only negatively impacts your system if your objects are not already being deserialized for other reasons, such as for indexing and querying or for listener operations. Once stored in deserialized form, there are reserialization costs for operations that send the object outside of the member, like values sent in response to netSearch or client requests, and storage to disk. The more operations that require reserialization, the higher the overhead of deserializing the object.
+-   **Cloning**. Cloning can affect performance. Not using cloning is risky, however, as you are modifying cached values in place. Make sure you synchronize your entry access to keep your cache from becoming inconsistent.
+-   **Problems applying the delta that cause the system to go back to the originator for the full entry value**. In this scenario, the overall operation costs more than sending the full entry value in the first place. The problem can be exacerbated if your delta is sent to a number of recipients, all or most of them request a full value, and the full value send requires the object to be serialized.
+-   **Disk I/O costs associated with overflow regions**. If you use eviction with overflow to disk, on-disk values must be brought into memory in order to apply the delta. This is much more costly than removing the reference to the disk copy, as you would do with a full value distribution into the cache.
+
+## <a id="performance__section_F7BC60C9E89B44BBA3D06995D52574AC" class="no-quick-link"></a>Configurations That Require Full Values
+
+Geode clients can always send deltas to the servers, and servers can usually sent deltas to clients. The following configurations require the servers to send full values to the clients, instead of deltas:
+
+-   When the client's `gemfire.properties` setting `conflate-events` is set to `true`, the servers send full values for all regions.
+-   When the server region attribute `enable-subscription-conflation` is set to `true` and the client `gemfire.properties` setting `conflate-events` is set to `server`, the servers send full values for the region.
+-   Servers send full values to client regions that are configured to not cache data—with the `PROXY                             RegionShortcut` in their region attributes `refid`.
+
+To use the delta propagation feature, all updates on a key in a region must have value types that implement the `Delta` interface. You cannot mix object types for an entry key where some of the types implement delta and some do not. This is because, when a type implementing the delta interface is received for an update, the existing value for the key is cast to a `Delta` type to apply the received delta.
+
+## <a id="performance__section_2767204E1914425BB8160E4347615B71" class="no-quick-link"></a>General Limitations
+
+Sometimes `fromDelta` cannot be invoked because there is no object to apply the delta to in the receiving cache. When this happens, the system sends the full value. There are two possible scenarios:
+
+-   If the system can determine beforehand that the receiver does not have a local copy, it sends the initial message with the full value. This is possible when regions are configured with no local data storage, as when you are using them to provide data update information to listeners.
+-   In less obvious cases, as when an entry has been locally deleted, first the delta is sent, then the receiver requests a full value and that is sent. Whenever the full value is received, any further distributions to the receiver’s peers or clients uses the full value.
+
+Geode does not propagate deltas for:
+
+-   Transactional commit on the server
+-   The `putAll` operation
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/dotnet-caching-api/application-callbacks.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/dotnet-caching-api/application-callbacks.html.md.erb b/geode-docs/docs/geode-native-docs/dotnet-caching-api/application-callbacks.html.md.erb
new file mode 100644
index 0000000..c9fca25
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/dotnet-caching-api/application-callbacks.html.md.erb
@@ -0,0 +1,81 @@
+---
+title:  Application Callbacks
+---
+
+For region-level events, an application can use `AttributesFactory.SetCache*` methods to implement and register the `ICacheLoader`, `ICacheWriter`, and `ICacheListener` interfaces to perform custom actions.
+
+You can use `Region.Put` for simple caching situations. For more complex needs, you should implement the `ICacheLoader` interface and allow the cache to manage the creation and loading of objects. When a `Region.Get` is called for a region entry with a value of null, the `ICacheLoader::Load` method of the cache loader (if any) for the region is invoked. A static `CacheLoader::NetSearch` method is provided which can be used by `ICacheLoader` implementations to locate the requested key in the distributed system. The `ICacheListener` interface can be used to listen to various region events after events such as create, update, or invalidate of region entries have occurred. The `ICacheWriter` interface is invoked before the events have occurred.
+
+## Using ICacheLoader to Load New Integers in the Region
+
+This example demonstrates an `ICacheLoader` implementation for loading new integers into a region.
+
+``` pre
+class SimpleCacheLoader<TKey, TVal> : ICacheLoader<TKey, TVal>
+{
+   #region ICacheLoader Members
+   public TVal Load(IRegion<TKey, TVal> region, TKey key, object helper)
+   {
+      Console.WriteLine("SimpleCacheLoader: Received Load event for region:
+      {0} and key: {1}", region.Name, key);
+      return default(TVal);
+   }
+   public void Close(IRegion<TKey, TVal> region)
+   {
+      Console.WriteLine("SimpleCacheLoader: Received Close event of region:
+      {0}", region.Name);
+   }
+   #endregion
+}
+```
+
+## Using ICacheWriter to Track Creates and Updates for a Region
+
+This example implements `ICacheWriter` to track region entry `create` and `update` events. This example just reports the events to the screen, but you can do whatever you need to do with the events.
+
+``` pre
+class SimpleCacheWriter<TKey, TVal> : ICacheWriter<TKey, TVal>
+{
+   #region ICacheWriter<TKey, TVal> Members
+   public bool BeforeUpdate(EntryEvent<TKey, TVal> ev)
+   {
+      Console.WriteLine("SimpleCacheWriter: Received BeforeUpdate event for: {0}", ev.Key);
+      return true;
+   }
+   // ... handle other entry events as needed
+   public bool BeforeRegionClear(RegionEvent<TKey, TVal> ev)
+   {
+      Console.WriteLine("SimpleCacheWriter: Received BeforeRegionClear event of region: {0}",
+      ev.Region.Name);
+      return true;
+   }
+   // ... handle other region events as needed
+   #endregion
+}
+```
+
+## A Sample ICacheListener Implementation
+
+This example implements `ICacheListener`.
+
+``` pre
+class SimpleCacheListener<TKey, TVal> : ICacheListener<TKey, TVal>
+{
+   #region ICacheListener<TKey, TVal> Members
+   public void AfterCreate(EntryEvent<TKey, TVal> ev)
+   {
+      Console.WriteLine("SimpleCacheListener: Received AfterCreate event
+      for: {0}", ev.Key);
+   }
+   // ... handle other entry events as needed
+   public void AfterRegionDestroy(RegionEvent<TKey, TVal> ev)
+   {
+      Console.WriteLine("SimpleCacheListener: Received AfterRegionDestroy
+      event of region: {0}", ev.Region.Name);
+   }
+   // ... handle other region events as needed
+   #endregion
+}
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/dotnet-caching-api/cache-apis.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/dotnet-caching-api/cache-apis.html.md.erb b/geode-docs/docs/geode-native-docs/dotnet-caching-api/cache-apis.html.md.erb
new file mode 100644
index 0000000..fa36a86
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/dotnet-caching-api/cache-apis.html.md.erb
@@ -0,0 +1,10 @@
+---
+title:  Cache APIs
+---
+
+This section describes the `CacheFactory` and `Cache` classes.
+
+-   **CacheFactory class**. Creates a `Cache` instance based on the provided distributed system and cache configuration. Any `gfcpp`.properties and `cache.xml` files provided to the application are used to initialize the system and cache. See [Setting System and Cache Properties](../setting-properties/chapter-overview.html#system_and_cache_properties). If a `cache.xml` file is used to create a cache and some of the regions already exist, a warning states that the regions exist and the cache is created.
+-   **Cache class**. Entry point to the Geode caching API. This class allows you to create regions. The cache is created by calling the `create` function of the `CacheFactory` class. When creating a cache, you specify a `DistributedSystem` that tells the new cache where to find other caches on the network and how to communicate with them.
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/dotnet-caching-api/cpp-class-to-dotnet-class-mappings.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/dotnet-caching-api/cpp-class-to-dotnet-class-mappings.html.md.erb b/geode-docs/docs/geode-native-docs/dotnet-caching-api/cpp-class-to-dotnet-class-mappings.html.md.erb
new file mode 100644
index 0000000..8a395f6
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/dotnet-caching-api/cpp-class-to-dotnet-class-mappings.html.md.erb
@@ -0,0 +1,164 @@
+---
+title:  C++ Class to .NET Class Mappings
+---
+
+Wherever the native C++ class methods use pass-by-reference semantics to return data, the corresponding .NET methods return the object instead of using pass-by-reference semantics.
+
+<a id="concept_FD847E19497C4985ACB247C0FA2C2AD5__table_8D8D228E223E4E89A313A17DB5C38652"></a>
+
+<table>
+<caption><span class="tablecap">Table 1. C++ Class to .NET Class Mappings</span></caption>
+<colgroup>
+<col width="50%" />
+<col width="50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th><p>C++ Class</p></th>
+<th><p>.NET Class</p></th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>class <code class="ph codeph">gemfire::AttributesFactory</code></td>
+<td>Sealed class <code class="ph codeph">AttributesFactory</code></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::AttributesMutator</code></p></td>
+<td>Sealed class <code class="ph codeph">AttributesMutator</code></td>
+</tr>
+<tr class="odd">
+<td>class <code class="ph codeph">gemfire::Cache</code></td>
+<td>Sealed class <code class="ph codeph">Cache</code></td>
+</tr>
+<tr class="even">
+<td><p>abstract class <code class="ph codeph">gemfire::Cacheable</code></p></td>
+<td><p>Interface <code class="ph codeph">IPdxSerializable</code> or interface <code class="ph codeph">IGFSerializable</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::CacheableBytes</code></p></td>
+<td><p><code class="ph codeph">Byte[]</code> or <code class="ph codeph">ArrayList&lt;Byte&gt;</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::Cacheableint32</code></p></td>
+<td><p><code class="ph codeph">Int32</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::CacheableString</code></p></td>
+<td><p><code class="ph codeph">String</code></p></td>
+</tr>
+<tr class="even">
+<td><p>abstract class <code class="ph codeph">gemfire::CacheableKey</code></p></td>
+<td><p>You can use any type that implements <code class="ph codeph">hashcode</code> and <code class="ph codeph">equals</code>. The generic .NET built-in types are all suitable.</p></td>
+</tr>
+<tr class="odd">
+<td><p>abstract class <code class="ph codeph">gemfire::CacheListener</code></p></td>
+<td><p>Interface <code class="ph codeph">ICacheListener</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::CacheLoader</code></p></td>
+<td><p>Interface <code class="ph codeph">ICacheLoader</code> plus static class <code class="ph codeph">CacheLoader</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::CacheWriter</code></p></td>
+<td><p>Interface class <code class="ph codeph">ICacheWriter</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::CacheFactory</code></p></td>
+<td><p>Sealed class <code class="ph codeph">CacheFactory</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::DataInput</code></p></td>
+<td><p>With <code class="ph codeph">IPdxSerializable</code>, <code class="ph codeph">IPdxReader.</code></p>
+<p>With <code class="ph codeph">IGFSerializable</code>, sealed class <code class="ph codeph">DataInput</code>.</p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::DataOutput</code></p></td>
+<td><p>With <code class="ph codeph">IPdxSerializable</code>, <code class="ph codeph">IPdxWriter.</code></p>
+<p>With <code class="ph codeph">IGFSerializable</code>, sealed class <code class="ph codeph">DataOutput</code> .</p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::DiskPolicyType</code></p></td>
+<td><p>enum <code class="ph codeph">DiskPolicyType</code> plus static class <code class="ph codeph">DiskPolicy</code> containing convenience methods for <code class="ph codeph">DiskPolicyType</code> enumeration</p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::DistributedSystem</code></p></td>
+<td><p>Sealed class <code class="ph codeph">Distr</code>ibutedSystem</p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::EntryEvent</code></p></td>
+<td><p>Sealed class <code class="ph codeph">EntryEvent</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::Exception</code></p></td>
+<td><p>Class <code class="ph codeph">GemfireException</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>all other exceptions deriving from <code class="ph codeph">gemfire::Exception</code></p></td>
+ <td><p>Corresponding exceptions deriving from <code class="ph codeph">GemfireException</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::ExpirationAction</code></p></td>
+<td><p>enum <code class="ph codeph">ExpirationAction</code> plus static class <code class="ph codeph">Expiration</code> containing convenience methods for <code class="ph codeph">ExpirationAction</code> enumeration</p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::Log</code></p></td>
+<td><p>Static class <code class="ph codeph">Log</code>. The native <code class="ph codeph">Log::log</code> method is mapped to <code class="ph codeph">Log.Write</code> to avoid the conflict with the class name which is reserved for the constructors of Log class. The various loglevel <code class="ph codeph">Throw</code> or <code class="ph codeph">Catch</code> methods are not implemented, since they are redundant to <code class="ph codeph">Log::Log</code> , <code class="ph codeph">Log::LogThrow</code>, and <code class="ph codeph">Log::LogCatch</code> methods that take <code class="ph codeph">LogLevel</code> as a parameter.</p></td>
+</tr>
+<tr class="even">
+<td><p>enum <code class="ph codeph">gemfire::MemberType</code></p></td>
+<td><p>enum <code class="ph codeph">MemberType</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>abstract class <code class="ph codeph">gemfire::PersistanceManager</code></p></td>
+<td><p>Not provided. You can register a C++ implementation using <code class="ph codeph">AttributesFactory.SetPersistenceManager</code> but you cannot implement a new one in .NET</p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::Properties</code></p></td>
+<td><p>Sealed class <code class="ph codeph">Properties</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::Properties::Visitor</code></p></td>
+<td><p>Delegate <code class="ph codeph">PropertiesVisitor</code></p></td>
+</tr>
+<tr class="even">
+<td><p>abstract class <code class="ph codeph">gemfire::Region</code></p></td>
+<td><p>Class <code class="ph codeph">IRegion</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::RegionAttributes</code></p></td>
+<td><p>Sealed class <code class="ph codeph">RegionAttributes</code></p></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::ScopeType</code></p></td>
+<td><p>enum <code class="ph codeph">ScopeType</code> plus static class <code class="ph codeph">Scope</code> containing convenience methods for <code class="ph codeph">ScopeType</code> enumeration+</p></td>
+</tr>
+<tr class="odd">
+<td><p>abstract class <code class="ph codeph">gemfire::Serializable</code></p></td>
+<td><p>Two options:</p>
+<ul>
+<li><p>Interface <code class="ph codeph">IPdxSerializable</code></p></li>
+<li><p>Interface <code class="ph codeph">IGFSerializable</code> plus wrapper <code class="ph codeph">Serializable</code> class for native <code class="ph codeph">Serializable</code> and <code class="ph codeph">UserData</code> objects. The native <code class="ph codeph">toString</code> method is not provided, since the <code class="ph codeph">ToString</code> method of the base object class provides the same functionality.</p></li>
+</ul></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::SystemProperties</code></p></td>
+<td><p>Sealed class <code class="ph codeph">SystemProperties</code></p></td>
+</tr>
+<tr class="odd">
+<td><p>class <code class="ph codeph">gemfire::UserData</code></p></td>
+<td><p>Two options:</p>
+<ul>
+<li><p>Interface <code class="ph codeph">IPdxSerializable</code></p></li>
+<li><p>Interface <code class="ph codeph">IGFSerializable</code></p></li>
+</ul></td>
+</tr>
+<tr class="even">
+<td><p>class <code class="ph codeph">gemfire::VectorT&lt;T&gt;</code></p></td>
+<td><p>Array of the given type, such as T[]</p></td>
+</tr>
+</tbody>
+</table>
+
+
+

http://git-wip-us.apache.org/repos/asf/geode/blob/de0559be/geode-docs/docs/geode-native-docs/dotnet-caching-api/creating-a-cache.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/docs/geode-native-docs/dotnet-caching-api/creating-a-cache.html.md.erb b/geode-docs/docs/geode-native-docs/dotnet-caching-api/creating-a-cache.html.md.erb
new file mode 100644
index 0000000..1613ba5
--- /dev/null
+++ b/geode-docs/docs/geode-native-docs/dotnet-caching-api/creating-a-cache.html.md.erb
@@ -0,0 +1,33 @@
+---
+title:  Creating a Cache
+---
+
+You create a cache using the Geode `CacheFactory.Create` call. Cache creation initializes the distributed system and creates the cache using your `gfcpp.properties` and `cache.xml` file settings and any additional properties you provide to the call.
+
+See [Setting System and Cache Properties](../setting-properties/chapter-overview.html#system_and_cache_properties) and see [Cache Initialization File](../cache-init-file/chapter-overview.html#chapter-overview).
+
+## Connecting and Creating the Cache
+
+In this example, the application connects to the distributed system and creates the cache using the available configuration files.
+
+The application becomes a distributed system member in the cache Create call.
+
+``` pre
+CacheFactory cacheFactory = CacheFactory.CreateCacheFactory();
+Cache cache = cacheFactory.Create();
+```
+
+## Providing Properties to the Cache Creation
+
+You can also create a cache by referencing a `cache.xml` file, as shown in the following example. You can use the `Properties` object to change any of the `gfcpp.properties` settings.
+
+``` pre
+Properties prop = Properties.Create();
+prop.Insert("cache-xml-file", "cache.xml");
+CacheFactory cacheFactory = CacheFactory.CreateCacheFactory(prop);
+Cache cache = cacheFactory.Create();
+```
+
+For systems with security enabled, the credentials for a joining member are authenticated when the cache is created and the system connection is made. For more information about secure connections to a distributed system, see [Security](../security/overviewsecurity.html#security).
+
+


Mime
View raw message