geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [01/34] geode-native git commit: GEODE-2441: Remove leftover pdx auto serializer references [Forced Update!]
Date Wed, 15 Mar 2017 17:51:02 GMT
Repository: geode-native
Updated Branches:
  refs/heads/feature/GEODE-2602 cf68eff24 -> 57e915b28 (forced update)


GEODE-2441: Remove leftover pdx auto serializer references

This closes #42.


Project: http://git-wip-us.apache.org/repos/asf/geode-native/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode-native/commit/7da9d90b
Tree: http://git-wip-us.apache.org/repos/asf/geode-native/tree/7da9d90b
Diff: http://git-wip-us.apache.org/repos/asf/geode-native/diff/7da9d90b

Branch: refs/heads/feature/GEODE-2602
Commit: 7da9d90bdd28619193b044be9ab3a226c50ffd0c
Parents: 5d9e713
Author: David Kimura <dkimura@pivotal.io>
Authored: Tue Feb 28 13:18:32 2017 -0800
Committer: Jacob Barrett <jbarrett@pivotal.io>
Committed: Tue Mar 7 16:54:26 2017 -0800

----------------------------------------------------------------------
 LICENSE                                         |  10 -
 dist/LICENSE                                    |  11 -
 .../include/geode/PdxAutoSerializer.hpp         | 529 -------------------
 src/cppcache/integration-test/test.sh.in        |   1 -
 src/cppcache/integration-test/testHeaders.sh    |  62 ---
 src/pdxautoserializer/ASCLIBuiltins.hpp         | 462 ----------------
 src/quickstart/cpp/CMakeLists.txt               |  22 -
 src/quickstart/cpp/PdxAutoSerializer.cpp        | 149 ------
 src/quickstart/runcpp.bat.in                    |   6 +-
 src/quickstart/runcpp.sh.in                     |   6 +-
 src/tests/cpp/CMakeLists.txt                    |   1 -
 src/tests/cpp/fwklib/QueryHelper.hpp            |  62 +--
 .../cpp/pdxautoserializerclass/CMakeLists.txt   |  38 --
 .../cpp/pdxautoserializerclass/PortfolioPdx.cpp | 199 -------
 .../cpp/pdxautoserializerclass/PortfolioPdx.hpp | 116 ----
 .../cpp/pdxautoserializerclass/PositionPdx.cpp  | 176 ------
 .../cpp/pdxautoserializerclass/PositionPdx.hpp  | 112 ----
 src/tests/cpp/security/CMakeLists.txt           |   1 -
 src/tests/cpp/testobject/CMakeLists.txt         |   4 -
 19 files changed, 5 insertions(+), 1962 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/LICENSE
----------------------------------------------------------------------
diff --git a/LICENSE b/LICENSE
index 81d5672..2d176dc 100644
--- a/LICENSE
+++ b/LICENSE
@@ -245,13 +245,3 @@ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
----------------------------------------------------------------------------
-Public Domain
----------------------------------------------------------------------------
-
-Apache Geode bundles the following files, which are available in the public
-domain:
-
-  - PUBLIC DOMAIN PCCTS-BASED C++ GRAMMAR (http://www.antlr2.org/)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/dist/LICENSE
----------------------------------------------------------------------
diff --git a/dist/LICENSE b/dist/LICENSE
index 5048591..6772aa9 100644
--- a/dist/LICENSE
+++ b/dist/LICENSE
@@ -317,14 +317,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-
----------------------------------------------------------------------------
-Public Domain
----------------------------------------------------------------------------
-
-Apache Geode bundles the following files, which are available in the public
-domain:
-
-  - ANTLRv2 (http://www.antlr2.org/)
-  - PUBLIC DOMAIN PCCTS-BASED C++ GRAMMAR (http://www.antlr2.org/)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/cppcache/include/geode/PdxAutoSerializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/PdxAutoSerializer.hpp b/src/cppcache/include/geode/PdxAutoSerializer.hpp
deleted file mode 100644
index e4b7af4..0000000
--- a/src/cppcache/include/geode/PdxAutoSerializer.hpp
+++ /dev/null
@@ -1,529 +0,0 @@
-#pragma once
-
-#ifndef GEODE_PDXAUTOSERIALIZER_H_
-#define GEODE_PDXAUTOSERIALIZER_H_
-
-/*
- * 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.
- */
-
-#include "geode_globals.hpp"
-#include "PdxWriter.hpp"
-#include "PdxReader.hpp"
-#include "VectorT.hpp"
-#include "HashMapT.hpp"
-#include "HashSetT.hpp"
-#include "GeodeTypeIds.hpp"
-#include "TypeHelper.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-namespace PdxAutoSerializable {
-// Read and write methods for various types
-// uint8_t
-//------------------------------------------------------------------------------------------------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int8_t value) {
-  pw->writeByte(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int8_t& value) {
-  value = pr->readByte(fieldName);
-}
-#else
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, char value) {
-  pw->writeChar(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, char& value) {
-  value = pr->readChar(fieldName);
-}
-#endif
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, wchar_t value) {
-  pw->writeWideChar(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, wchar_t& value) {
-  value = pr->readWideChar(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, bool value) {
-  pw->writeBoolean(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, bool& value) {
-  value = pr->readBoolean(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, signed char value) {
-  pw->writeByte(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, signed char& value) {
-  value = pr->readByte(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int16_t value) {
-  pw->writeShort(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int16_t& value) {
-  value = pr->readShort(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int32_t value) {
-  pw->writeInt(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int32_t& value) {
-  value = pr->readInt(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int64_t value) {
-  pw->writeLong(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int64_t& value) {
-  value = pr->readLong(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, float value) {
-  pw->writeFloat(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, float& value) {
-  value = pr->readFloat(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, double value) {
-  pw->writeDouble(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, double& value) {
-  value = pr->readDouble(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, CacheableDatePtr value) {
-  pw->writeDate(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, CacheableDatePtr& value) {
-  value = pr->readDate(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, const char* value) {
-  pw->writeString(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, char*& value) {
-  value = pr->readString(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, const wchar_t* value) {
-  pw->writeWideString(fieldName, value);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, wchar_t*& value) {
-  value = pr->readWideString(fieldName);
-}
-// ---- helper methods for bytearrayofarray -------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, char** value,
-                           int32_t arraySize, int32_t* elemArraySize) {
-  pw->writeArrayOfByteArrays(fieldName, (char**)value, arraySize,
-                             elemArraySize);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, char**& value, int32_t& len,
-                          int32_t*& Lengtharr) {
-  GF_NEW(Lengtharr, int32_t[len]);
-  value = (char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
-}
-#else
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int8_t** value,
-                           int32_t arraySize, int32_t* elemArraySize) {
-  pw->writeArrayOfByteArrays(fieldName, value, arraySize, elemArraySize);
-}
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int8_t**& value, int32_t& len,
-                          int32_t*& Lengtharr) {
-  GF_NEW(Lengtharr, int32_t[len]);
-  value = (signed char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
-}
-#endif
-
-//------------------------------------------------------------------------------------------------
-// Base Serializable types
-template <typename TObj>
-inline void writePdxObject(
-    apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
-    const apache::geode::client::SharedPtr<TObj>& value,
-    apache::geode::client::TypeHelper::yes_type isSerializable) {
-  pw->writeObject(fieldName, value);
-}
-
-template <typename TObj>
-inline void writePdxObject(
-    apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
-    const apache::geode::client::SharedPtr<TObj>& value) {
-  writePdxObject(pw, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
-}
-
-template <typename TObj>
-inline void readPdxObject(
-    apache::geode::client::PdxReaderPtr& pr, const char* fieldName,
-    apache::geode::client::SharedPtr<TObj>& value,
-    apache::geode::client::TypeHelper::yes_type isSerializable) {
-  value = dynCast<apache::geode::client::SharedPtr<TObj> >(
-      pr->readObject(fieldName));
-}
-
-template <typename TObj>
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName,
-                          apache::geode::client::SharedPtr<TObj>& value) {
-  readPdxObject(pr, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, bool* value, int32_t len) {
-  pw->writeBooleanArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, bool*& value, int32_t& len) {
-  value = pr->readBooleanArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, wchar_t* value, int32_t len) {
-  pw->writeWideCharArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, wchar_t*& value,
-                          int32_t& len) {
-  value = pr->readWideCharArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-#ifdef _SOLARIS
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int8_t* value, int32_t len) {
-  pw->writeByteArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int8_t*& value, int32_t& len) {
-  value = (int8_t*)pr->readByteArray(fieldName, len);
-}
-#else
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, char* value, int32_t len) {
-  pw->writeCharArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, char*& value, int32_t& len) {
-  value = pr->readCharArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, signed char* value,
-                           int32_t len) {
-  pw->writeByteArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, signed char*& value,
-                          int32_t& len) {
-  value = (signed char*)pr->readByteArray(fieldName, len);
-}
-#endif
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int16_t* value, int32_t len) {
-  pw->writeShortArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int16_t*& value,
-                          int32_t& len) {
-  value = pr->readShortArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int32_t* value, int32_t len) {
-  pw->writeIntArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int32_t*& value,
-                          int32_t& len) {
-  value = pr->readIntArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, int64_t* value, int32_t len) {
-  pw->writeLongArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, int64_t*& value,
-                          int32_t& len) {
-  value = pr->readLongArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, float* value, int32_t len) {
-  pw->writeFloatArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, float*& value, int32_t& len) {
-  value = pr->readFloatArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, double* value, int32_t len) {
-  pw->writeDoubleArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, double*& value, int32_t& len) {
-  value = pr->readDoubleArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, char** value, int32_t len) {
-  pw->writeStringArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, char**& value, int32_t& len) {
-  value = pr->readStringArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName, wchar_t** value,
-                           int32_t len) {
-  pw->writeWideStringArray(fieldName, value, len);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName, wchar_t**& value,
-                          int32_t& len) {
-  value = pr->readWideStringArray(fieldName, len);
-}
-//------------------------------------------------------------------------------------------------
-inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
-                           const char* fieldName,
-                           CacheableObjectArrayPtr value) {
-  pw->writeObjectArray(fieldName, value);
-}
-
-inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
-                          const char* fieldName,
-                          CacheableObjectArrayPtr& value) {
-  value = pr->readObjectArray(fieldName);
-}
-//------------------------------------------------------------------------------------------------
-// For containers vector/hashmap/hashset
-// template <typename TObj>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
-// char*
-// fieldName,
-//    const VectorT< TObj >& value )
-//{
-//  int32_t len = (int32_t)value.size();
-//  pw->writeArrayLen( len );
-//  for ( typename VectorT< TObj >::Iterator iter = value.begin( );
-//      iter != value.end( ); ++iter ) {
-//    writePdxObject( output, *iter );
-//  }
-//}
-
-// inline uint32_t objectSize( const _VectorOfCacheable& value )
-//{
-//  uint32_t objectSize = 0;
-//  for ( _VectorOfCacheable::Iterator iter = value.begin( );
-//      iter != value.end( ); ++iter ) {
-//    if (*iter != NULLPTR) {
-//      objectSize += (*iter)->objectSize( );
-//    }
-//  }
-//  objectSize += (sizeof(CacheablePtr) * (uint32_t)value.size());
-//  return objectSize;
-//}
-
-// template <typename TObj>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
-// char* fieldName,
-//    VectorT< TObj >& value )
-//{
-//  int32_t len;
-//  pr->readArrayLen( &len );
-//  if ( len >= 0 ) {
-//    TObj obj;
-//    for ( int32_t index = 0; index < len; index++ ) {
-//      readPdxObject( input, obj );
-//      value.push_back( obj );
-//    }
-//  }
-//}
-
-// template <typename TKey, typename TValue>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
-// char*
-// fieldName,
-//    const HashMapT< TKey, TValue >& value )
-//{
-//  int32_t len = (int32_t)value.size();
-//  pw->writeArrayLen( len );
-//  if ( len > 0 ) {
-//    for ( typename HashMapT< TKey, TValue >::Iterator iter = value.begin( );
-//        iter != value.end( ); ++iter ) {
-//      writePdxObject( output, iter.first( ) );
-//      writePdxObject( output, iter.second( ) );
-//    }
-//  }
-//}
-
-// inline uint32_t objectSize( const _HashMapOfCacheable& value )
-//{
-//  uint32_t objectSize = 0;
-//  for ( _HashMapOfCacheable::Iterator iter = value.begin( );
-//      iter != value.end( ); ++iter ) {
-//    objectSize += iter.first( )->objectSize( );
-//    if (iter.second( ) != NULLPTR) {
-//      objectSize += iter.second( )->objectSize( );
-//    }
-//  }
-//  objectSize += ( ( sizeof( CacheableKeyPtr ) + sizeof( CacheablePtr ) )
-//      * (uint32_t)value.size());
-//  return objectSize;
-//}
-
-// template <typename TKey, typename TValue>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
-// char* fieldName,
-//    HashMapT< TKey, TValue >& value )
-//{
-//  int32_t len;
-//  pr->readArrayLen( &len );
-//  if ( len > 0 ) {
-//    TKey key;
-//    TValue val;
-//    for( int32_t index = 0; index < len; index++ ) {
-//      readPdxObject( input, key );
-//      readPdxObject( input, val );
-//      value.insert( key, val );
-//    }
-//  }
-//}
-
-// template <typename TKey>
-// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
-// char*
-// fieldName,
-//  const HashSetT< TKey >& value )
-//{
-//  int32_t len = (int32_t)value.size();
-//  pw->writeArrayLen( len );
-//  for ( typename HashSetT< TKey >::Iterator iter = value.begin( );
-//    iter != value.end( ); ++iter ) {
-//    writePdxObject( output, *iter );
-//  }
-//}
-
-// inline uint32_t objectSize( const _HashSetOfCacheableKey& value )
-//{
-//  uint32_t objectSize = 0;
-//  for ( _HashSetOfCacheableKey::Iterator iter = value.begin( );
-//    iter != value.end( ); ++iter ) {
-//    if (*iter != NULLPTR) {
-//      objectSize += (*iter)->objectSize( );
-//    }
-//  }
-//  objectSize += (sizeof(CacheableKeyPtr) * (uint32_t)value.size());
-//  return objectSize;
-//}
-
-// template <typename TKey>
-// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
-// char* fieldName,
-//    HashSetT< TKey >& value )
-//{
-//  int32_t len;
-//  pr->readArrayLen( &len );
-//  if ( len > 0 ) {
-//    TKey key;
-//    for( int32_t index = 0; index < len; index++ ) {
-//      readPdxObject( input, key );
-//      value.insert( key );
-//    }
-//  }
-//}
-
-//// Default value for builtin types
-
-// template <typename TObj>
-// inline TObj zeroObject( )
-//{
-//  return 0;
-//}
-
-// template <>
-// inline bool zeroObject<bool>( )
-//{
-//  return false;
-//}
-
-// template <>
-// inline double zeroObject<double>( )
-//{
-//  return 0.0;
-//}
-
-// template <>
-// inline float zeroObject<float>( )
-//{
-//  return 0.0F;
-//}
-
-}  // namespace PdxAutoSerializable
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_PDXAUTOSERIALIZER_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/cppcache/integration-test/test.sh.in
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/test.sh.in b/src/cppcache/integration-test/test.sh.in
index e941227..23d2aec 100644
--- a/src/cppcache/integration-test/test.sh.in
+++ b/src/cppcache/integration-test/test.sh.in
@@ -20,7 +20,6 @@ set -o pipefail
 
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:apache-geode>
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:fwk>
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:pdxobject>
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:testobject>
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:SqLiteImpl>
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$<TARGET_LINKER_FILE_DIR:cryptoImpl>

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/cppcache/integration-test/testHeaders.sh
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testHeaders.sh b/src/cppcache/integration-test/testHeaders.sh
deleted file mode 100755
index 0137094..0000000
--- a/src/cppcache/integration-test/testHeaders.sh
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/bin/bash
-
-# 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.
-
-
-#set -xv
-
-#echo $1
-GFCPP=`echo $1 | perl -p -e 's/\\\/\//g'`
-#echo $GFCPP
-INCDIR=$GFCPP/include
-if [ ! -f "${INCDIR}/geode/Region.hpp" ]; then
-  echo "ERROR: Header files are not packed in product."
-  exit 1
-fi
-
-HEADERS=`find $INCDIR -type d -name "impl" -prune -o -name "_*.hpp" \
-  -o -name "*.hpp" -print` | grep -v PdxAutoSerializer
-
-function compileHeaders {
-  echo "0" >status
-  if [ ! -z ${WINDIR:-} ]; then
-
-    PRAGMAFILE=testHeaders_pragmas.hpp
-
-    echo "#pragma warning (disable : 4514)   /* unreferenced inline */" \
-      >$PRAGMAFILE
-    echo "#pragma warning (disable : 4290)   /* throws ignored */" \
-      >>$PRAGMAFILE
-
-    COMPILE="cl /nologo /c /Zs /TP /EHsc /W3 /WX /FI$PRAGMAFILE -I$INCDIR -I. oneheader.cpp"
-  elif [ `uname` == "SunOS" ]; then
-    COMPILE="CC -c -I$INCDIR oneheader.cpp"
-  else 
-    COMPILE="g++ -c -I$INCDIR oneheader.cpp"
-  fi
-
-  for hpp in $HEADERS; do
-    echo "#include <$hpp>" >oneheader.cpp
-    $COMPILE || \
-      ( failed=`cat status`; failed=`expr $failed + 1`; echo "$failed" >status; echo "ERROR in header $hpp" )
-  done
-}
-
-compileHeaders 2>&1 | egrep -v "oneheader.cpp" | tee testHeaders.out
-failed=`cat status`
-outdir=`pwd`
-echo "Discovered $failed headers with errors. See ${outdir}/testHeaders.out for details"
-exit $failed

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/pdxautoserializer/ASCLIBuiltins.hpp
----------------------------------------------------------------------
diff --git a/src/pdxautoserializer/ASCLIBuiltins.hpp b/src/pdxautoserializer/ASCLIBuiltins.hpp
deleted file mode 100644
index 36ce787..0000000
--- a/src/pdxautoserializer/ASCLIBuiltins.hpp
+++ /dev/null
@@ -1,462 +0,0 @@
-#pragma once
-
-#ifndef GEODE_PDXAUTOSERIALIZER_ASCLIBUILTINS_H_
-#define GEODE_PDXAUTOSERIALIZER_ASCLIBUILTINS_H_
-
-/*
- * 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.
- */
-
-#ifdef GEMFIRE_CLR
-
-#include "ASBuiltins.hpp"
-#include <vcclr.h>
-
-using namespace System;
-using namespace System::Collections::Generic;
-
-namespace Apache {
-namespace Geode {
-namespace Client {
-namespace Serializer {
-
-/**
-* @brief Helper type traits and other structs/classes do determine type
-*        information at compile time using typename.
-*        Useful for templates in particular.
-*/
-namespace TypeHelper {
-typedef uint8_t yes_type;
-typedef uint32_t no_type;
-
-template <typename TBase, typename TDerived>
-struct BDHelper {
-  template <typename T>
-  static yes_type check_sig(TDerived const volatile ^, T);
-  static no_type check_sig(TBase const volatile ^, int);
-};
-
-/**
-* @brief This struct helps us determine whether or not a class is a
-*        subclass of another at compile time, so that it can be used
-*        in templates. Adapted and extended from
-*        {@link
-* http://groups.google.com/group/comp.lang.c++.moderated/msg/dd6c4e4d5160bd83}
-*/
-template <typename TBase, typename TDerived>
-struct SuperSubclass {
- private:
-  struct Host {
-    operator TBase const volatile ^() const;
-    operator TDerived const volatile ^();
-  };
-
- public:
-  static const bool result = sizeof(BDHelper<TBase, TDerived>::check_sig(
-                                 Host(), 0)) == sizeof(yes_type);
-};
-
-template <typename TBase>
-struct SuperSubclass<TBase, TBase> {
-  static const bool result = true;
-};
-
-template <bool getType = true>
-struct YesNoType {
-  static const yes_type value = 0;
-};
-
-template <>
-struct YesNoType<false> {
-  static const no_type value = 0;
-};
-}
-
-#define TYPE_IS_IGFSERIALIZABLE(T) \
-  TypeHelper::SuperSubclass<IGeodeSerializable, T>::result
-#define TYPE_IS_IGFSERIALIZABLE_TYPE(T) \
-  TypeHelper::YesNoType<TYPE_IS_SERIALIZABLE(T)>::value
-
-inline void WriteObject(apache::geode::client::DataOutput& output, Byte value) {
-  output.write((uint8_t)value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input, Byte % value) {
-  uint8_t val;
-  input.read(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        SByte value) {
-  output.write((int8_t)value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input, SByte % value) {
-  int8_t val;
-  input.read(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        array<Byte> ^ bytes) {
-  if (bytes != nullptr) {
-    // We can safely use the pinning technique here since the pointer
-    // is not required after the end of native 'writeBytes' function.
-    pin_ptr<Byte> pin_bytes = &bytes[0];
-    output.writeBytes((uint8_t*)pin_bytes, bytes->Length);
-  } else {
-    output.writeBytes((uint8_t*)NULL, 0);
-  }
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       array<Byte> ^ % bytes) {
-  int32_t length;
-  input.readInt(&length);
-  if (length > 0) {
-    bytes = gcnew array<Byte>(length);
-    pin_ptr<Byte> pin_bytes = &bytes[0];
-    input.readBytes((uint8_t*)pin_bytes, length);
-  } else {
-    bytes = nullptr;
-  }
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        array<SByte> ^ bytes) {
-  if (bytes != nullptr) {
-    pin_ptr<SByte> pin_bytes = &bytes[0];
-    output.writeBytes((int8_t*)pin_bytes, bytes->Length);
-  } else {
-    output.writeBytes((int8_t*)NULL, 0);
-  }
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       array<SByte> ^ % bytes) {
-  int32_t length;
-  input.readInt(&length);
-  if (length > 0) {
-    bytes = gcnew array<SByte>(length);
-    pin_ptr<SByte> pin_bytes = &bytes[0];
-    input.readBytes((int8_t*)pin_bytes, length);
-  } else {
-    bytes = nullptr;
-  }
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Int16 value) {
-  output.writeInt((int16_t)value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input, Int16 % value) {
-  int16_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Int32 value) {
-  output.writeInt(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input, Int32 % value) {
-  int32_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Int64 value) {
-  output.writeInt(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input, Int64 % value) {
-  int64_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        UInt16 value) {
-  output.writeInt(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       UInt16 % value) {
-  uint16_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        UInt32 value) {
-  output.writeInt(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       UInt32 % value) {
-  uint32_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        UInt64 value) {
-  output.writeInt(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       UInt64 % value) {
-  uint64_t val;
-  input.readInt(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Boolean value) {
-  output.write((uint8_t)(value ? 1 : 0));
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       Boolean % value) {
-  uint8_t byte;
-  input.read(&byte);
-  value = (byte == 1 ? true : false);
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Double value) {
-  output.writeDouble(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       Double % value) {
-  double val;
-  input.readDouble(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        Single value) {
-  output.writeFloat(value);
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       Single % value) {
-  float val;
-  input.readFloat(&val);
-  value = val;
-}
-
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        String ^ str) {
-  if (str != nullptr) {
-    pin_ptr<const wchar_t> pin_str = PtrToStringChars(str);
-    output.writeUTF((wchar_t*)pin_str, str->Length);
-  } else {
-    output.writeUTF((wchar_t*)NULL, 0);
-  }
-}
-
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       String ^ % str) {
-  wchar_t* n_buffer = nullptr;
-  uint16_t len;
-  input.readUTF(&n_buffer, &len);
-  if (len > 0) {
-    str = gcnew String(n_buffer, 0, len);
-    input.freeUTFMemory(n_buffer);
-  } else {
-    str = nullptr;
-  }
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, TObj ^ value,
-                        TypeHelper::yes_type isSerializable) {
-  mg_output->WriteObject(value);
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, TObj ^ value,
-                        TypeHelper::no_type isNotSerializable) {
-  WriteObject(output, value);
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, TObj ^ value) {
-  WriteObject(output, mg_output, value, TYPE_IS_IGFSERIALIZABLE_TYPE(TObj));
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, TObj value) {
-  WriteObject(output, value);
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, TObj ^ % value,
-                       TypeHelper::yes_type isSerializable) {
-  value = static_cast<TObj ^>(mg_input->ReadObject());
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, TObj ^ % value,
-                       TypeHelper::no_type isNotSerializable) {
-  ReadObject(input, value);
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, TObj ^ % value) {
-  ReadObject(input, mg_input, value, TYPE_IS_IGFSERIALIZABLE_TYPE(TObj));
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, TObj % value) {
-  ReadObject(input, value);
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        array<TObj> ^ arr) {
-  if (arr != nullptr) {
-    pin_ptr<TObj> pin_arr = &arr[0];
-    apache::geode::client::serializer::writeObject(output, (TObj*)pin_arr,
-                                                   arr->Length);
-  } else {
-    output.writeInt(0);
-  }
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       array<TObj> ^ % arr) {
-  int32_t size;
-  input.readInt(&size);
-  if (size > 0) {
-    arr = gcnew array<TObj>(size);
-    pin_ptr<TObj> pin_arr = &arr[0];
-    apache::geode::client::serializer::readArray(input, (TObj*)pin_arr, size);
-  } else {
-    arr = nullptr;
-  }
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, array<TObj ^> ^ arr) {
-  if (arr != nullptr) {
-    output.writeInt(arr->Length);
-            for
-              each(TObj ^ obj in arr) { WriteObject(output, mg_output, obj); }
-  } else {
-    output.writeInt(-1);
-  }
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, array<TObj ^> ^ % arr) {
-  int32_t size;
-  input.readInt(&size);
-  if (size > 0) {
-    arr = gcnew array<TObj ^>(size);
-            for
-              each(TObj ^ obj in arr) { ReadObject(input, mg_input, obj); }
-  } else {
-    arr = nullptr;
-  }
-}
-
-template <typename TObj>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output, List<TObj> ^ value) {
-  if (value != nullptr) {
-    output.writeInt(value->Count);
-            for
-              each(TObj obj in value) { WriteObject(output, mg_output, obj); }
-  } else {
-    output.writeInt(-1);
-  }
-}
-
-template <typename TObj>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, List<TObj> ^ % value) {
-  int32_t len;
-  input.readInt(&len);
-  if (len > 0) {
-    value = gcnew List<TObj>(len);
-    for (int32_t listIndex = 0; listIndex < len; listIndex++) {
-      ReadObject(input, mg_input, value[listIndex]);
-    }
-  } else {
-    value = nullptr;
-  }
-}
-
-template <typename TKey, typename TVal>
-inline void WriteObject(apache::geode::client::DataOutput& output,
-                        DataOutput ^ mg_output,
-                        Dictionary<TKey, TVal> ^ value) {
-  if (value != nullptr) {
-    output.writeInt(value->Count);
-            for
-              each(KeyValuePair<TKey, TVal> ^ pair in value) {
-                WriteObject(output, mg_output, pair->Key);
-                WriteObject(output, mg_output, pair->Value);
-              }
-  } else {
-    output.writeInt(-1);
-  }
-}
-
-template <typename TKey, typename TVal>
-inline void ReadObject(apache::geode::client::DataInput& input,
-                       DataInput ^ mg_input, Dictionary<TKey, TVal> ^ % value) {
-  int32_t len;
-  input.readInt(&len);
-  if (len > 0) {
-    TKey ^ key;
-    TVal ^ val;
-    value = gcnew Dictionary<TKey, TVal>(len);
-    for (int32_t listIndex = 0; listIndex < len; listIndex++) {
-      ReadObject(input, mg_input, key);
-      ReadObject(input, mg_input, val);
-      value[key] = val;
-    }
-  } else {
-    value = nullptr;
-  }
-}
-}
-}
-}
-}
-
-#endif  // GEMFIRE_CLR
-
-#endif  // GEODE_PDXAUTOSERIALIZER_ASCLIBUILTINS_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/quickstart/cpp/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/quickstart/cpp/CMakeLists.txt b/src/quickstart/cpp/CMakeLists.txt
index d6f8a59..9c6d60c 100644
--- a/src/quickstart/cpp/CMakeLists.txt
+++ b/src/quickstart/cpp/CMakeLists.txt
@@ -26,16 +26,6 @@ elseif(UNIX)
     set(DYNAMIC_LIBRARY_PATH LD_LIBRARY_PATH=${NATIVECLIENT_DIR}/lib)
 endif()
 
-macro(add_pdxautoserializer NAMESPACE CLASS HEADER SUFFIX CLASSNAMESTR)
-    set(_OUTPUT ${CMAKE_SOURCE_DIR}/queryobjects/${NAMESPACE}_${CLASS}${SUFFIX}.cpp)
-    set(_INPUT ${HEADER})
-
-    add_custom_command(OUTPUT ${_OUTPUT}
-        COMMAND ${DYNAMIC_LIBRARY_PATH} ${NATIVECLIENT_BINARIES_DIR}/pdxautoserializer --outDir=${CMAKE_SOURCE_DIR}/queryobjects ${CMAKE_SOURCE_DIR}/queryobjects/${HEADER}
-        DEPENDS ${CMAKE_SOURCE_DIR}/queryobjects/${_INPUT}
-    )
-endmacro()
-
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
@@ -62,9 +52,6 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -std=c++11 -lstdc++ -lgcc_s -lCrunG3 -lc")
 endif()
 
-add_pdxautoserializer(testobject PortfolioPdxAuto PortfolioPdxAuto.hpp Serializable "")
-add_pdxautoserializer(testobject PositionPdxAuto PositionPdxAuto.hpp Serializable "")
-
 set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}")
 set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}")
 
@@ -178,14 +165,5 @@ add_executable(PdxRemoteQuery
   queryobjects/PositionPdx.cpp)
 target_link_libraries(PdxRemoteQuery PUBLIC ${GFCPPCACHE})
 
-add_executable(PdxAutoSerializer
-  PdxAutoSerializer.cpp
-  queryobjects/PortfolioPdxAuto.cpp
-  queryobjects/PositionPdxAuto.cpp
-  queryobjects/testobject_PortfolioPdxAutoSerializable.cpp
-  queryobjects/testobject_PositionPdxAutoSerializable.cpp
-  )
-target_link_libraries(PdxAutoSerializer PUBLIC ${GFCPPCACHE})
-
 file(COPY ../XMLs DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 file(COPY ../keystore DESTINATION ${CMAKE_CURRENT_BINARY_DIR})

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/quickstart/cpp/PdxAutoSerializer.cpp
----------------------------------------------------------------------
diff --git a/src/quickstart/cpp/PdxAutoSerializer.cpp b/src/quickstart/cpp/PdxAutoSerializer.cpp
deleted file mode 100644
index 962e072..0000000
--- a/src/quickstart/cpp/PdxAutoSerializer.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * 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 PoolRemoteQuery QuickStart Example.
- * This examples creates pool using locator.
- * This example takes the following steps:
- *
- * 1. Create a Geode Cache.
- * 2. Get the example Region from the Pool.
- * 3. Populate some Pdx Type query objects on the Region.
- * 4. Get the pool, get the Query Service from Cache. Pool is define in
- * clientPdxRemoteQuery.xml. Pool has locator to get the server. Apart from that
- * pool is bind to server group "ServerGroup1".
- * 5. Execute a query that returns a Result Set.
- * 6. Execute a query that returns a Struct Set.
- * 7. Execute the region shortcut/convenience query methods.
- * 8. Close the Cache.
- *
- */
-
-// Include the Geode library.
-#include <geode/GeodeCppCache.hpp>
-
-// Include our Query objects, viz. PortfolioPdx and PositionPdx.
-#include "queryobjects/PortfolioPdxAuto.hpp"
-#include "queryobjects/PositionPdxAuto.hpp"
-
-// Use the "geode" namespace.
-using namespace apache::geode::client;
-
-// Use the "testobject" namespace for the query objects.
-using namespace testobject;
-
-// The PdxRemoteQuery QuickStart example.
-int main(int argc, char** argv) {
-  try {
-    CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
-
-    // Create a Geode Cache with the "clientPdxRemoteQuery.xml" Cache XML
-    // file.
-    // CachePtr cachePtr = cacheFactory->set("cache-xml-file",
-    // "XMLs/clientPdxAutoSerializer.xml")->create();
-    CachePtr cachePtr =
-        cacheFactory->set("cache-xml-file", "XMLs/clientPdxAutoSerializer.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("Portfolios");
-
-    LOGINFO("Obtained the Region from the Cache");
-
-    // Register our Serializable/Cacheable Query objects, viz. PortfolioPdx and
-    // PositionPdx.
-    Serializable::registerPdxType(PortfolioPdxAuto::createDeserializable);
-    Serializable::registerPdxType(PositionPdxAuto::createDeserializable);
-
-    LOGINFO("Registered PDX Type Query Objects");
-
-    // Populate the Region with some Pdx Type objects, i.e PortfolioPdx objects.
-    PortfolioPdxPtr port1Ptr(new PortfolioPdxAuto(1 /*ID*/, 10 /*size*/));
-    PortfolioPdxPtr port2Ptr(new PortfolioPdxAuto(2 /*ID*/, 20 /*size*/));
-    PortfolioPdxPtr port3Ptr(new PortfolioPdxAuto(3 /*ID*/, 30 /*size*/));
-    regionPtr->put("Key1", port1Ptr);
-    regionPtr->put("Key2", port2Ptr);
-    regionPtr->put("Key3", port3Ptr);
-
-    LOGINFO("Populated some PortfolioPdx Objects");
-
-    // Get the QueryService from the Cache.
-    QueryServicePtr qrySvcPtr = cachePtr->getQueryService("examplePool");
-
-    LOGINFO("Got the QueryService from the Cache");
-
-    PortfolioPdxPtr port4Ptr = regionPtr->get("Key1");
-
-    // Execute a Query which returns a ResultSet.
-    QueryPtr qryPtr = qrySvcPtr->newQuery("SELECT DISTINCT * FROM /Portfolios");
-    SelectResultsPtr resultsPtr = qryPtr->execute();
-
-    LOGINFO("ResultSet Query returned %d rows", resultsPtr->size());
-
-    // Execute a Query which returns a StructSet.
-    qryPtr = qrySvcPtr->newQuery(
-        "SELECT DISTINCT id, status FROM /Portfolios WHERE id > 1");
-    resultsPtr = qryPtr->execute();
-
-    LOGINFO("StructSet Query returned %d rows", resultsPtr->size());
-
-    // Iterate through the rows of the query result.
-    int rowCount = 0;
-    SelectResultsIterator iter = resultsPtr->getIterator();
-    while (iter.hasNext()) {
-      rowCount++;
-      Struct* psi = dynamic_cast<Struct*>(iter.next().ptr());
-      LOGINFO("Row %d Column 1 is named %s, value is %s", rowCount,
-              psi->getFieldName(0), (*psi)[0]->toString()->asChar());
-      LOGINFO("Row %d Column 2 is named %s, value is %S", rowCount,
-              psi->getFieldName(1), (*psi)[1]->toString()->asWChar());
-    }
-
-    // Execute a Region Shortcut Query (convenience method).
-    resultsPtr = regionPtr->query("id = 2");
-
-    LOGINFO("Region Query returned %d rows", resultsPtr->size());
-
-    // Execute the Region selectValue() API.
-    SerializablePtr resultPtr = regionPtr->selectValue("id = 3");
-    PortfolioPdxPtr portPtr = dynCast<PortfolioPdxPtr>(resultPtr);
-
-    LOGINFO("Region selectValue() returned an item:\n %s",
-            portPtr->toString()->asChar());
-
-    // Execute the Region existsValue() API.
-    bool existsValue = regionPtr->existsValue("id = 4");
-
-    LOGINFO("Region existsValue() returned %s", existsValue ? "true" : "false");
-
-    // Close the Geode Cache.
-    cachePtr->close();
-
-    LOGINFO("Closed the Geode Cache");
-
-    return 0;
-  }
-  // An exception should not occur
-  catch (const Exception& geodeExcp) {
-    LOGERROR("PdxAutoSerializer Geode Exception: %s", geodeExcp.getMessage());
-
-    return 1;
-  }
-}

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/quickstart/runcpp.bat.in
----------------------------------------------------------------------
diff --git a/src/quickstart/runcpp.bat.in b/src/quickstart/runcpp.bat.in
index dce7118..1b088a4 100755
--- a/src/quickstart/runcpp.bat.in
+++ b/src/quickstart/runcpp.bat.in
@@ -239,8 +239,7 @@ echo 21.TransactionsXA
 echo 22.PdxRemoteQuery
 echo 23.PdxSerializer
 echo 24.PdxInstance
-echo 25.PdxAutoSerializer
-echo 26.Quit
+echo 25.Quit
 echo.
 
 :getoption
@@ -275,8 +274,7 @@ if '%option%' equ '21' set exname=TransactionsXA
 if '%option%' equ '22' set exname=PdxRemoteQuery
 if '%option%' equ '23' set exname=PdxSerializer
 if '%option%' equ '24' set exname=PdxInstance
-if '%option%' equ '25' set exname=PdxAutoSerializer
-if '%option%' equ '26' goto finished
+if '%option%' equ '25' goto finished
 
 if '%exname%' equ 'invalidoption' goto invalidoption
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/quickstart/runcpp.sh.in
----------------------------------------------------------------------
diff --git a/src/quickstart/runcpp.sh.in b/src/quickstart/runcpp.sh.in
index e12d76d..ba1a1c8 100755
--- a/src/quickstart/runcpp.sh.in
+++ b/src/quickstart/runcpp.sh.in
@@ -69,8 +69,7 @@ else
     echo 22.PdxRemoteQuery
     echo 23.PdxSerializer
     echo 24.PdxInstance
-    echo 25.PdxAutoSerializer
-    echo 26.Quit
+    echo 25.Quit
     echo
   fi
 
@@ -151,9 +150,6 @@ else
         exname='PdxInstance'
       ;;
       "25")
-        exname='PdxAutoSerializer'
-      ;;
-      "26")
         exname='Quit'
     exit
       ;;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/tests/cpp/CMakeLists.txt b/src/tests/cpp/CMakeLists.txt
index 971f711..71c6442 100644
--- a/src/tests/cpp/CMakeLists.txt
+++ b/src/tests/cpp/CMakeLists.txt
@@ -17,6 +17,5 @@ project(nativeclient.tests.cpp)
 
 add_subdirectory(fwklib)
 add_subdirectory(fwk)
-add_subdirectory(pdxautoserializerclass)
 add_subdirectory(testobject)
 add_subdirectory(security)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/fwklib/QueryHelper.hpp
----------------------------------------------------------------------
diff --git a/src/tests/cpp/fwklib/QueryHelper.hpp b/src/tests/cpp/fwklib/QueryHelper.hpp
index 2e08263..329b36b 100644
--- a/src/tests/cpp/fwklib/QueryHelper.hpp
+++ b/src/tests/cpp/fwklib/QueryHelper.hpp
@@ -32,8 +32,6 @@
 #include "../testobject/PdxType.hpp"
 #include "../testobject/PortfolioPdx.hpp"
 #include "../testobject/PositionPdx.hpp"
-#include "../pdxautoserializerclass/PortfolioPdx.hpp"
-#include "../pdxautoserializerclass/PositionPdx.hpp"
 #include "fwklib/FwkLog.hpp"
 
 #include <geode/ResultSet.hpp>
@@ -45,7 +43,6 @@
 
 using namespace apache::geode::client;
 using namespace PdxTests;
-using namespace AutoPdxTests;
 
 namespace testData {
 
@@ -683,11 +680,6 @@ class QueryHelper {
                                         char** nm = NULL);
   virtual void populatePositionPdxData(RegionPtr& pregion, int setSize,
                                        int numSets);
-  virtual void populateAutoPortfolioPdxData(RegionPtr& pregion, int setSize,
-                                            int numSets, int32_t objSize = 1,
-                                            char** nm = NULL);
-  virtual void populateAutoPositionPdxData(RegionPtr& pregion, int setSize,
-                                           int numSets);
   virtual void destroyPortfolioOrPositionData(RegionPtr& pregion, int setSize,
                                               int numSets,
                                               const char* dataType);
@@ -908,12 +900,10 @@ void QueryHelper::destroyPortfolioOrPositionData(RegionPtr& rptr, int setSize,
       for (int current = 1; current <= setSize; current++) {
         char portname[100] = {0};
         if (strcmp(dataType, "Portfolio") == 0 ||
-            strcmp(dataType, "PortfolioPdx") == 0 ||
-            strcmp(dataType, "AutoPortfolioPdx") == 0) {
+            strcmp(dataType, "PortfolioPdx") == 0) {
           ACE_OS::sprintf(portname, "port%d-%d", set, current);
         } else if (strcmp(dataType, "Position") == 0 ||
-                   strcmp(dataType, "PositionPdx") == 0 ||
-                   strcmp(dataType, "AutoPositionPdx") == 0) {
+                   strcmp(dataType, "PositionPdx") == 0) {
           ACE_OS::sprintf(portname, "pos%d-%d", set, current);
         } else {
           throw apache::geode::client::IllegalArgumentException(
@@ -1023,54 +1013,6 @@ void QueryHelper::populatePositionPdxData(RegionPtr& rptr, int setSize,
   }
   // positionSetSize = setSize; positionNumSets = numSets;
 }
-void QueryHelper::populateAutoPortfolioPdxData(RegionPtr& rptr, int setSize,
-                                               int numSets, int32_t objSize,
-                                               char** nm) {
-  // lets reset the counter for uniform population of position objects
-  AutoPdxTests::PositionPdx::resetCounter();
-
-  for (int set = 1; set <= numSets; set++) {
-    for (int current = 1; current <= setSize; current++) {
-      CacheablePtr port(new AutoPdxTests::PortfolioPdx(current, objSize));
-
-      char portname[100] = {0};
-      ACE_OS::sprintf(portname, "port%d-%d", set, current);
-
-      CacheableKeyPtr keyport = CacheableKey::create(portname);
-
-      rptr->put(keyport, port);
-      LOGINFO(
-          "populateAutoPortfolioPdxData:: Put for iteration current = %d done",
-          current);
-    }
-  }
-  // portfolioSetSize = setSize; portfolioNumSets = numSets; objectSize =
-  // objSize;
-
-  printf("all puts done \n");
-}
-
-void QueryHelper::populateAutoPositionPdxData(RegionPtr& rptr, int setSize,
-                                              int numSets) {
-  int numSecIds = sizeof(secIds) / sizeof(char*);
-
-  for (int set = 1; set <= numSets; set++) {
-    for (int current = 1; current <= setSize; current++) {
-      CacheablePtr pos(new AutoPdxTests::PositionPdx(
-          secIds[current % numSecIds], current * 100));
-
-      char posname[100] = {0};
-      ACE_OS::sprintf(posname, "pos%d-%d", set, current);
-
-      CacheableKeyPtr keypos = CacheableKey::create(posname);
-      rptr->put(keypos, pos);
-      LOGINFO(
-          "populateAutoPositionPdxData:: Put for iteration current = %d done",
-          current);
-    }
-  }
-  // positionSetSize = setSize; positionNumSets = numSets;
-}
 bool QueryHelper::verifyRS(SelectResultsPtr& resultSet, int expectedRows) {
   if (!instanceOf<ResultSetPtr>(resultSet)) {
     return false;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/pdxautoserializerclass/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/tests/cpp/pdxautoserializerclass/CMakeLists.txt b/src/tests/cpp/pdxautoserializerclass/CMakeLists.txt
deleted file mode 100644
index cf1c6f3..0000000
--- a/src/tests/cpp/pdxautoserializerclass/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# 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.
-cmake_minimum_required(VERSION 3.4)
-project(nativeclient.tests.pdxautoserializerclass)
-
-file(GLOB_RECURSE SOURCES "*.cpp")
-
-if (APPLE)
-    set(DYNAMIC_LIBRARY_PATH DYLD_LIBRARY_PATH=$<TARGET_LINKER_FILE_DIR:apache-geode>)
-elseif(UNIX)
-    set(DYNAMIC_LIBRARY_PATH LD_LIBRARY_PATH=$<TARGET_LINKER_FILE_DIR:apache-geode>)
-endif()
-
-add_library(pdxobject SHARED ${SOURCES})
-set_target_properties(pdxobject PROPERTIES FOLDER test)
-
-add_definitions(-DBUILD_TESTOBJECT)
-
-target_link_libraries(pdxobject
-  PUBLIC 
-    apache-geode
-    c++11
-)
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.cpp
----------------------------------------------------------------------
diff --git a/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.cpp b/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.cpp
deleted file mode 100644
index d6cb464..0000000
--- a/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * 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.
- */
-#include "PortfolioPdx.hpp"
-
-using namespace apache::geode::client;
-using namespace AutoPdxTests;
-
-char *PortfolioPdx::secIds[] = {(char *)"SUN",  (char *)"IBM",  (char *)"YHOO",
-                                (char *)"GOOG", (char *)"MSFT", (char *)"AOL",
-                                (char *)"APPL", (char *)"ORCL", (char *)"SAP",
-                                (char *)"DELL"};
-
-PortfolioPdx::PortfolioPdx(int32_t i, int32_t size, char **nm) : names(nm) {
-  ID = i;
-
-  char pkidbuf[256];
-  sprintf(pkidbuf, "%d", i);
-  size_t strSize = strlen(pkidbuf) + 1;
-  pkid = new char[strSize];
-  memcpy(pkid, pkidbuf, strSize);
-
-  const char *statusStr = (i % 2 == 0) ? "active" : "inactive";
-  int32_t statusSize = static_cast<int32_t>(strlen(statusStr)) + 1;
-  status = new char[statusSize];
-  memcpy(status, statusStr, statusSize);
-
-  char buf[100];
-  sprintf(buf, "type%d", (i % 3));
-  size_t strSize2 = strlen(buf) + 1;
-  type = new char[strSize2];
-  memcpy(type, buf, strSize2);
-
-  int numSecIds = sizeof(secIds) / sizeof(char *);
-  position1 = new PositionPdx(secIds[PositionPdx::cnt % numSecIds],
-                              PositionPdx::cnt * 1000);
-  if (i % 2 != 0) {
-    position2 = new PositionPdx(secIds[PositionPdx::cnt % numSecIds],
-                                PositionPdx::cnt * 1000);
-  } else {
-    position2 = NULLPTR;
-  }
-  positions = CacheableHashMap::create();
-  positions->insert(
-      CacheableString::create(secIds[PositionPdx::cnt % numSecIds]), position1);
-
-  if (size > 0) {
-    newVal = new int8_t[size];
-    for (int index = 0; index < size; index++) {
-      newVal[index] = static_cast<int8_t>('B');
-    }
-  }
-  newValSize = size;
-
-  time_t timeVal = 1310447869;
-  creationDate = CacheableDate::create(timeVal);
-  arrayNull = NULL;
-  arrayZeroSize = new int8_t[0];
-  arrayNullLen = 0;
-  arrayZeroSizeLen = 0;
-}
-
-PortfolioPdx::~PortfolioPdx() {
-  if (newVal != NULL) {
-    delete[] newVal;
-    newVal = NULL;
-  }
-  if (status != NULL) {
-    delete[] status;
-    status = NULL;
-  }
-  if (pkid != NULL) {
-    delete[] pkid;
-    pkid = NULL;
-  }
-
-  if (type != NULL) {
-    delete[] type;
-    type = NULL;
-  }
-
-  if (newVal != NULL) {
-    delete[] newVal;
-    newVal = NULL;
-  }
-}
-
-void PortfolioPdx::toData( PdxWriterPtr pw  )  {
-  pw->writeInt("ID", ID);
-  pw->markIdentityField("ID");
-
-  pw->writeString("pkid", pkid);
-  pw->markIdentityField("pkid");
-
-  pw->writeObject("position1", position1);
-  pw->markIdentityField("position1");
-
-  pw->writeObject("position2", position2);
-  pw->markIdentityField("position2");
-
-  pw->writeObject("positions", positions);
-  pw->markIdentityField("positions");
-
-  pw->writeString("type", type);
-  pw->markIdentityField("type");
-
-  pw->writeString("status", status);
-  pw->markIdentityField("status");
-
-  pw->writeStringArray("names", names, 0);
-  pw->markIdentityField("names");
-
-  pw->writeByteArray("newVal", newVal, newValSize);
-  pw->markIdentityField("newVal");
-
-  pw->writeDate("creationDate", creationDate);
-  pw->markIdentityField("creationDate");
-
-  pw->writeByteArray("arrayNull", arrayNull,0);
-  pw->writeByteArray("arrayZeroSize", arrayZeroSize,0);
-
-}
-
-void PortfolioPdx::fromData( PdxReaderPtr pr )
-{
-  ID = pr->readInt("ID");
-  pkid = pr->readString("pkid");
-
-  position1 = dynCast<PositionPdxPtr>(pr->readObject("position1"));
-  position2 = dynCast<PositionPdxPtr>(pr->readObject("position2"));
-  positions = dynCast<CacheableHashMapPtr>(pr->readObject("positions"));
-  type = pr->readString("type");
-  status = pr->readString("status");
-
-  int32_t strLenArray=0;
-  names = pr->readStringArray("names", strLenArray);
-  int32_t byteArrayLen=0;
-  newVal = pr->readByteArray("newVal", byteArrayLen);
-  creationDate = pr->readDate("creationDate");
-  int32_t arrayNullLen = 0;
-  arrayNull = pr->readByteArray("arrayNull", arrayNullLen);
-  int32_t arrayZeroSizeLen=0;
-  arrayZeroSize = pr->readByteArray("arrayZeroSize", arrayZeroSizeLen);
-
-}
-
-CacheableStringPtr PortfolioPdx::toString() const {
-  LOGINFO("PortfolioPdx::toString() Start");
-  char idbuf[1024];
-  sprintf(idbuf, "PortfolioPdxObject: [ ID=%d ]", ID);
-
-  char pkidbuf[1024];
-  if (pkid != NULL) {
-    sprintf(pkidbuf, " status=%s type=%s pkid=%s\n", this->status, this->type,
-            this->pkid);
-  } else {
-    sprintf(pkidbuf, " status=%s type=%s pkid=%s\n", this->status, this->type,
-            this->pkid);
-  }
-  char position1buf[2048];
-  if (position1 != NULLPTR) {
-    sprintf(position1buf, "\t\t\t  P1: %s", position1->toString()->asChar());
-  } else {
-    sprintf(position1buf, "\t\t\t  P1: %s", "NULL");
-  }
-  char position2buf[2048];
-  if (position2 != NULLPTR) {
-    sprintf(position2buf, " P2: %s", position2->toString()->asChar());
-  } else {
-    sprintf(position2buf, " P2: %s ]", "NULL");
-  }
-  char creationdatebuf[2048];
-  if (creationDate != NULLPTR) {
-    sprintf(creationdatebuf, "creation Date %s",
-            creationDate->toString()->asChar());
-  } else {
-    sprintf(creationdatebuf, "creation Date %s", "NULL");
-  }
-
-  char stringBuf[7000];
-  sprintf(stringBuf, "%s%s%s%s%s", idbuf, pkidbuf, creationdatebuf,
-          position1buf, position2buf);
-  return CacheableString::create(stringBuf);
-
-  return CacheableString::create(idbuf);
-}

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.hpp
----------------------------------------------------------------------
diff --git a/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.hpp b/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.hpp
deleted file mode 100644
index e2d2202..0000000
--- a/src/tests/cpp/pdxautoserializerclass/PortfolioPdx.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#pragma once
-
-#ifndef GEODE_PDXAUTOSERIALIZERCLASS_PORTFOLIOPDX_H_
-#define GEODE_PDXAUTOSERIALIZERCLASS_PORTFOLIOPDX_H_
-
-/*
- * 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.
- */
-
-/*
- * @brief User class for testing the put functionality for object.
- */
-
-#include "PositionPdx.hpp"
-#define GFIGNORE(X) X
-#define GFEXCLUDE
-#define GFID
-#define GFARRAYSIZE(X)
-#define GFARRAYELEMSIZE(X)
-using namespace apache::geode::client;
-
-namespace AutoPdxTests {
-
-class GFIGNORE(TESTOBJECT_EXPORT) PortfolioPdx : public PdxSerializable {
- private:
-  GFID int32_t ID;
-
-  GFID char* pkid;
-
-  GFID PositionPdxPtr position1;
-  GFID PositionPdxPtr position2;
-  GFID CacheableHashMapPtr positions;
-  GFID char *type, *status;
-  GFID char** names;
-  GFARRAYSIZE(names) int32_t nameStrArrayLen;
-  // GFEXCLUDE static  const char* secIds[]; // bug #914
-  GFEXCLUDE static char* secIds[];
-  GFID int8_t* newVal;
-  GFARRAYSIZE(newVal) int32_t newValSize;
-  GFID CacheableDatePtr creationDate;
-  GFID int8_t *arrayNull, *arrayZeroSize;
-  GFARRAYSIZE(arrayNull) int32_t arrayNullLen;
-  GFARRAYSIZE(arrayZeroSize) int32_t arrayZeroSizeLen;
-
- public:
-  PortfolioPdx()
-      : ID(0),
-        pkid(NULL),
-        type(NULL),
-        status(NULL),
-        newVal(NULL),
-        creationDate(NULLPTR),
-        arrayNull(NULL),
-        arrayZeroSize(NULL) {}
-
-  PortfolioPdx(int32_t id, int32_t size = 0, char** nm = NULL);
-
-  virtual ~PortfolioPdx();
-
-  int32_t getID() { return ID; }
-
-  char* getPkid() { return pkid; }
-
-  PositionPdxPtr getP1() { return position1; }
-
-  PositionPdxPtr getP2() { return position2; }
-
-  CacheableHashMapPtr getPositions() { return positions; }
-
-  bool testMethod(bool booleanArg) { return true; }
-
-  char* getStatus() { return status; }
-
-  bool isActive() { return (strcmp(status, "active") == 0) ? true : false; }
-
-  int8_t* getNewVal() { return newVal; }
-
-  int32_t getNewValSize() { return newValSize; }
-
-  const char* getClassName() { return this->type; }
-
-  CacheableDatePtr getCreationDate() { return creationDate; }
-
-  int8_t* getArrayNull() { return arrayNull; }
-
-  int8_t* getArrayZeroSize() { return arrayZeroSize; }
-
-  static PdxSerializable* createDeserializable();
-
-  const char* getClassName() const { return this->type; }
-
-  using PdxSerializable::toData;
-  using PdxSerializable::fromData;
-  virtual void toData(PdxWriterPtr pw);
-  virtual void fromData(PdxReaderPtr pr);
-
-  CacheableStringPtr toString() const;
-};
-
-typedef SharedPtr<PortfolioPdx> PortfolioPdxPtr;
-}  // namespace AutoPdxTests
-
-#endif  // GEODE_PDXAUTOSERIALIZERCLASS_PORTFOLIOPDX_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/pdxautoserializerclass/PositionPdx.cpp
----------------------------------------------------------------------
diff --git a/src/tests/cpp/pdxautoserializerclass/PositionPdx.cpp b/src/tests/cpp/pdxautoserializerclass/PositionPdx.cpp
deleted file mode 100644
index 3508fbd..0000000
--- a/src/tests/cpp/pdxautoserializerclass/PositionPdx.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * 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.
- */
-#include "PositionPdx.hpp"
-#include <cwchar>
-#include <wchar.h>
-
-using namespace apache::geode::client;
-using namespace AutoPdxTests;
-
-int32_t PositionPdx::cnt = 0;
-
-PositionPdx::PositionPdx() { init(); }
-
-PositionPdx::PositionPdx(const char* id, int32_t out) {
-  init();
-
-  size_t strSize = strlen(id) + 1;
-  secId = new char[strSize];
-  memcpy(secId, id, strSize);
-
-  qty = out * (cnt % 2 == 0 ? 10.0 : 100.0);
-  mktValue = qty * 1.2345998;
-  sharesOutstanding = out;
-  // secType = ( wchar_t * )malloc( ( wcslen( L"a" ) + 1 ) * sizeof( wchar_t )
-  // );
-  secType = new char[(strlen("a") + 1)];
-  strcpy(secType, "a");
-
-  pid = cnt++;
-}
-
-// This constructor is just for some internal data validation test
-PositionPdx::PositionPdx(int32_t iForExactVal) {
-  init();
-
-  char* id = new char[iForExactVal + 2];
-  for (int i = 0; i <= iForExactVal; i++) {
-    id[i] = 'a';
-  }
-  id[iForExactVal + 1] = '\0';
-  size_t strSize = strlen(id) + 1;
-  secId = new char[strSize];
-  memcpy(secId, id, strSize);
-
-  delete[] id;
-  qty = (iForExactVal % 2 == 0 ? 1000 : 100);
-  mktValue = qty * 2;
-  sharesOutstanding = iForExactVal;
-  // secType = ( wchar_t * )malloc( ( wcslen( L"a" ) + 1 ) * sizeof( wchar_t )
-  // );
-  secType = new char[(strlen("a") + 1)];
-  strcpy(secType, "a");
-  pid = iForExactVal;
-}
-
-PositionPdx::~PositionPdx() {
-  if (secType != NULL) {
-    // free(secType);
-    delete[] secType;
-    secType = NULL;
-  }
-
-  if (secId != NULL) {
-    // free(secId);
-    delete[] secId;
-    secId = NULL;
-  }
-}
-
-void PositionPdx::init() {
-  avg20DaysVol = 0;
-  bondRating = NULL;
-  convRatio = 0.0;
-  country = NULL;
-  delta = 0.0;
-  industry = 0;
-  issuer = 0;
-  mktValue = 0.0;
-  qty = 0.0;
-  secId = NULL;
-  secLinks = NULL;
-  secType = NULL;
-  sharesOutstanding = 0;
-  underlyer = NULL;
-  volatility = 0;
-  pid = 0;
-}
-
-void PositionPdx::toData( PdxWriterPtr pw)  {
-  pw->writeLong("avg20DaysVol", avg20DaysVol);
-  pw->markIdentityField("avg20DaysVol");
-
-  pw->writeString("bondRating", bondRating);
-  pw->markIdentityField("bondRating");
-
-  pw->writeDouble("convRatio", convRatio);
-  pw->markIdentityField("convRatio");
-
-  pw->writeString("country", country);
-  pw->markIdentityField("country");
-
-  pw->writeDouble("delta", delta);
-  pw->markIdentityField("delta");
-
-  pw->writeLong("industry", industry);
-  pw->markIdentityField("industry");
-
-  pw->writeLong("issuer", issuer);
-  pw->markIdentityField("issuer");
-
-  pw->writeDouble("mktValue", mktValue);
-  pw->markIdentityField("mktValue");
-
-  pw->writeDouble("qty", qty);
-  pw->markIdentityField("qty");
-
-  pw->writeString("secId", secId);
-  pw->markIdentityField("secId");
-
-  pw->writeString("secLinks", secLinks);
-  pw->markIdentityField("secLinks");
-
-  pw->writeString("secType", secType);
-  pw->markIdentityField("secType");
-
-  pw->writeInt("sharesOutstanding", sharesOutstanding);
-  pw->markIdentityField("sharesOutstanding");
-
-  pw->writeString("underlyer", underlyer);
-  pw->markIdentityField("underlyer");
-
-  pw->writeLong("volatility", volatility);
-  pw->markIdentityField("volatility");
-
-  pw->writeInt("pid", pid);
-  pw->markIdentityField("pid");
-}
-
-void PositionPdx::fromData( PdxReaderPtr pr ){
-
-  avg20DaysVol = pr->readLong("avg20DaysVol");
-  bondRating = pr->readString("bondRating");
-  convRatio = pr->readDouble("convRatio");
-  country = pr->readString("country");
-  delta = pr->readDouble("delta");
-  industry = pr->readLong("industry");
-  issuer = pr->readLong("issuer");
-  mktValue = pr->readDouble("mktValue");
-  qty = pr->readDouble("qty");
-  secId = pr->readString("secId");
-  secLinks = pr->readString("secLinks");
-  secType = pr->readString("secType");
-  sharesOutstanding = pr->readInt("sharesOutstanding");
-  underlyer = pr->readString("underlyer");
-  volatility = pr->readLong("volatility");
-  pid = pr->readInt("pid");
-}
-CacheableStringPtr PositionPdx::toString() const {
-  char buf[1024];
-  sprintf(buf, "PositionPdx Object:[ id=%d ]", this->pid);
-  return CacheableString::create(buf);
-}

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/pdxautoserializerclass/PositionPdx.hpp
----------------------------------------------------------------------
diff --git a/src/tests/cpp/pdxautoserializerclass/PositionPdx.hpp b/src/tests/cpp/pdxautoserializerclass/PositionPdx.hpp
deleted file mode 100644
index d2ce1c0..0000000
--- a/src/tests/cpp/pdxautoserializerclass/PositionPdx.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#pragma once
-
-#ifndef GEODE_PDXAUTOSERIALIZERCLASS_POSITIONPDX_H_
-#define GEODE_PDXAUTOSERIALIZERCLASS_POSITIONPDX_H_
-
-/*
- * 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.
- */
-
-/*
- * @brief User class for testing the put functionality for object.
- */
-
-#include <geode/GeodeCppCache.hpp>
-#include <geode/PdxSerializable.hpp>
-#include <geode/PdxWriter.hpp>
-#include <geode/PdxReader.hpp>
-#include <string>
-
-#ifdef _WIN32
-#ifdef BUILD_TESTOBJECT
-#define TESTOBJECT_EXPORT LIBEXP
-#else
-#define TESTOBJECT_EXPORT LIBIMP
-#endif
-#else
-#define TESTOBJECT_EXPORT
-#endif
-#define GFIGNORE(X) X
-#define GFEXCLUDE
-#define GFID
-#define GFARRAYSIZE(X)
-#define GFARRAYELEMSIZE(X)
-
-using namespace apache::geode::client;
-
-namespace AutoPdxTests {
-
-class GFIGNORE(TESTOBJECT_EXPORT) PositionPdx
-    : public apache::geode::client::PdxSerializable {
- private:
-  GFID int64_t avg20DaysVol;
-  GFID char* bondRating;
-  GFID double convRatio;
-  GFID char* country;
-  GFID double delta;
-  GFID int64_t industry;
-  GFID int64_t issuer;
-  GFID double mktValue;
-  GFID double qty;
-  GFID char *secId, *secLinks, *secType;
-  GFID int32_t sharesOutstanding;
-  GFID char* underlyer;
-  GFID int64_t volatility;
-
-  GFID int32_t pid;
-
- public:
-  GFEXCLUDE static int32_t cnt;
-
-  PositionPdx();
-  PositionPdx(const char* id, int32_t out);
-  // This constructor is just for some internal data validation test
-  PositionPdx(int32_t iForExactVal);
-  virtual ~PositionPdx();
-  using PdxSerializable::toData;
-  using PdxSerializable::fromData;
-  virtual void toData(PdxWriterPtr pw);
-  virtual void fromData(PdxReaderPtr pr);
-
-  CacheableStringPtr toString() const;
-
-  virtual uint32_t objectSize() const {
-    uint32_t objectSize = sizeof(PositionPdx);
-    return objectSize;
-  }
-
-  static void resetCounter() { cnt = 0; }
-
-  char* getSecId() { return secId; }
-
-  int32_t getId() { return pid; }
-
-  int32_t getSharesOutstanding() { return sharesOutstanding; }
-
-  static PdxSerializable* createDeserializable();
-
-  const char* getClassName() { return "PositionPdxType"; }
-
-  const char* getClassName() const { return "PositionPdxType"; }
-
- private:
-  void init();
-};
-
-typedef apache::geode::client::SharedPtr<PositionPdx> PositionPdxPtr;
-}  // namespace AutoPdxTests
-
-#endif  // GEODE_PDXAUTOSERIALIZERCLASS_POSITIONPDX_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/security/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/tests/cpp/security/CMakeLists.txt b/src/tests/cpp/security/CMakeLists.txt
index 45ebdfe..56828ec 100644
--- a/src/tests/cpp/security/CMakeLists.txt
+++ b/src/tests/cpp/security/CMakeLists.txt
@@ -24,7 +24,6 @@ target_link_libraries(security
     ACE
   PUBLIC
     fwk
-    pdxobject
     testobject
     crypto
     ssl

http://git-wip-us.apache.org/repos/asf/geode-native/blob/7da9d90b/src/tests/cpp/testobject/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/src/tests/cpp/testobject/CMakeLists.txt b/src/tests/cpp/testobject/CMakeLists.txt
index bd78b86..5122fd6 100644
--- a/src/tests/cpp/testobject/CMakeLists.txt
+++ b/src/tests/cpp/testobject/CMakeLists.txt
@@ -25,9 +25,6 @@ elseif(UNIX)
     set(DYNAMIC_LIBRARY_PATH LD_LIBRARY_PATH=$<TARGET_LINKER_FILE_DIR:apache-geode>)
 endif()
 
-macro(add_pdxautoserializer SOURCES_VAR NAMESPACE CLASS HEADER SUFFIX CLASSNAMESTR)
-    set(${SOURCES_VAR} ${${SOURCES_VAR}} ${CMAKE_CURRENT_SOURCE_DIR}/${NAMESPACE}_${CLASS}${SUFFIX}.cpp)
-endmacro()
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_library(testobject SHARED ${SOURCES})
@@ -37,7 +34,6 @@ target_link_libraries(testobject
   PUBLIC 
     apache-geode
     fwk
-    pdxobject
     c++11
   PRIVATE
     ACE


Mime
View raw message