geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [8/9] geode-native git commit: GEODE-2741: Removes last of SharedPtr/SharedBase.
Date Thu, 22 Jun 2017 18:01:31 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/SharedPtr.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/SharedPtr.hpp b/src/cppcache/include/geode/SharedPtr.hpp
deleted file mode 100644
index 610b08e..0000000
--- a/src/cppcache/include/geode/SharedPtr.hpp
+++ /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.
- */
-
-#pragma once
-
-#ifndef GEODE_SHAREDPTR_H_
-#define GEODE_SHAREDPTR_H_
-
-// TODO shared_ptr - remove this file.
-
-#include "SharedBase.hpp"
-#include "SharedPtrHelper.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-typedef SharedPtr<SharedBase> SharedBasePtr;
-
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_SHAREDPTR_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/SharedPtrHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/SharedPtrHelper.hpp b/src/cppcache/include/geode/SharedPtrHelper.hpp
deleted file mode 100644
index a1f4219..0000000
--- a/src/cppcache/include/geode/SharedPtrHelper.hpp
+++ /dev/null
@@ -1,86 +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.
- */
-
-#pragma once
-
-#ifndef GEODE_SHAREDPTRHELPER_H_
-#define GEODE_SHAREDPTRHELPER_H_
-
-// TODO shared_ptr - remove this file.
-
-#include <typeinfo>
-
-#include "geode_globals.hpp"
-#include "TypeHelper.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class SharedBase;
-
-/** Helper class for SharedPtr exceptions
- */
-class CPPCACHE_EXPORT SPEHelper {
- public:
-  static void throwNullPointerException(const char* ename);
-
-  static void throwClassCastException(const char* msg, const char* fromType,
-                                      const char* toType);
-};
-
-/* Helper function template for type conversion.
- */
-template <class Target, class Src>
-Target* getTargetHelper(Src* ptr,
-                        apache::geode::client::TypeHelper::yes_type yes) {
-  return ptr;
-}
-
-/* Helper function template for type conversion.
- */
-template <class Target, class Src>
-Target* getTargetHelper(Src* ptr,
-                        apache::geode::client::TypeHelper::no_type no) {
-  Target* tptr = dynamic_cast<Target*>(ptr);
-  if (tptr) {
-    return tptr;
-  } else {
-    SPEHelper::throwClassCastException("getTargetHelper: cast failed",
-                                       typeid(ptr).name(), typeid(tptr).name());
-    return nullptr;
-  }
-}
-
-/* Helper function template for type conversion.
- */
-template <class Target, class Src>
-Target* getTarget(Src* ptr) {
-  return getTargetHelper<Target>(ptr, GF_SRC_IS_TARGET_TYPE(Target, Src));
-}
-
-/* Helper function template for type conversion.
- */
-template <class Src>
-SharedBase* getSB(Src* ptr) {
-  return getTarget<SharedBase>(ptr);
-}
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_SHAREDPTRHELPER_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/TransactionId.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/TransactionId.hpp b/src/cppcache/include/geode/TransactionId.hpp
index 63a4c14..b0f110f 100644
--- a/src/cppcache/include/geode/TransactionId.hpp
+++ b/src/cppcache/include/geode/TransactionId.hpp
@@ -21,8 +21,7 @@
  */
 
 #include <memory>
-
-#include "SharedBase.hpp"
+#include "geode_base.hpp"
 
 namespace apache {
 namespace geode {
@@ -33,8 +32,8 @@ namespace client {
 * @see Cache#getCacheTransactionManager
 * @see CacheTransactionManager#getTransactionId
 */
-class CPPCACHE_EXPORT TransactionId : public apache::geode::client::SharedBase {
- protected:
+class CPPCACHE_EXPORT TransactionId {
+ public:
   TransactionId();
   virtual ~TransactionId();
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/TypeHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/TypeHelper.hpp b/src/cppcache/include/geode/TypeHelper.hpp
deleted file mode 100644
index 149ea80..0000000
--- a/src/cppcache/include/geode/TypeHelper.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#pragma once
-
-#ifndef GEODE_TYPEHELPER_H_
-#define GEODE_TYPEHELPER_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.
- */
-
-/**
- * @file Contains helper classes for extracting compile-time type traits
- */
-
-#include "geode_globals.hpp"
-#include <memory>
-
-namespace apache {
-namespace geode {
-namespace client {
-
-// TODO share_ptr - remove this and replace with explicit std::shared_ptr defs.
-template <class Target>
-using SharedPtr = std::shared_ptr<Target>;
-
-// Forward declaration of CacheableArrayType<T, ID>
-template <typename Target, int8_t TYPEID>
-class CacheableArrayType;
-
-template <typename TObj, int8_t TYPEID>
-using SharedArrayPtr = SharedPtr<CacheableArrayType<TObj, TYPEID>>;
-
-/**
- * @brief Helper type traits and other structs/classes to 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. For an explanation of how this works see:
- *        {@link
- * http://groups.google.com/group/comp.lang.c++.moderated/msg/dd6c4e4d5160bd83}
- *        {@link
- * http://groups.google.com/group/comp.lang.c++.moderated/msg/645b2486ae80e5fb}
- */
-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);
-};
-
-/**
- * @brief Specialization of <code>SuperSubclass</code> to return true
- *        for the special case when the two types being checked are same.
- */
-template <typename TBase>
-struct SuperSubclass<TBase, TBase> {
-  static const bool result = true;
-};
-
-/**
- * @brief This struct helps convert a boolean value into static objects
- *        of different types. Useful for matching of template functions.
- */
-template <bool getType = true>
-struct YesNoType {
-  static const yes_type value = 0;
-};
-
-/**
- * @brief Specialization of YesNoType for boolean value false.
- */
-template <>
-struct YesNoType<false> {
-  static const no_type value = 0;
-};
-
-/** @brief This struct unwraps the type <code>T</code> inside SharedPtr. */
-template <class T>
-struct UnwrapSharedPtr {};
-
-/** @brief This struct unwraps the type <code>T</code> inside SharedPtr. */
-template <class T>
-struct UnwrapSharedPtr<SharedPtr<T> > {
-  typedef T type;
-};
-
-/** @brief This struct unwraps the type <code>T</code> inside SharedArrayPtr. */
-template <class T, int8_t ID>
-struct UnwrapSharedPtr<SharedArrayPtr<T, ID> > {
-  typedef CacheableArrayType<T, ID> type;
-};
-}  // namespace TypeHelper
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-/** @brief Macro to unwrap the type <code>T</code> inside SharedPtr. */
-#define GF_UNWRAP_SP(T) \
-  typename apache::geode::client::TypeHelper::UnwrapSharedPtr<T>::type
-
-/**
- * @brief Macro to determine if the type <code>T</code> is derived from
- *        <code>Serializable</code>.
- */
-#define GF_TYPE_IS_SERIALIZABLE(T)                  \
-  apache::geode::client::TypeHelper::SuperSubclass< \
-      apache::geode::client::Serializable, T>::result
-
-/**
- * @brief Macro that returns <code>yes_type</code> if the type <code>T</code> is
- *        derived from <code>Serializable</code> and <code>no_type</code>
- *        otherwise. Useful for overloaded template functions.
- */
-#define GF_TYPE_IS_SERIALIZABLE_TYPE(T)                                 \
-  apache::geode::client::TypeHelper::YesNoType<GF_TYPE_IS_SERIALIZABLE( \
-      T)>::value
-
-#define GF_SRC_IS_TARGET_TYPE(TARGET, SRC)                     \
-  apache::geode::client::TypeHelper::YesNoType<                \
-      apache::geode::client::TypeHelper::SuperSubclass<TARGET, \
-                                                       SRC>::result>::value
-
-#endif  // GEODE_TYPEHELPER_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/UserData.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/UserData.hpp b/src/cppcache/include/geode/UserData.hpp
index 467a0c4..c722d4b 100644
--- a/src/cppcache/include/geode/UserData.hpp
+++ b/src/cppcache/include/geode/UserData.hpp
@@ -32,7 +32,7 @@ namespace geode {
 namespace client {
 
 typedef Serializable UserData;
-typedef SharedPtr<UserData> UserDataPtr;
+typedef std::shared_ptr<UserData> UserDataPtr;
 }  // namespace client
 }  // namespace geode
 }  // namespace apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/UserFunctionExecutionException.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/UserFunctionExecutionException.hpp b/src/cppcache/include/geode/UserFunctionExecutionException.hpp
index 3ca4634..01e5a40 100644
--- a/src/cppcache/include/geode/UserFunctionExecutionException.hpp
+++ b/src/cppcache/include/geode/UserFunctionExecutionException.hpp
@@ -27,51 +27,51 @@ namespace apache {
 namespace geode {
 namespace client {
 class UserFunctionExecutionException;
-typedef SharedPtr<UserFunctionExecutionException>
+typedef std::shared_ptr<UserFunctionExecutionException>
     UserFunctionExecutionExceptionPtr;
 
 /**
-* @brief UserFunctionExecutionException class is used to encapsulate geode
-*sendException in case of Function execution.
-**/
+ * @brief UserFunctionExecutionException class is used to encapsulate geode
+ *sendException in case of Function execution.
+ **/
 class UserFunctionExecutionException : public Serializable {
   /**
-  * @brief public methods
-  */
+   * @brief public methods
+   */
 
  public:
   /**
-  * @brief destructor
-  */
+   * @brief destructor
+   */
   virtual ~UserFunctionExecutionException() {}
 
   /**
-  * @brief constructors
-  */
+   * @brief constructors
+   */
   UserFunctionExecutionException(CacheableStringPtr msg);
 
   /**
-  *@brief serialize this object
-  * @throws IllegalStateException If this api is called from User code.
-  **/
+   *@brief serialize this object
+   * @throws IllegalStateException If this api is called from User code.
+   **/
   virtual void toData(DataOutput& output) const;
 
   /**
-  *@brief deserialize this object, typical implementation should return
-  * the 'this' pointer.
-  * @throws IllegalStateException If this api is called from User code.
-  **/
+   *@brief deserialize this object, typical implementation should return
+   * the 'this' pointer.
+   * @throws IllegalStateException If this api is called from User code.
+   **/
   virtual Serializable* fromData(DataInput& input);
 
   /**
-  *@brief Return the classId of the instance being serialized.
-  * This is used by deserialization to determine what instance
-  * type to create and deserialize into.
-  *
-  * The classId must be unique within an application suite.
-  * Using a negative value may result in undefined behavior.
-  * @throws IllegalStateException If this api is called from User code.
-  */
+   *@brief Return the classId of the instance being serialized.
+   * This is used by deserialization to determine what instance
+   * type to create and deserialize into.
+   *
+   * The classId must be unique within an application suite.
+   * Using a negative value may result in undefined behavior.
+   * @throws IllegalStateException If this api is called from User code.
+   */
   virtual int32_t classId() const;
 
   /**
@@ -82,7 +82,7 @@ class UserFunctionExecutionException : public Serializable {
    * cache memory utilization.
    * Note that you must implement this only if you use the HeapLRU feature.
    * @throws IllegalStateException If this api is called from User code.
- */
+   */
   virtual uint32_t objectSize() const;
 
   /**
@@ -96,15 +96,15 @@ class UserFunctionExecutionException : public Serializable {
   virtual int8_t typeId() const;
 
   /**
-  *@brief return as CacheableStringPtr the Exception message returned from
-  *geode sendException api.
-  **/
+   *@brief return as CacheableStringPtr the Exception message returned from
+   *geode sendException api.
+   **/
   CacheableStringPtr getMessage() { return m_message; }
 
   /**
-  *@brief return as CacheableStringPtr the Exception name returned from geode
-  *sendException api.
-  **/
+   *@brief return as CacheableStringPtr the Exception name returned from geode
+   *sendException api.
+   **/
   CacheableStringPtr getName() {
     const char* msg = "UserFunctionExecutionException";
     CacheableStringPtr str = CacheableString::create(msg);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/VectorOfSharedBase.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/VectorOfSharedBase.hpp b/src/cppcache/include/geode/VectorOfSharedBase.hpp
deleted file mode 100644
index 537fb4c..0000000
--- a/src/cppcache/include/geode/VectorOfSharedBase.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#pragma once
-
-#ifndef GEODE_VECTOROFSHAREDBASE_H_
-#define GEODE_VECTOROFSHAREDBASE_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 "SharedPtr.hpp"
-#ifdef BUILD_CPPCACHE
-#include <vector>
-#endif
-
-/** @file
-*/
-
-namespace apache {
-namespace geode {
-namespace client {
-
-#ifdef BUILD_CPPCACHE
-typedef std::vector<apache::geode::client::SharedBasePtr> VofSBP;
-typedef VofSBP::const_iterator VofSBPIterator;
-#else
-class VofSBP;
-class VofSBPIterator;
-#endif
-
-/** Represents a vector of <code>apache::geode::client::SharedBasePtr</code>
-*/
-class CPPCACHE_EXPORT VectorOfSharedBase {
- private:
-  VofSBP* m_stdvector;
-
- public:
-  /** Interface of an iterator for <code>VectorOfSharedBase</code>.*/
-  class CPPCACHE_EXPORT Iterator {
-   private:
-    VofSBPIterator* m_iter;
-
-    Iterator(const VofSBPIterator& iter);
-    // Never defined.
-    Iterator();
-
-   private:
-    const Iterator& operator=(const Iterator&);
-
-   public:
-    Iterator(const Iterator& other);
-
-    const SharedBasePtr operator*() const;
-
-    Iterator& operator++();
-
-    void operator++(int);
-
-    bool operator==(const Iterator& other) const;
-
-    bool operator!=(const Iterator& other) const;
-
-    ~Iterator();
-
-    friend class VectorOfSharedBase;
-  };
-
-  /** return the size of the vector. */
-  int32_t size() const;
-
-  /** return the largest possible size of the vector. */
-  int32_t max_size() const;
-
-  /** return the number of elements allocated for this vector. */
-  int32_t capacity() const;
-
-  /** return true if the vector's size is 0. */
-  bool empty() const;
-
-  /** Return the n'th element */
-  SharedBasePtr& operator[](int32_t n);
-
-  /** Return the n'th element */
-  const SharedBasePtr& operator[](int32_t n) const;
-
-  /** Return the n'th element with bounds checking. */
-  SharedBasePtr& at(int32_t n);
-
-  /** Return the n'th element with bounds checking. */
-  SharedBasePtr& at(int32_t n) const;
-
-  /** Get an iterator pointing to the start of vector. */
-  Iterator begin() const;
-
-  /** Get an iterator pointing to the end of vector. */
-  Iterator end() const;
-
-  /** Create an empty vector. */
-  VectorOfSharedBase();
-
-  /** Create a vector with n elements allocated */
-  VectorOfSharedBase(int32_t n);
-
-  /** Create a vector with n copies of t */
-  VectorOfSharedBase(int32_t n, const SharedBasePtr& t);
-
-  /** copy constructor */
-  VectorOfSharedBase(const VectorOfSharedBase& other);
-
-  /** destructor, sets all SharedPtr elements to nullptr */
-  ~VectorOfSharedBase();
-
-  /** assignment operator */
-  VectorOfSharedBase& operator=(const VectorOfSharedBase& other);
-
-  /** reallocate a vector to hold n elements. */
-  void reserve(int32_t n);
-
-  /** returns the first element. */
-  SharedBasePtr& front();
-
-  /** returns the first element. */
-  const SharedBasePtr& front() const;
-
-  /** returns the last element. */
-  SharedBasePtr& back();
-
-  /** returns the last element. */
-  const SharedBasePtr& back() const;
-
-  /** insert a new element at the end. */
-  void push_back(const SharedBasePtr& e);
-
-  /** removes the last element. */
-  void pop_back();
-
-  /** swaps the contents of two vectors. */
-  void swap(VectorOfSharedBase& other);
-
-  /** erases all elements. */
-  void clear();
-
-  /** inserts or erases elements at the end such that size becomes n.
-   *  Not to be confused with reserve which simply allocates the space,
-   *  resize fills the space with active elements. */
-  void resize(int32_t n, const SharedBasePtr& t = nullptr);
-
-  /** insert object at the given index. */
-  void insert(int32_t index, const SharedBasePtr& t);
-
-  /** removes the object at the specified index from a vector
-  */
-  void erase(int32_t index);
-};
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_VECTOROFSHAREDBASE_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/WritablePdxInstance.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/WritablePdxInstance.hpp b/src/cppcache/include/geode/WritablePdxInstance.hpp
index 621c5e2..029119c 100644
--- a/src/cppcache/include/geode/WritablePdxInstance.hpp
+++ b/src/cppcache/include/geode/WritablePdxInstance.hpp
@@ -20,7 +20,7 @@
  * limitations under the License.
  */
 
-#include "SharedPtr.hpp"
+#include <memory>
 #include "Cacheable.hpp"
 
 #include "PdxInstance.hpp"
@@ -30,502 +30,503 @@ namespace geode {
 namespace client {
 
 /**
-* WritablePdxInstance is a {@link PdxInstance} that also supports field
-* modification
-* using the {@link #setField} method.
-* To get a WritablePdxInstance call {@link PdxInstance#createWriter}.
-*/
+ * WritablePdxInstance is a {@link PdxInstance} that also supports field
+ * modification
+ * using the {@link #setField} method.
+ * To get a WritablePdxInstance call {@link PdxInstance#createWriter}.
+ */
 class CPPCACHE_EXPORT WritablePdxInstance : public PdxInstance {
   /**
-  * @brief public methods
-  */
+   * @brief public methods
+   */
 
  public:
   /**
-  * @brief destructor
-  */
+   * @brief destructor
+   */
   virtual ~WritablePdxInstance() {}
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * CacheablePtr type is corresponding to java object type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type CacheablePtr
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * CacheablePtr type is corresponding to java object type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type CacheablePtr
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, CacheablePtr value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * bool type is corresponding to java boolean type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type bool
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * bool type is corresponding to java boolean type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type bool
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, bool value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * signed char type is corresponding to java byte type.
-  * For C++ on Windows and Linux, signed char type is corresponding to int8_t
-  * type.
-  * However C++ users on Solaris should always use this api after casting int8_t
-  * to signed char.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type signed char
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * signed char type is corresponding to java byte type.
+   * For C++ on Windows and Linux, signed char type is corresponding to int8_t
+   * type.
+   * However C++ users on Solaris should always use this api after casting
+   * int8_t to signed char.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type signed char
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, signed char value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * unsigned char type is corresponding to java byte type.
-  * For C++ on Windows and Linux, unsigned char type is corresponding to int8_t
-  * type.
-  * However C++ users on Solaris should always use this api after casting int8_t
-  * to unsigned char.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type unsigned char
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * unsigned char type is corresponding to java byte type.
+   * For C++ on Windows and Linux, unsigned char type is corresponding to int8_t
+   * type.
+   * However C++ users on Solaris should always use this api after casting
+   * int8_t to unsigned char.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type unsigned char
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, unsigned char value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int16_t type is corresponding to java short type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int16_t
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int16_t type is corresponding to java short type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int16_t
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int16_t value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int32_t type is corresponding to java int type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int32_t
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int32_t type is corresponding to java int type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int32_t
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int32_t value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int64_t type is corresponding to java long type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int64_t
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int64_t type is corresponding to java long type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int64_t
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int64_t value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * float type is corresponding to java float type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type float
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * float type is corresponding to java float type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type float
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, float value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * double type is corresponding to java double type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type double
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * double type is corresponding to java double type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type double
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, double value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * wchar_t type is corresponding to java char type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type wchar_t
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * wchar_t type is corresponding to java char type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type wchar_t
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, wchar_t value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * char type is corresponding to java char type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type char
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * char type is corresponding to java char type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type char
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, char value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * CacheableDatePtr type is corresponding to java Java.util.date type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type CacheableDatePtr
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * CacheableDatePtr type is corresponding to java Java.util.date type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type CacheableDatePtr
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, CacheableDatePtr value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * bool* type is corresponding to java boolean[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type bool array
-  * @param length
-  *          The number of elements in bool array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * bool* type is corresponding to java boolean[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type bool array
+   * @param length
+   *          The number of elements in bool array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, bool* value, int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * signed char* type is corresponding to java byte[] type.
-  * For C++ on Windows and Linux, signed char* type is corresponding to int8_t*
-  * type.
-  * However C++ users on Solaris should always use this api after casting
-  * int8_t* to signed char*.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type signed char array
-  * @param length
-  *          The number of elements in signed char array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * signed char* type is corresponding to java byte[] type.
+   * For C++ on Windows and Linux, signed char* type is corresponding to int8_t*
+   * type.
+   * However C++ users on Solaris should always use this api after casting
+   * int8_t* to signed char*.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type signed char array
+   * @param length
+   *          The number of elements in signed char array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, signed char* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * unsigned char* type is corresponding to java byte[] type.
-  * For C++ on Windows and Linux, unsigned char* type is corresponding to
-  * int8_t* type.
-  * However C++ users on Solaris should always use this api after casting
-  * int8_t* to unsigned char*.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type unsigned char array
-  * @param length
-  *          The number of elements in unsigned char array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * unsigned char* type is corresponding to java byte[] type.
+   * For C++ on Windows and Linux, unsigned char* type is corresponding to
+   * int8_t* type.
+   * However C++ users on Solaris should always use this api after casting
+   * int8_t* to unsigned char*.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type unsigned char array
+   * @param length
+   *          The number of elements in unsigned char array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, unsigned char* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int16_t* type is corresponding to java short[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int16_t array
-  * @param length
-  *          The number of elements in int16_t array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int16_t* type is corresponding to java short[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int16_t array
+   * @param length
+   *          The number of elements in int16_t array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int16_t* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int32_t* type is corresponding to java int[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int32_t array
-  * @param length
-  *          The number of elements in int32_t array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int32_t* type is corresponding to java int[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int32_t array
+   * @param length
+   *          The number of elements in int32_t array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int32_t* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int64_t* type is corresponding to java long[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type int64_t array
-  * @param length
-  *          The number of elements in int64_t array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int64_t* type is corresponding to java long[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type int64_t array
+   * @param length
+   *          The number of elements in int64_t array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int64_t* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * float* type is corresponding to java float[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type float array
-  * @param length
-  *          The number of elements in float array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * float* type is corresponding to java float[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type float array
+   * @param length
+   *          The number of elements in float array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, float* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * double* type is corresponding to java double[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type double array
-  * @param length
-  *          The number of elements in double array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * double* type is corresponding to java double[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type double array
+   * @param length
+   *          The number of elements in double array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, double* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * wchar_t* type is corresponding to java String type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type wchar_t*
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * wchar_t* type is corresponding to java String type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type wchar_t*
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, const wchar_t* value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * char* type is corresponding to java String type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type char*
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * char* type is corresponding to java String type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type char*
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, const char* value) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * wchar_t* type is corresponding to java char[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type wchar_t array
-  * @param length
-  *          The number of elements in wchar_t array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * wchar_t* type is corresponding to java char[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type wchar_t array
+   * @param length
+   *          The number of elements in wchar_t array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, wchar_t* value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * char* type is corresponding to java char[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type char array
-  * @param length
-  *          The number of elements in char array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * char* type is corresponding to java char[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type char array
+   * @param length
+   *          The number of elements in char array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, char* value, int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * wchar_t** type is corresponding to java String[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type wchar_t* array
-  * @param length
-  *          The number of elements in WCString array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * wchar_t** type is corresponding to java String[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type wchar_t* array
+   * @param length
+   *          The number of elements in WCString array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, wchar_t** value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * char** type is corresponding to java String[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type char* array
-  * @param length
-  *          The number of elements in CString array type.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * char** type is corresponding to java String[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type char* array
+   * @param length
+   *          The number of elements in CString array type.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, char** value,
                         int32_t length) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * int8_t** type is corresponding to java byte[][] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type array of byte arrays
-  * @param arrayLength
-  *          The number of byte arrays.
-  * @param elementLength
-  *          The lengths of individual byte arrays.
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * int8_t** type is corresponding to java byte[][] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type array of byte arrays
+   * @param arrayLength
+   *          The number of byte arrays.
+   * @param elementLength
+   *          The lengths of individual byte arrays.
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName, int8_t** value,
                         int32_t arrayLength, int32_t* elementLength) = 0;
 
   /**
-  * Set the existing named field to the given value.
-  * The setField method has copy-on-write semantics.
-  * So for the modifications to be stored in the cache the WritablePdxInstance
-  * must be put into a region after setField has been called one or more times.
-  * CacheableObjectArrayPtr type is corresponding to java Object[] type.
-  * @param fieldName
-  *          name of the field whose value will be set
-  * @param value
-  *          value that will be set to the field of type CacheableObjectArrayPtr
-  * @throws IllegalStateException if the named field does not exist
-  * or if the type of the value is not compatible with the field.
-  */
+   * Set the existing named field to the given value.
+   * The setField method has copy-on-write semantics.
+   * So for the modifications to be stored in the cache the WritablePdxInstance
+   * must be put into a region after setField has been called one or more times.
+   * CacheableObjectArrayPtr type is corresponding to java Object[] type.
+   * @param fieldName
+   *          name of the field whose value will be set
+   * @param value
+   *          value that will be set to the field of type
+   * CacheableObjectArrayPtr
+   * @throws IllegalStateException if the named field does not exist
+   * or if the type of the value is not compatible with the field.
+   */
   virtual void setField(const char* fieldName,
                         CacheableObjectArrayPtr value) = 0;
 
  protected:
   /**
-  * @brief constructors
-  */
+   * @brief constructors
+   */
   WritablePdxInstance(){};
 
  private:

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/geode_base.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/geode_base.hpp b/src/cppcache/include/geode/geode_base.hpp
index d506d22..b45b2f8 100644
--- a/src/cppcache/include/geode/geode_base.hpp
+++ b/src/cppcache/include/geode/geode_base.hpp
@@ -269,26 +269,6 @@ typedef enum {
 
 #include <new>
 
-#ifdef _WIN32
-
-typedef void *(*pNew)(size_t);
-typedef void (*pDelete)(void *);
-
-namespace apache {
-namespace geode {
-namespace client {
-extern void setDefaultNewAndDelete();
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-void *operator new(size_t size);
-void operator delete(void *p);
-void *operator new[](size_t size);
-void operator delete[](void *p);
-
-#endif  // _WIN32
-
 /** Allocates x and throws OutOfMemoryException if it fails */
 #define GF_NEW(v, stmt)                                                 \
   {                                                                     \
@@ -314,8 +294,10 @@ void operator delete[](void *p);
     x = nullptr;                \
   }
 
-// TODO shared_ptre - make C+11 library dependent or make constructor destructor
-// public
+// TODO shared_ptr - Consider making con/destructors public.
+/*
+ * Allows std::shared_ptr to access protected constructors and destructors.
+ */
 #if defined(__clang__)
 #define FRIEND_STD_SHARED_PTR(_T)                                      \
   friend std::__libcpp_compressed_pair_imp<std::allocator<_T>, _T, 1>; \

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/geode_globals.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/geode_globals.hpp b/src/cppcache/include/geode/geode_globals.hpp
index 2333bfd..9c112b2 100644
--- a/src/cppcache/include/geode/geode_globals.hpp
+++ b/src/cppcache/include/geode/geode_globals.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_GLOBALS_H_
-#define GEODE_GFCPP_GLOBALS_H_
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -20,6 +15,11 @@
  * limitations under the License.
  */
 
+#pragma once
+
+#ifndef GEODE_GFCPP_GLOBALS_H_
+#define GEODE_GFCPP_GLOBALS_H_
+
 /**
  * @file
  */
@@ -128,10 +128,6 @@ namespace client {
 
 extern void CPPCACHE_EXPORT millisleep(uint32_t millis);
 
-#ifdef _WIN32
-extern void CPPCACHE_EXPORT setNewAndDelete(pNew, pDelete);
-#endif
-
 }  // namespace client
 }  // namespace geode
 }  // namespace apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/geode_types.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/geode_types.hpp b/src/cppcache/include/geode/geode_types.hpp
index 6fb90c4..25ce7e3 100644
--- a/src/cppcache/include/geode/geode_types.hpp
+++ b/src/cppcache/include/geode/geode_types.hpp
@@ -20,7 +20,9 @@
  * limitations under the License.
  */
 
-#include "SharedPtr.hpp"
+#include <memory>
+
+#include "geode_globals.hpp"
 
 /**
  * @file
@@ -34,7 +36,7 @@ class CacheFactory;
 
 #define _GF_PTR_DEF_(a, b) \
   class CPPCACHE_EXPORT a; \
-  typedef SharedPtr<a> b;
+  typedef std::shared_ptr<a> b;
 
 _GF_PTR_DEF_(DistributedSystem, DistributedSystemPtr);
 _GF_PTR_DEF_(CacheFactory, CacheFactoryPtr);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/include/geode/utils.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/utils.hpp b/src/cppcache/include/geode/utils.hpp
index f05c445..be9a76e 100644
--- a/src/cppcache/include/geode/utils.hpp
+++ b/src/cppcache/include/geode/utils.hpp
@@ -1,10 +1,7 @@
 #pragma once
 
-// TODO shared_ptr rename to avoid collision with Util.hpp. Consider
-// Equality.hpp?
-
-#ifndef GEODE_UTILSX_H_
-#define GEODE_UTILSX_H_
+#ifndef GEODE_UTILS_H_
+#define GEODE_UTILS_H_
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -77,4 +74,4 @@ struct dereference_equal_to<_T*> : std::equal_to<_T*> {
 }  // namespace geode
 }  // namespace apache
 
-#endif  // GEODE_UTILSX_H_
+#endif  // GEODE_UTILS_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/CacheHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/CacheHelper.cpp b/src/cppcache/integration-test/CacheHelper.cpp
index cf73dbf..bba3dcd 100644
--- a/src/cppcache/integration-test/CacheHelper.cpp
+++ b/src/cppcache/integration-test/CacheHelper.cpp
@@ -856,7 +856,7 @@ CacheableStringPtr CacheHelper::createCacheable(const char* value) {
 }
 
 void CacheHelper::showKeys(VectorOfCacheableKey& vecKeys) {
-  fprintf(stdout, "vecKeys.size() = %d\n", vecKeys.size());
+  fprintf(stdout, "vecKeys.size() = %zd\n", vecKeys.size());
   for (uint32_t i = 0; i < static_cast<uint32_t>(vecKeys.size()); i++) {
     char msg[1024];
     size_t wrote = vecKeys.at(i)->logString(msg, 1023);
@@ -1373,7 +1373,7 @@ void CacheHelper::createDuplicateXMLFile(std::string& originalFile,
   std::string s(cmd);
   CacheHelper::staticConfigFileList.push_back(s);
 
-  printf("createDuplicateXMLFile added file %s %ld", cmd,
+  printf("createDuplicateXMLFile added file %s %zd", cmd,
          CacheHelper::staticConfigFileList.size());
 }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/DeltaEx.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/DeltaEx.hpp b/src/cppcache/integration-test/DeltaEx.hpp
index 3937cc2..a502b31 100644
--- a/src/cppcache/integration-test/DeltaEx.hpp
+++ b/src/cppcache/integration-test/DeltaEx.hpp
@@ -160,6 +160,6 @@ class PdxDeltaEx : public PdxSerializable, public Delta {
     return CacheableString::create(idbuf);
   }
 };
-typedef SharedPtr<PdxDeltaEx> PdxDeltaExPtr;
+typedef std::shared_ptr<PdxDeltaEx> PdxDeltaExPtr;
 
 #endif  // GEODE_INTEGRATION_TEST_DELTAEX_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/QueryHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/QueryHelper.hpp b/src/cppcache/integration-test/QueryHelper.hpp
index 1bd3469..90d5daf 100644
--- a/src/cppcache/integration-test/QueryHelper.hpp
+++ b/src/cppcache/integration-test/QueryHelper.hpp
@@ -309,7 +309,7 @@ bool QueryHelper::verifyRS(SelectResultsPtr& resultSet, int expectedRows) {
   }
 
   ResultSetPtr rsptr =
-      std::static_pointer_cast<GF_UNWRAP_SP(ResultSetPtr)>(resultSet);
+      std::static_pointer_cast<ResultSet>(resultSet);
 
   int foundRows = 0;
 
@@ -337,7 +337,7 @@ bool QueryHelper::verifySS(SelectResultsPtr& structSet, int expectedRows,
   }
 
   StructSetPtr ssptr =
-      std::static_pointer_cast<GF_UNWRAP_SP(StructSetPtr)>(structSet);
+      std::static_pointer_cast<StructSet>(structSet);
 
   int foundRows = 0;
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/TallyListener.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/TallyListener.hpp b/src/cppcache/integration-test/TallyListener.hpp
index d9c5386..1d94a0f 100644
--- a/src/cppcache/integration-test/TallyListener.hpp
+++ b/src/cppcache/integration-test/TallyListener.hpp
@@ -26,7 +26,7 @@
 using namespace apache::geode::client;
 class TallyListener;
 
-typedef apache::geode::client::SharedPtr<TallyListener> TallyListenerPtr;
+typedef std::shared_ptr<TallyListener> TallyListenerPtr;
 
 class TallyListener : public CacheListener {
  private:

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/TallyLoader.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/TallyLoader.hpp b/src/cppcache/integration-test/TallyLoader.hpp
index cf7e84a..6b72ab1 100644
--- a/src/cppcache/integration-test/TallyLoader.hpp
+++ b/src/cppcache/integration-test/TallyLoader.hpp
@@ -27,7 +27,7 @@ using namespace test;
 
 class TallyLoader;
 
-typedef apache::geode::client::SharedPtr<TallyLoader> TallyLoaderPtr;
+typedef std::shared_ptr<TallyLoader> TallyLoaderPtr;
 
 class TallyLoader : virtual public CacheLoader {
  private:

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/TallyWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/TallyWriter.hpp b/src/cppcache/integration-test/TallyWriter.hpp
index e1e49c5..9a99b7a 100644
--- a/src/cppcache/integration-test/TallyWriter.hpp
+++ b/src/cppcache/integration-test/TallyWriter.hpp
@@ -27,7 +27,7 @@ using namespace test;
 
 class TallyWriter;
 
-typedef apache::geode::client::SharedPtr<TallyWriter> TallyWriterPtr;
+typedef std::shared_ptr<TallyWriter> TallyWriterPtr;
 
 class TallyWriter : virtual public CacheWriter {
  private:

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientDistOps.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientDistOps.hpp b/src/cppcache/integration-test/ThinClientDistOps.hpp
index 339d179..20364cc 100644
--- a/src/cppcache/integration-test/ThinClientDistOps.hpp
+++ b/src/cppcache/integration-test/ThinClientDistOps.hpp
@@ -282,7 +282,7 @@ void createAndVerifyEntry(const char* name) {
     auto longRetValue =
         std::dynamic_pointer_cast<CacheableInt64>(regPtr->get(int64Key));
     FAIL("Expected EntryExistException here");
-  } catch (EntryExistsException& e) {
+  } catch (EntryExistsException& ) {
     LOG(" Expected EntryExistsException exception thrown by localCreate");
   }
 
@@ -339,7 +339,7 @@ void createAndVerifyEntry(const char* name) {
       regPtr->create(keyObject2, in64Value);
       FAIL("Expected EntryExistException here");
     }
-  } catch (EntryExistsException& e) {
+  } catch (EntryExistsException& ) {
     LOG(" Expected EntryExistsException exception thrown by localCreate");
   }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientDurable.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientDurable.hpp b/src/cppcache/integration-test/ThinClientDurable.hpp
index 52d5774..a10ef20 100644
--- a/src/cppcache/integration-test/ThinClientDurable.hpp
+++ b/src/cppcache/integration-test/ThinClientDurable.hpp
@@ -134,7 +134,7 @@ class OperMonitor : public CacheListener {
   virtual void afterRegionInvalidate(const RegionEvent& event){};
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
-typedef SharedPtr<OperMonitor> OperMonitorPtr;
+typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
 void setCacheListener(const char* regName, OperMonitorPtr monitor) {
   RegionPtr reg = getHelper()->getRegion(regName);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientDurableFailover.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientDurableFailover.hpp b/src/cppcache/integration-test/ThinClientDurableFailover.hpp
index 3a3318a..628c342 100644
--- a/src/cppcache/integration-test/ThinClientDurableFailover.hpp
+++ b/src/cppcache/integration-test/ThinClientDurableFailover.hpp
@@ -129,7 +129,7 @@ class OperMonitor : public CacheListener {
   virtual void afterRegionInvalidate(const RegionEvent& event){};
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
-typedef SharedPtr<OperMonitor> OperMonitorPtr;
+typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
 void setCacheListener(const char* regName, OperMonitorPtr monitor) {
   RegionPtr reg = getHelper()->getRegion(regName);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientDurableInterest.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientDurableInterest.hpp b/src/cppcache/integration-test/ThinClientDurableInterest.hpp
index 01225a5..eba3789 100644
--- a/src/cppcache/integration-test/ThinClientDurableInterest.hpp
+++ b/src/cppcache/integration-test/ThinClientDurableInterest.hpp
@@ -111,7 +111,7 @@ class OperMonitor : public CacheListener {
     LOG("afterRegionLive called.");
   }
 };
-typedef SharedPtr<OperMonitor> OperMonitorPtr;
+typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
 const char* mixKeys[] = {"Key-1", "D-Key-1", "Key-2", "D-Key-2"};
 const char* testRegex[] = {"D-Key-.*", "Key-.*"};

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientDurableReconnect.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientDurableReconnect.hpp b/src/cppcache/integration-test/ThinClientDurableReconnect.hpp
index 935dfaa..9ec709d 100644
--- a/src/cppcache/integration-test/ThinClientDurableReconnect.hpp
+++ b/src/cppcache/integration-test/ThinClientDurableReconnect.hpp
@@ -64,7 +64,7 @@ class OperMonitor : public CacheListener {
     LOG("Listener Close Called");
   }
 };
-typedef SharedPtr<OperMonitor> OperMonitorPtr;
+typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
 void setCacheListener(const char* regName, OperMonitorPtr monitor) {
   RegionPtr reg = getHelper()->getRegion(regName);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientGatewayTest.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientGatewayTest.hpp b/src/cppcache/integration-test/ThinClientGatewayTest.hpp
index 571c016..5d60765 100644
--- a/src/cppcache/integration-test/ThinClientGatewayTest.hpp
+++ b/src/cppcache/integration-test/ThinClientGatewayTest.hpp
@@ -62,7 +62,7 @@ class MyListener : public CacheListener {
   int getNumEvents() { return m_events; }
 };
 
-typedef apache::geode::client::SharedPtr<MyListener> MyListenerPtr;
+typedef std::shared_ptr<MyListener> MyListenerPtr;
 
 void setCacheListener(const char* regName, TallyListenerPtr regListener) {
   RegionPtr reg = getHelper()->getRegion(regName);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientHelper.hpp b/src/cppcache/integration-test/ThinClientHelper.hpp
index 9b206d2..8d1a173 100644
--- a/src/cppcache/integration-test/ThinClientHelper.hpp
+++ b/src/cppcache/integration-test/ThinClientHelper.hpp
@@ -42,7 +42,6 @@
 #include "CacheHelper.hpp"
 
 using namespace apache::geode::client;
-using namespace test;
 using namespace unitTests;
 
 CacheHelper* cacheHelper = nullptr;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientListenerWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientListenerWriter.hpp b/src/cppcache/integration-test/ThinClientListenerWriter.hpp
index d037bf0..32c4578 100644
--- a/src/cppcache/integration-test/ThinClientListenerWriter.hpp
+++ b/src/cppcache/integration-test/ThinClientListenerWriter.hpp
@@ -31,8 +31,7 @@
 #define CLIENT3 s2p2
 
 class SimpleCacheListener;
-typedef apache::geode::client::SharedPtr<SimpleCacheListener>
-    SimpleCacheListenerPtr;
+typedef std::shared_ptr<SimpleCacheListener> SimpleCacheListenerPtr;
 
 // The SimpleCacheListener class.
 class SimpleCacheListener : public CacheListener {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp b/src/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
index adcba03..db18d3e 100644
--- a/src/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
+++ b/src/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
@@ -91,7 +91,7 @@ class SimpleCacheListener : public CacheListener {
     LOGINFO("SimpleCacheListener: Got a close event.");
   }
 };
-typedef SharedPtr<SimpleCacheListener> SimpleCacheListenerPtr;
+typedef std::shared_ptr<SimpleCacheListener> SimpleCacheListenerPtr;
 
 SimpleCacheListenerPtr eventListener1 = nullptr;
 SimpleCacheListenerPtr eventListener2 = nullptr;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/ThinClientTransactionsXA.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientTransactionsXA.hpp b/src/cppcache/integration-test/ThinClientTransactionsXA.hpp
index 00c259c..6dc3580 100644
--- a/src/cppcache/integration-test/ThinClientTransactionsXA.hpp
+++ b/src/cppcache/integration-test/ThinClientTransactionsXA.hpp
@@ -34,7 +34,6 @@
 #include "CacheHelper.hpp"
 
 using namespace apache::geode::client;
-using namespace test;
 
 #define CLIENT1 s1p1
 #define CLIENT2 s1p2

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/fw_dunit.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/fw_dunit.cpp b/src/cppcache/integration-test/fw_dunit.cpp
index 007cada..06851d0 100644
--- a/src/cppcache/integration-test/fw_dunit.cpp
+++ b/src/cppcache/integration-test/fw_dunit.cpp
@@ -837,13 +837,6 @@ void log(std::string s, int lineno, const char* filename) {
 void cleanup() { gClientCleanup.callClientCleanup(); }
 
 int dmain(int argc, ACE_TCHAR* argv[]) {
-#ifdef WIN32
-  char* envsetting = ACE_OS::getenv("BUG481");
-  if (envsetting != nullptr && strlen(envsetting) > 0) {
-    apache::geode::client::setNewAndDelete(&operator new, & operator delete);
-  }
-#endif
-
 #ifdef USE_SMARTHEAP
   MemRegisterTask();
 #endif
@@ -1199,9 +1192,4 @@ void Semaphore::release(int t) {
 
 namespace test {
 
-NOCout cout;
-NOCout::FLAGS endl = NOCout::endl;
-NOCout::FLAGS flush = NOCout::flush;
-NOCout::FLAGS hex = NOCout::hex;
-NOCout::FLAGS dec = NOCout::dec;
 }  // namespace test

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/fw_dunit.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/fw_dunit.hpp b/src/cppcache/integration-test/fw_dunit.hpp
index 624004f..f346c1d 100644
--- a/src/cppcache/integration-test/fw_dunit.hpp
+++ b/src/cppcache/integration-test/fw_dunit.hpp
@@ -361,6 +361,6 @@ int ACE_TMAIN(int argc, ACE_TCHAR* argv[]) { return dunit::dmain(argc, argv); }
 
 #include "fw_perf.hpp"
 
-#include "no_cout.hpp"
-
+namespace test {
+}  // namespace test
 #endif  // GEODE_INTEGRATION_TEST_FW_DUNIT_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/fw_helper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/fw_helper.hpp b/src/cppcache/integration-test/fw_helper.hpp
index 41829a7..5afc75c 100644
--- a/src/cppcache/integration-test/fw_helper.hpp
+++ b/src/cppcache/integration-test/fw_helper.hpp
@@ -216,8 +216,6 @@ int main(int argc, char* argv[])
 }
 }
 
-#include "no_cout.hpp"
-
 #define BEGIN_TEST(x)                      \
   class Test_##x : virtual public TestOp { \
    public:                                 \

http://git-wip-us.apache.org/repos/asf/geode-native/blob/b1a9af53/src/cppcache/integration-test/no_cout.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/no_cout.hpp b/src/cppcache/integration-test/no_cout.hpp
deleted file mode 100644
index fe191fe..0000000
--- a/src/cppcache/integration-test/no_cout.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#pragma once
-
-#ifndef GEODE_INTEGRATION_TEST_NO_COUT_H_
-#define GEODE_INTEGRATION_TEST_NO_COUT_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 <ace/OS.h>
-
-namespace test {
-
-class NOCout {
- private:
-  bool m_needHeading;
-
-  void heading() {
-    if (m_needHeading) {
-      fprintf(stdout, "[TEST %d] ", ACE_OS::getpid());
-      m_needHeading = false;
-    }
-  }
-
- public:
-  NOCout() : m_needHeading(true) {}
-
-  ~NOCout() {}
-
-  enum FLAGS { endl = 1, flush, hex, dec };
-
-  NOCout& operator<<(const char* msg) {
-    fprintf(stdout, "%s", msg);
-    return *this;
-  }
-
-  NOCout& operator<<(void* v) {
-    fprintf(stdout, "%p", v);
-    return *this;
-  }
-
-  NOCout& operator<<(int v) {
-    fprintf(stdout, "%d", v);
-    return *this;
-  }
-
-  NOCout& operator<<(std::string& str) {
-    fprintf(stdout, "%s", str.c_str());
-    return *this;
-  }
-
-  NOCout& operator<<(FLAGS& flag) {
-    if (flag == endl) {
-      fprintf(stdout, "\n");
-      m_needHeading = true;
-    } else if (flag == flush) {
-      fflush(stdout);
-    }
-    return *this;
-  }
-};
-
-extern NOCout cout;
-extern NOCout::FLAGS endl;
-extern NOCout::FLAGS flush;
-extern NOCout::FLAGS hex;
-extern NOCout::FLAGS dec;
-}  // namespace test
-
-#endif  // GEODE_INTEGRATION_TEST_NO_COUT_H_


Mime
View raw message