You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by db...@apache.org on 2017/04/04 16:26:36 UTC
[5/7] geode-native git commit: GEODE-2513: Rename and reorganize
client doc sources This closes #85
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb b/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
deleted file mode 100644
index 9b95e77..0000000
--- a/docs/geode-native-docs/cpp-caching-api/serialization_using_serializable.html.md.erb
+++ /dev/null
@@ -1,256 +0,0 @@
----
-title: Serializing Data with the Serializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The C++ client API provides a `Serializable` interface that you can use for fast and compact data serialization. This section discusses the Geode serializable interface, and presents implementation examples.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_8143F965A8C6495E8AB104FD36DA366A" class="no-quick-link"></a>How Serialization Works
-
-When your application puts an object into the cache for subsequent distribution, Geode serializes the data by taking these steps:
-
-1. Calls the appropriate `classId` function.
-2. Writes the full `typeId` using the `classId` for the instance.
-3. Invokes the instance\u2019s `toData` function.
-
-When your application subsequently receives a byte array, Geode takes the following steps:
-
-1. Decodes the `typeId`, extracts the `classId` from the `typeId`, then creates an object of the designated type using the registered factory functions.
-
-2. Invokes the `fromData` function with input from the data stream.
-3. Decodes the data, then populates the data fields.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_786CF85FD80E4FE391135460E04D46CC" class="no-quick-link"></a>Implementing the Serializable Interface
-
-To store your own data types in the cache, you need to derive a new subclass from the `Serializable` interface. In practical terms, this means that you need to implement a small set of helper functions:
-
-1. Write a `toData` function that serializes your data.
-
- ``` pre
- void toData (DataOutput& output)
- ```
-
- The `toData` function is responsible for copying all of the object\u2019s data fields to the object stream.
-
- The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order.
-
-2. Write a `fromData` function that consumes a data input stream and repopulates the object\u2019s data fields.
-
- ``` pre
- void fromData (DataInput& input)
- ```
-
- The `DataInput` class represents the input stream and provides methods for reading input elements. The `fromData` function must read the elements of the input stream in the same order that they were written by `toData`.
-
-## Example 1. The Simple Class BankAccount
-
-This example demonstrates a simple `BankAccount` class that encapsulates two `ints`, `ownerId` and `accountId`:
-
-``` pre
-class BankAccount
-{
- private:
-�
- int m_ownerId;
- int m_accountId;
-�
- public:
-�
- BankAccount( int owner, int account ): m_ownerId( owner ),
- m_accountId( account ) {}
-�
- int getOwner( )
- {
- return m_ownerId;
- }
-�
- int getAccount( )
- {
- return m_accountId;
- }
-�
-};
-```
-
-To make `BankAccount` serializable, you would need to derive the class from `Serializable` and implement the following:
-
-- `toData`\u2014a function to serialize the data.
-- `fromData`\u2014a function to deserialize the data.
-- `classId`\u2014a function to provide a unique integer for the class.
-- `TypeFactoryMethod`\u2014a pointer to a function that returns a `Serializable*` to an uninitialized instance of the type.
-
-## Example 2. Implementing a Serializable Class
-
-This example shows a code sample that demonstrates how to implement a serializable class.
-
-``` pre
-class BankAccount : public Serializable
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Add the following for the Serializable interface
-// Our TypeFactoryMethod
-static Serializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t classId( )
-{
- return 10; // must be unique per class.
-}
-
-virtual uint32_t objectSize() const
-{
- return 10;
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-Serializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_108942E549CE4DE68FF3956712DEC7AF" class="no-quick-link"></a>Registering the Type
-
-To be able to use the `BankAccount` type, you must register it with the type system so that when an incoming stream contains a `BankAccount`, it can be manufactured from the associated `TypeFactoryMethod`.
-
-``` pre
-Serializable::registerType( BankAccount::createInstance );
-```
-
-Typically, you would register the type before calling the function `DistributedSystem::connect`.
-
-**Note:**
-Type IDs must be unique to only one class.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_311C3661023C46328B406F26F4F16808" class="no-quick-link"></a>Custom Key Types
-
-If your application uses key types that are too complex to easily force into `CacheableString`, you can likely improve performance by deriving a new class from `CacheableKey`. If you have hybrid data types you can implement your own derivation of `CacheableKey` that encapsulates the data type.
-
-See below for information about implementing key types for a client that is used with a Java cache server.
-
-To extend a `Serializable` class to be a `CacheableKey`, you need to modify the class definition as follows:
-
-- Change the class so that it derives from `CacheableKey` rather than `Serializable`.
-
-- Implement `operator==` and `hashcode` functions.
-
-## Example 3. Extending a Serializable Class To Be a CacheableKey
-
-This example shows how to extend a serializable class to be a cacheable key.
-
-``` pre
-class BankAccount
-: public CacheableKey
-{
- private:
- int m_ownerId;
- int m_accountId;
- public:
- BankAccount( int owner, int account ) : m_ownerId( owner ),
- m_accountId( account ) {}
-
-int getOwner( )
-{
- return m_ownerId;
-}
-
-int getAccount( )
-{
- return m_accountId;
-}
-
-// Our TypeFactoryMethod
-static Serializable* createInstance( )
-{
- return new BankAccount( 0, 0 );
-}
-
-int32_t typeId( )
-{
- return 1000; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
- output.writeInt( m_ownerId );
- output.writeInt( m_accountId );
-}
-
-Serializable* fromData( DataInput& input )
-{
- input.readInt( &m_ownerId );
- input.readInt( &m_accountId );
- return this;
-}
-
-// Add the following for the CacheableKey interface
-bool operator == ( const CacheableKey& other ) const
-{
- const BankAccount& otherBA =
- static_cast<const BankAccount&>( other );
- return (m_ownerId == otherBA.m_ownerId) && (m_accountId == otherBA.m_accountId);
-}
-
-uint32_t hashcode( ) const
-{
- return m_ownerId;
-}
-
-virtual int32_t classId( )const
-{
- return 10; // must be unique per class.
-}
-�
-virtual uint32_t objectSize() const
-{
- return 10;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274" class="no-quick-link"></a>Serialization in Native Client Mode with a Java Server
-
-Primitive object types supported in all languages (`CacheableInt32`, `CacheableString`, `CacheableBytes`) function without requiring custom definitions with the Java cache server. For the keys, the Java cache server has to deserialize them and locate the hashcode to be able to insert the internal maps. Because of this, key types for C++ clients used with a Java server are required to be registered on the Java server, but the value types do not need to be registered. This needs to be done even if there are no Java clients.
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/type-interoperability.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/type-interoperability.html.md.erb b/docs/geode-native-docs/cpp-caching-api/type-interoperability.html.md.erb
new file mode 100644
index 0000000..57746f8
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/type-interoperability.html.md.erb
@@ -0,0 +1,63 @@
+---
+title: Interoperability of C++ Types When Using PDX Serialization
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+This topic table lists the mapping between C++ types and other language types when using PDX serialization.
+
+In addition, the table lists which PdxReader and PdxWriter C++ APIs to use when serializing and deserializing the types.
+
+| C++ Type | .NET Type | Java Type | PdxReader/PdxWriter API |
+|-----------------------------------|------------------------------------------------------------------|-------------------------|----------------------------------------------|
+| CacheableHashTable | System::Collections::Hashtable | java.util.Hashtable | readObject/writeObject |
+| CacheableHashMap | System::Collections ::Generic::IDictionary<Object, Object> | java.util.HashMap | readObject/writeObject |
+| CacheableVector | System::Collections::ArrayList | java.util.Vector | readObject/writeObject |
+| CacheableArrayList | System::Collections::�Generic::IList<Object> | java.util.ArrayList | readObject/writeObject |
+| bool | bool | boolean | readBoolean/writeBoolean |
+| int8\_t | sbyte | Byte | readByte/writeByte |
+| wchar\_t/char<sup>1</sup> | Char | Char | readChar/writeChar |
+| wchar\_t\*/char\*<sup>1</sup> | string | string | readString/writeString |
+| double | Double | double | readDouble/writeDouble |
+| float | float | float | readFloat/writeFloat |
+| int16\_t | short | short | readShort/writeShort |
+| int32\_t | Int32/int | int | readInt/writeInt |
+| int64\_t | Int64/long | long | readLong/writeLong |
+| int8\_t\* | System.Byte\[ \]/System.SByte\[ \] | Byte\[ \]<sup>2</sup> | readByteArray/writeByteArray |
+| double\* | System.Double\[ \] | Double\[ \] | readDoubleArray/writeDoubleArray |
+| float\* | System.float\[ \] | Float\[ \] | readFloatArray/writeFloatArray |
+| CacheableHashSet | CacheableHashSet | java.util.HashSet | readObject/writeObject |
+| CacheableLinkedHashSet | CacheableLinkedHashSet | java.util.LinkedHashSet | readObject/writeObject |
+| int16\_t\* | System.Int16\[ \] | Short\[ \] | readShortArray/writeShortArray |
+| int32\_t\* | System.Int32\[ \] | Int\[ \] | readIntArray/writeIntArray |
+| int64\_t\* | System.Int64\[ \] | Long\[ \] | readLongArray/writeLongArray |
+| bool\* | System.Boolean\[ \] | Boolean\[ \] | readBooleanArray/writeBooleanArray |
+| wchar\_t\*/char\*<sup>1</sup> | System.Char\[ \] | char\[ \] | readCharArray/writeCharArray |
+| enum<sup>3</sup> | enum | Enum | readObject/writeObject |
+| int8\_t\*\* | byte\[ \]\[ \]/Sbyte\[ \]\[ \] | Byte\[ \]\[ \] | readArrayOfByteArrays/writeArrayOfByteArrays |
+| wchar\_t\*\*/char\*\*<sup>1</sup> | System.String\[ \] | String\[ \] | readStringArray/writeStringArray |
+| CacheableDate | System.DateTime (UTC) | Java.util.date | readDate/writeDate |
+| CacheableObjectArray | object\[ \]/System.Object\[ \] | Object\[ \] | readObjectArray/writeObjectArray |
+| Cacheable/Serializable | object/System.Object | Object | readObject/writeObject |
+
+<sup>1</sup>C++ allows unicode and non-unicode characters, so C++ PDX will support both wchar\_t/char and wchar\_t\*/char\*.
+
+<sup>2</sup> For Pdx, only SByte is used, as Java Byte is signed. But for DataSerializable, Byte\[ \] array is used as a data container.
+
+<sup>3</sup>C++ allows explicit setting of ordinal numbers, but it is up to the developer to map the Java enumNames with C++ enumNames. See [Using C++ Enum Type with PDX Serialization](using-enum-type-with-pdx.html#concept_F38FDBC327204B4EB1E0BC74B4C95409).
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb b/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
deleted file mode 100644
index bb5f6d2..0000000
--- a/docs/geode-native-docs/cpp-caching-api/type_interoperability.html.md.erb
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: Interoperability of C++ Types When Using PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-This topic table lists the mapping between C++ types and other language types when using PDX serialization.
-
-In addition, the table lists which PdxReader and PdxWriter C++ APIs to use when serializing and deserializing the types.
-
-| C++ Type | .NET Type | Java Type | PdxReader/PdxWriter API |
-|-----------------------------------|------------------------------------------------------------------|-------------------------|----------------------------------------------|
-| CacheableHashTable | System::Collections::Hashtable | java.util.Hashtable | readObject/writeObject |
-| CacheableHashMap | System::Collections ::Generic::IDictionary<Object, Object> | java.util.HashMap | readObject/writeObject |
-| CacheableVector | System::Collections::ArrayList | java.util.Vector | readObject/writeObject |
-| CacheableArrayList | System::Collections::�Generic::IList<Object> | java.util.ArrayList | readObject/writeObject |
-| bool | bool | boolean | readBoolean/writeBoolean |
-| int8\_t | sbyte | Byte | readByte/writeByte |
-| wchar\_t/char<sup>1</sup> | Char | Char | readChar/writeChar |
-| wchar\_t\*/char\*<sup>1</sup> | string | string | readString/writeString |
-| double | Double | double | readDouble/writeDouble |
-| float | float | float | readFloat/writeFloat |
-| int16\_t | short | short | readShort/writeShort |
-| int32\_t | Int32/int | int | readInt/writeInt |
-| int64\_t | Int64/long | long | readLong/writeLong |
-| int8\_t\* | System.Byte\[ \]/System.SByte\[ \] | Byte\[ \]<sup>2</sup> | readByteArray/writeByteArray |
-| double\* | System.Double\[ \] | Double\[ \] | readDoubleArray/writeDoubleArray |
-| float\* | System.float\[ \] | Float\[ \] | readFloatArray/writeFloatArray |
-| CacheableHashSet | CacheableHashSet | java.util.HashSet | readObject/writeObject |
-| CacheableLinkedHashSet | CacheableLinkedHashSet | java.util.LinkedHashSet | readObject/writeObject |
-| int16\_t\* | System.Int16\[ \] | Short\[ \] | readShortArray/writeShortArray |
-| int32\_t\* | System.Int32\[ \] | Int\[ \] | readIntArray/writeIntArray |
-| int64\_t\* | System.Int64\[ \] | Long\[ \] | readLongArray/writeLongArray |
-| bool\* | System.Boolean\[ \] | Boolean\[ \] | readBooleanArray/writeBooleanArray |
-| wchar\_t\*/char\*<sup>1</sup> | System.Char\[ \] | char\[ \] | readCharArray/writeCharArray |
-| enum<sup>3</sup> | enum | Enum | readObject/writeObject |
-| int8\_t\*\* | byte\[ \]\[ \]/Sbyte\[ \]\[ \] | Byte\[ \]\[ \] | readArrayOfByteArrays/writeArrayOfByteArrays |
-| wchar\_t\*\*/char\*\*<sup>1</sup> | System.String\[ \] | String\[ \] | readStringArray/writeStringArray |
-| CacheableDate | System.DateTime (UTC) | Java.util.date | readDate/writeDate |
-| CacheableObjectArray | object\[ \]/System.Object\[ \] | Object\[ \] | readObjectArray/writeObjectArray |
-| Cacheable/Serializable | object/System.Object | Object | readObject/writeObject |
-
-<sup>1</sup>C++ allows unicode and non-unicode characters, so C++ PDX will support both wchar\_t/char and wchar\_t\*/char\*.
-
-<sup>2</sup> For Pdx, only SByte is used, as Java Byte is signed. But for DataSerializable, Byte\[ \] array is used as a data container.
-
-<sup>3</sup>C++ allows explicit setting of ordinal numbers, but it is up to the developer to map the Java enumNames with C++ enumNames. See [Using C++ Enum Type with PDX Serialization](using_enum_type_with_pdx.html#concept_F38FDBC327204B4EB1E0BC74B4C95409).
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using-enum-type-with-pdx.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using-enum-type-with-pdx.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using-enum-type-with-pdx.html.md.erb
new file mode 100644
index 0000000..b8d520e
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/using-enum-type-with-pdx.html.md.erb
@@ -0,0 +1,130 @@
+---
+title: Using C++ Enum Type with PDX Serialization
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+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 (geode::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-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
new file mode 100644
index 0000000..847f32a
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/using-pdxinstance.html.md.erb
@@ -0,0 +1,59 @@
+---
+title: Programming Your Application to Use PdxInstances
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. Geode provides the implementation of the `PdxInstance` class.
+
+You can configure your cache to return a `PdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. Preventing deserialization saves both time and memory and does not require you deserialize the object to the domain class.
+
+This configuration can be done in cache.xml by setting the attribute `read-serialized` to `true` on the <pdx>element. Or it can be done programmatically using the `CacheFactory::setPdxReadSerialized(bool)` method.
+
+After this preference is configured, any time a PDX object is deserialized, it is deserialized into a `PdxInstance`.
+
+The following is a code sample of using the setField API of PdxInstance to modify fields:
+
+``` pre
+RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
+CacheableKeyPtr keyport = CacheableKey::create("pdxput");
+CacheableKeyPtr keyport1 = CacheableKey::create("pdxput2");
+
+PdxInstancePtr pIPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
+LOG( "modifyPdxInstance get complete." );
+
+WritablePdxInstancePtr wpiPtr( pIPtr->createWriter());
+
+ASSERT(pIPtr != NULLPTR, "pIPtr != NULLPTR expected");
+int val = 0;
+int newVal = 0;
+ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
+pIPtr->getField("m_int32", val);
+wpiPtr->setField("m_int32", val + 1);
+rptr->put(keyport, wpiPtr);
+PdxInstancePtr newPiPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
+ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
+newPiPtr->getField("m_int32", newVal);
+ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
+ASSERT((*pIPtr.ptr() == *newPiPtr.ptr()) == false,
+ "PdxInstance should not be equal");
+```
+
+In addition to field access, `PdxInstance` also supports field modification using the `setField(fieldName)` method. The `setField` method has copy-on-write semantics. So for the modifications to be stored in the cache, the `PdxInstance` must be put into a region after `setField` has been called one or more times.
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb
new file mode 100644
index 0000000..940f67a
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/using-pdxinstancefactory.html.md.erb
@@ -0,0 +1,134 @@
+---
+title: Using PdxInstanceFactory to Create PdxInstances
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+You can 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 Geode 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 & geodeExcp)
+ {
+ LOGERROR("PdxInstance Exception: %s", geodeExcp.getMessage());
+ }
+}
+```
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
new file mode 100644
index 0000000..7df9135
--- /dev/null
+++ b/docs/geode-native-docs/cpp-caching-api/using-pdxserializer.html.md.erb
@@ -0,0 +1,119 @@
+---
+title: Serialize Your Domain Objects with PdxSerializer and PdxWrapper
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+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-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
deleted file mode 100644
index b8d520e..0000000
--- a/docs/geode-native-docs/cpp-caching-api/using_enum_type_with_pdx.html.md.erb
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: Using C++ Enum Type with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-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 (geode::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-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
deleted file mode 100644
index 847f32a..0000000
--- a/docs/geode-native-docs/cpp-caching-api/using_pdxinstance.html.md.erb
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Programming Your Application to Use PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. Geode provides the implementation of the `PdxInstance` class.
-
-You can configure your cache to return a `PdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. Preventing deserialization saves both time and memory and does not require you deserialize the object to the domain class.
-
-This configuration can be done in cache.xml by setting the attribute `read-serialized` to `true` on the <pdx>element. Or it can be done programmatically using the `CacheFactory::setPdxReadSerialized(bool)` method.
-
-After this preference is configured, any time a PDX object is deserialized, it is deserialized into a `PdxInstance`.
-
-The following is a code sample of using the setField API of PdxInstance to modify fields:
-
-``` pre
-RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
-CacheableKeyPtr keyport = CacheableKey::create("pdxput");
-CacheableKeyPtr keyport1 = CacheableKey::create("pdxput2");
-
-PdxInstancePtr pIPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-LOG( "modifyPdxInstance get complete." );
-
-WritablePdxInstancePtr wpiPtr( pIPtr->createWriter());
-
-ASSERT(pIPtr != NULLPTR, "pIPtr != NULLPTR expected");
-int val = 0;
-int newVal = 0;
-ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
-pIPtr->getField("m_int32", val);
-wpiPtr->setField("m_int32", val + 1);
-rptr->put(keyport, wpiPtr);
-PdxInstancePtr newPiPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
-newPiPtr->getField("m_int32", newVal);
-ASSERT(val + 1 == newVal, "val + 1 == newVal expected");
-ASSERT((*pIPtr.ptr() == *newPiPtr.ptr()) == false,
- "PdxInstance should not be equal");
-```
-
-In addition to field access, `PdxInstance` also supports field modification using the `setField(fieldName)` method. The `setField` method has copy-on-write semantics. So for the modifications to be stored in the cache, the `PdxInstance` must be put into a region after `setField` has been called one or more times.
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
deleted file mode 100644
index 940f67a..0000000
--- a/docs/geode-native-docs/cpp-caching-api/using_pdxinstancefactory.html.md.erb
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Using PdxInstanceFactory to Create PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-You can 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 Geode 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 & geodeExcp)
- {
- LOGERROR("PdxInstance Exception: %s", geodeExcp.getMessage());
- }
-}
-```
-
-
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb b/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
deleted file mode 100644
index 7df9135..0000000
--- a/docs/geode-native-docs/cpp-caching-api/using_pdxserializer.html.md.erb
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: Serialize Your Domain Objects with PdxSerializer and PdxWrapper
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-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-native/blob/1dbe9e61/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
index 40613e5..ceb14dd 100644
--- a/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
@@ -21,7 +21,7 @@ limitations under the License.
This section describes the primary classes, usage conventions, and C++ to .NET class mappings of the .NET client API. It demonstrates how to use the API to create caches and perform data serialization.
-See the [.NET API](/releases/latest/api/dotnetdocs) documentation for API details.
+See the [.NET API](http://geode.apache.org/docs/) documentation for API details.
- **[About the .NET Client API](csharp-dotnet-api.html)**
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
index 018b4d6..a42f725 100644
--- a/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
+++ b/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
@@ -39,6 +39,6 @@ A `DSFID` is an integer that returns the data serialization fixed ID type. `DSFI
If your application uses its own key types that are too complex to easily force into string, you can probably improve performance by using a custom type and implementing `HashCode` and `Equals` functions. For example, if you have hybrid data types such as floating point numbers, you can implement your own type that encapsulates the floating point number. Comparing floating point numbers in this way provides greater performance than comparing a string representation of the floating point numbers, with such noticeable improvements as faster cache access and smaller payloads.
-See [Serialization in Native Client Mode with a Java Server](../cpp-caching-api/serialization_using_serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274) for information about implementing key types for a client that is used with a Java cache server.
+See [Serialization in Native Client Mode with a Java Server](../cpp-caching-api/serialization-using-serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274) for information about implementing key types for a client that is used with a Java cache server.
To extend a type that implements `IPdxSerializable` or `IGeodeSerializable` for your key, override and implement the `HashCode` and `Equals` methods in the key as needed.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/getting_started/system_requirements/#client_requirements.html.md.erb#
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/getting_started/system_requirements/#client_requirements.html.md.erb# b/docs/geode-native-docs/getting_started/system_requirements/#client_requirements.html.md.erb#
deleted file mode 100644
index 37bade1..0000000
--- a/docs/geode-native-docs/getting_started/system_requirements/#client_requirements.html.md.erb#
+++ /dev/null
@@ -1,194 +0,0 @@
----
-title: Geode Client Requirements
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The Apache Geode client provides access for C++ and Microsoft\ufffd\ufffd .NET\ufffd\ufffd\ufffd\ufffd clients to the Geode distributed system. It is known to operate on platforms running Microsoft Windows, Linux (Intel), and Sun Solaris.
-
-Operating system requirements are listed in the chart below:
-
-
-<table style="width:100%;">
-<colgroup>
-<col width="20%" />
-<col width="20%" />
-<col width="20%" />
-<col width="20%" />
-<col width="20%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Operating System</th>
-<th>Processor and Architecture</th>
-<th>RAM</th>
-<th>Swap Space</th>
-<th>64-Bit Disk Space Required</th>
-</tr>
-</thead>
-<tbody>
-<tr class="even">
-<td>Solaris 11</td>
-<td>x86-64
-</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>90MB</td>
-</tr>
-<tr class="odd">
-<td>RHEL 6 (<b>deprecated</b>)</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>120MB</td>
-</tr>
-<tr class="odd">
-<td>RHEL 7</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>120MB</td>
-</tr>
-<tr class="even">
-<td>SLES 11** (<b>deprecated</b>)</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>120MB</td>
-</tr>
-<tr class="even">
-<td>SLES 12**</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>120MB</td>
-</tr>
-<tr class="odd">
-<td>Windows 2012 Server R2</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>125MB</td>
-</tr>
-<tr class="even">
-<td>Windows 8.1 (<b>deprecated</b>)</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>125MB</td>
-</tr>
-<tr class="odd">
-<td>Windows 10</td>
-<td>x86-64</td>
-<td>2GB</td>
-<td>256MB</td>
-<td>125MB</td>
-</tr>
-</tbody>
-</table>
-
-\*\*Indicates operating systems that have not been fully tested but are still supported.
-
-## Host Machine Requirements
-
-Each machine that runs a native client must meet the following requirements:
-
-- A system clock set to the correct time and a time synchronization
-service such as Network Time Protocol (NTP).
-Correct time stamps permit the following activities:
- - Logs that are useful for troubleshooting. Synchronized time stamps ensure that log messages from different hosts can be merged to reproduce an accurate chronological history of a distributed run.
- - Aggregate product-level and application-level time statistics.
- - Accurate monitoring of the system with scripts and other tools that read the system statistics and log files.
-- The host name and host files are properly configured for the machine.
-- Many default Linux installations use SYN cookies to protect the
-system against malicious attacks that flood TCP SYN packets.
-The use of SYN cookies dramatically reduces network bandwidth,
-and can be triggered by a running GemFire distributed system.
-
- To disable SYN cookies permanently:
- 1. Edit the `/etc/sysctl.conf` file to include the following line:
-
- ``` pre
- net.ipv4.tcp_syncookies = 0
- ```
- Setting this value to zero disables SYN cookies.
- 2. Reload `sysctl.conf`:
-
- ``` pre
- sysctl -p
- ```
-
-## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__section_3A8A0684D68E467EBA498D939E91C5AA" class="no-quick-link"></a>Windows Support Details
-
-**Runtime Library Requirements**
-
-The GemFire native client also requires the Microsoft Visual C++ 2013 Redistributable Package. This package is installed for you when you use the native client .msi installer. If you do not use the .msi installer, you will need to install this package for your platform architecture manually ([x86-64](https://www.microsoft.com/en-us/download/details.aspx?id=40784)) on all machines that will run the GemFire native client. This package contains runtime libraries needed by the native client.
-
-**.NET Framework Version Support**
-
-The Pivotal GemFire native client is supported with Microsoft .NET Framework 4.5.2.
-
-A Microsoft .NET Framework must be installed to support the C++/CLI (Common Language Infrastructure) library for the native client.
-
-The Pivotal GemFire native client 9.0 supports .NET 4.5.2 and Visual Studio 2013 (for compiling C++ applications on Windows). For more information on the features of .NET and Visual Studio Community Edition 2013 Update 5, see [https://msdn.microsoft.com/en-us/library/dd831853(v=vs.120).aspx](https://msdn.microsoft.com/en-us/library/dd831853(v=vs.120).aspx) .
-
-## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__section_C5848F353C504844BAFFD3EB2BE7DA23" class="no-quick-link"></a>Linux
-
-The following table lists the RPM package dependencies for the Linux distribution. The i386 or i686 after the package name indicates that you must install the package for that particular architecture regardless of the native operating system architecture. All of the packages listed are available with the default media for the distribution.
-
-<a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__table_C809C11B1624423EAD4ABA21636C2F10"></a>
-
-| Linux Version | glibc | libgcc |
-|-----------------------------------------------------|--------------|---------------|
-| Red Hat Enterprise Linux Server release 7 (x86-64) | glibc (i686) | libgcc (i386) |
-
-
-For versions of Linux not listed in the table, you can verify that you meet the native client dependencies at the library level by using the `ldd` tool and entering this command:
-
-``` pre
-prompt> ldd $GFCPP/lib/libgfcppcache.so
-```
-
-This step assumes you have already installed the native client and have set the GFCPP environment variable to *productDir*, where *productDir* represents the location of the NativeClient\_*xxxx*\_b*nnnnn* directory (*xxxx* is the four-digit product version and b*nnnnn* is the product build number).
-
-The following libraries are external dependencies of the native library, `libgfcppcache.so`. Verify that the ldd tool output includes all of these:
-
-- libdl.so.2
-- libm.so.6
-- libpthread.so.0
-- libc.so.6
-- libz.so.1
-
-
-## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__section_07CB50BE132D482B8F99154B81C6D2A4" class="no-quick-link"></a>Running Pivotal GemFire Native Client on vSphere
-
-Without tuning, the Pivotal GemFire native client can suffer a performance drop in virtual environments, including the VMware vSphere virtual platform. Without correct tuning, you can expect to see significant performance degradation when running the GemFire native client on vSphere versus running GemFire on dedicated hardware.
-
-We recommend that you tune your GemFire native client on vSphere deployments using the same guidelines published for Pivotal GemFire.
-
-See [Improving GemFire Performance on vSphere](geodeman/managing/monitor_tune/gemfire_performance_on_vsphere.html) for a list of guidelines and recommendations.
-
-## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__ssl_requirements" class="no-quick-link"></a>Software Requirements for Using SSL
-
-If you plan on using SSL in your GemFire native client and server deployment, you will need to download and install OpenSSL.
-
-The GemFire native client requires OpenSSL 1.0.1t or later. For Windows platforms, you can use either the regular or the OpenSSL "Light" version.
-
-In addition, make sure that your system environment variables have been configured to include OpenSSL.
-
-See [SSL Client/Server Communication](../../security/overviewsslclientserver.html#security) for instructions.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/introduction/client-configurations.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/introduction/client-configurations.html.md.erb b/docs/geode-native-docs/introduction/client-configurations.html.md.erb
new file mode 100644
index 0000000..5c9c712
--- /dev/null
+++ b/docs/geode-native-docs/introduction/client-configurations.html.md.erb
@@ -0,0 +1,164 @@
+---
+title: Apache Geode Client Configurations
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+The Apache Geode client provides access for C++ and Microsoft� .NET\u2122 clients to the Geode distributed system.
+As an open source project, the client (at least theoretically) can be built on nearly any system.
+In practical terms, the client is known to have been successfully built and used on platforms running Microsoft Windows, Linux (Intel), and Sun Solaris.
+
+For your convenience, this table shows configuration guidelines for some familiar operating systems.
+
+
+<table style="width:100%;">
+<colgroup>
+<col width="20%" />
+<col width="20%" />
+<col width="20%" />
+<col width="20%" />
+<col width="20%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Operating System</th>
+<th>Processor and Architecture</th>
+<th>RAM</th>
+<th>Swap Space</th>
+<th>64-Bit Disk Space Required</th>
+</tr>
+</thead>
+<tbody>
+<tr class="even">
+<td>Solaris 11</td>
+<td>x86-64
+</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>90MB</td>
+</tr>
+<tr class="odd">
+<td>RHEL 7</td>
+<td>x86-64</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>120MB</td>
+</tr>
+<tr class="even">
+<td>SLES 12</td>
+<td>x86-64</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>120MB</td>
+</tr>
+<tr class="odd">
+<td>Windows 2012 Server R2</td>
+<td>x86-64</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>125MB</td>
+</tr>
+<tr class="odd">
+<td>Windows 10</td>
+<td>x86-64</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>125MB</td>
+</tr>
+<tr class="odd">
+<td>macOS 10.12 (Sierra)</td>
+<td>x86-64</td>
+<td>2GB</td>
+<td>256MB</td>
+<td>125MB</td>
+</tr>
+</tbody>
+</table>
+
+## Host Machine Configuration Guidelines
+
+Each machine that runs a Geode client should meet the following guidelines:
+
+- A system clock set to the correct time and a time synchronization
+service such as Network Time Protocol (NTP).
+Correct time stamps permit the following activities:
+ - Logs that are useful for troubleshooting. Synchronized time stamps ensure that log messages from different hosts can be merged to reproduce an accurate chronological history of a distributed run.
+ - Aggregate product-level and application-level time statistics.
+ - Accurate monitoring of the system with scripts and other tools that read the system statistics and log files.
+- The host name and host files are properly configured for the machine.
+- Many default Linux installations use SYN cookies to protect the
+system against malicious attacks that flood TCP SYN packets.
+The use of SYN cookies dramatically reduces network bandwidth,
+and can be triggered by a running GemFire distributed system.
+
+ To disable SYN cookies permanently:
+ 1. Edit the `/etc/sysctl.conf` file to include the following line:
+
+ ``` pre
+ net.ipv4.tcp_syncookies = 0
+ ```
+ Setting this value to zero disables SYN cookies.
+ 2. Reload `sysctl.conf`:
+
+ ``` pre
+ sysctl -p
+ ```
+
+## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__section_3A8A0684D68E467EBA498D939E91C5AA" class="no-quick-link"></a>Windows Guidelines
+
+**Runtime Library**
+
+The Geode client requires the [Microsoft Visual C++ 2013 Redistributable Package](https://www.microsoft.com/en-us/download/details.aspx?id=40784).
+This package contains runtime libraries needed by the client; install it for your platform architecture on all machines that will run the client.
+
+**.NET Framework Version Support**
+
+The Geode client is supported with Microsoft .NET Framework 4.5.2.
+
+A Microsoft .NET Framework must be installed to support the C++/CLI (Common Language Infrastructure) library for the client.
+
+The Geode supports .NET 4.5.2 and Visual Studio 2013 (for compiling C++ applications on Windows).
+For more information on the features of .NET and Visual Studio Community Edition 2013 Update 5, see the [Visual Studio 2013 web page](https://msdn.microsoft.com/en-us/library/dd831853(v=vs.120).aspx).
+
+## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__section_C5848F353C504844BAFFD3EB2BE7DA23" class="no-quick-link"></a>Linux
+
+For Linux, you can verify that you meet the client dependencies at the library level by using the `ldd` tool and entering this command:
+
+``` pre
+prompt> ldd $client-installdir/lib/libgfcppcache.so
+```
+where _client-installdir_ is the location in which you have installed the Geode client.
+
+The following libraries are external dependencies of the client library, `libgfcppcache.so`. Verify that the ldd tool output includes all of these:
+
+- libdl.so.2
+- libm.so.6
+- libpthread.so.0
+- libc.so.6
+- libz.so.1
+
+
+## <a id="concept_7AE0C1CB11244095A50CCB52A09A09A1__ssl_requirements" class="no-quick-link"></a>Software Requirements for Using SSL
+
+If you plan on using SSL in your Geode client and server deployment, you will need to download and install OpenSSL.
+
+The client requires OpenSSL 1.0.1t or later. For Windows platforms, you can use either the regular or the OpenSSL "Light" version.
+
+In addition, make sure that your system environment variables have been configured to include OpenSSL.
+
+See [SSL Client/Server Communication](../security/sslclientserver.html) for instructions.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/introduction/client-intro.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/introduction/client-intro.html.md.erb b/docs/geode-native-docs/introduction/client-intro.html.md.erb
new file mode 100644
index 0000000..f926896
--- /dev/null
+++ b/docs/geode-native-docs/introduction/client-intro.html.md.erb
@@ -0,0 +1,38 @@
+---
+title: Getting Started with the Client
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+This section shows you how to build the product and run the quick start examples.
+
+The Geode client provides access for C++ and Microsoft<sup>�</sup> .NET\u2122 clients to a Geode distributed system.
+
+- **[System Configurations](client-configurations.html)**
+
+ Configuration guidelines for some familiar operating systems.
+
+- **[Installing the Client](install-overview.html)**
+
+ Procedures for building the client libraries from a source distribution.
+
+- **[QuickStart Examples](quickstart.html)**
+
+ Run the native client QuickStart examples to understand client functionality.
+
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/1dbe9e61/docs/geode-native-docs/introduction/client-overview.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/introduction/client-overview.html.md.erb b/docs/geode-native-docs/introduction/client-overview.html.md.erb
new file mode 100644
index 0000000..0090cd2
--- /dev/null
+++ b/docs/geode-native-docs/introduction/client-overview.html.md.erb
@@ -0,0 +1,37 @@
+---
+title: About the Client
+---
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+The Geode client delivers the full set of capabilities supplied by Java clients communicating with a Geode server.
+
+The Geode client is written entirely in C++, so its initialization process does not involve the creation of a Java virtual machine. The .NET client provides operations for the .NET Framework application developer who writes in .NET languages and needs to access the Geode server.
+
+Clients in C++, Java, and .NET languages communicate only with the cache server and do not communicate with each other. The clients interface with the server at the sockets level and implement the same wire protocol to the server. These capabilities produce extremely high performance and system scalability.
+
+C++ and .NET clients provide access to the full region API, including support for application plug-ins, managed connectivity, highly available data, and reliable failover to a specified server list. All of this is transparent to the end user.
+
+You can configure clients to cache data locally, or they can act in a cacheless mode where they retrieve data from a cache server and directly pass it to other system members without incurring the caching overhead. They can be configured as read only caches, or be configured to receive notifications from the server whenever a key of interest to the client changes on the server.
+
+This figure diagrams how .NET and C++ applications access the cache server. <a id="concept_BCE696D352144690ADF786A0E3D2BD98__fig_C19B4B30942D4F1BA59DBDCC6146241A"></a>
+
+
+<img src="../common/images/client-overview.gif" alt="Client Overview" id="concept_BCE696D352144690ADF786A0E3D2BD98__image_A0805B5079C64B0E8F2E9DA2A8A5A7A6" class="image" />
+
+