geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [3/8] geode-native git commit: GEODE-2439: Remove int type definitions
Date Fri, 24 Feb 2017 03:39:24 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxHelper.cpp b/src/cppcache/src/PdxHelper.cpp
index bcb3671..200fb69 100644
--- a/src/cppcache/src/PdxHelper.cpp
+++ b/src/cppcache/src/PdxHelper.cpp
@@ -59,7 +59,6 @@ CacheImpl* PdxHelper::getCacheImpl() {
 void PdxHelper::serializePdx(DataOutput& output,
                              const PdxSerializable& pdxObject) {
   const char* pdxClassname = NULL;
-  // bool isPdxWrapper = false;
 
   PdxSerializable& pdx = const_cast<PdxSerializable&>(pdxObject);
   PdxInstanceImpl* pdxII = dynamic_cast<PdxInstanceImpl*>(&pdx /*.ptr()*/);
@@ -183,9 +182,8 @@ void PdxHelper::serializePdx(DataOutput& output,
 
     nType->InitializeType();
 
-    // int32 nTypeId =(int32)
     // SerializationRegistry::GetPDXIdForType(output.getPoolName(), nType);
-    int32 nTypeId = PdxTypeRegistry::getPDXIdForType(
+    int32_t nTypeId = PdxTypeRegistry::getPDXIdForType(
         pdxType, output.getPoolName(), nType, true);
     nType->setTypeId(nTypeId);
 
@@ -243,9 +241,8 @@ void PdxHelper::serializePdx(DataOutput& output,
 
 PdxSerializablePtr PdxHelper::deserializePdx(DataInput& dataInput,
                                              bool forceDeserialize,
-                                             int32 typeId, int32 length) {
+                                             int32_t typeId, int32_t length) {
   char* pdxClassname = NULL;
-  // char* pdxDomainClassname = NULL;
   PdxSerializablePtr pdxObjectptr = NULLPTR;
   PdxTypePtr pdxLocalType = NULLPTR;
 
@@ -298,15 +295,6 @@ PdxSerializablePtr PdxHelper::deserializePdx(DataInput& dataInput,
     // pdxClassname = pType->getPdxClassName();
     pdxObjectptr = SerializationRegistry::getPdxType(pType->getPdxClassName());
     PdxSerializablePtr pdxRealObject = pdxObjectptr;
-    // bool isPdxWrapper = false;
-    /*
-    PdxWrapperPtr pdxWrapper = dynamic_cast<PdxWrapperPtr>(pdxObject);
-
-    if(pdxWrapper != nullptr)
-    {
-      isPdxWrapper = true;
-    }
-    else{}*/
     if (pdxLocalType == NULLPTR)  // need to know local type
     {
       PdxReaderWithTypeCollectorPtr prtc(
@@ -393,11 +381,10 @@ PdxSerializablePtr PdxHelper::deserializePdx(DataInput& dataInput,
       cacheImpl->m_cacheStats->incPdxDeSerialization(len +
                                                      9);  // pdxLen + 1 + 2*4
     }
-    return PdxHelper::deserializePdx(dataInput, forceDeserialize, (int32)typeId,
-                                     (int32)len);
+    return PdxHelper::deserializePdx(dataInput, forceDeserialize, (int32_t)typeId,
+                                     (int32_t)len);
 
   } else {
-    // PdxSerializablePtr pdxObject = NULLPTR;
     // Read Length
     int32_t len;
     dataInput.readInt(&len);
@@ -478,10 +465,6 @@ PdxSerializablePtr PdxHelper::deserializePdx(DataInput& dataInput,
 
     dataInput.advanceCursor(len);
 
-    // dataInput->AdvanceCursorPdx(len);
-    // dataInput->AdvanceUMCursor();
-    // dataInput->SetBuffer();
-
     CacheImpl* cacheImpl = PdxHelper::getCacheImpl();
     if (cacheImpl != NULL) {
       cacheImpl->m_cacheStats->incPdxInstanceCreations();
@@ -512,8 +495,8 @@ void PdxHelper::createMergedType(PdxTypePtr localType, PdxTypePtr remoteType,
   }
 }
 
-int32 PdxHelper::readInt32(uint8_t* offsetPosition) {
-  int32 data = offsetPosition[0];
+int32_t PdxHelper::readInt32(uint8_t* offsetPosition) {
+  int32_t data = offsetPosition[0];
   data = (data << 8) | offsetPosition[1];
   data = (data << 8) | offsetPosition[2];
   data = (data << 8) | offsetPosition[3];
@@ -521,40 +504,40 @@ int32 PdxHelper::readInt32(uint8_t* offsetPosition) {
   return data;
 }
 
-void PdxHelper::writeInt32(uint8_t* offsetPosition, int32 value) {
+void PdxHelper::writeInt32(uint8_t* offsetPosition, int32_t value) {
   offsetPosition[0] = static_cast<uint8_t>(value >> 24);
   offsetPosition[1] = static_cast<uint8_t>(value >> 16);
   offsetPosition[2] = static_cast<uint8_t>(value >> 8);
   offsetPosition[3] = static_cast<uint8_t>(value);
 }
 
-int32 PdxHelper::readInt16(uint8_t* offsetPosition) {
+int32_t PdxHelper::readInt16(uint8_t* offsetPosition) {
   int16_t data = offsetPosition[0];
   data = (data << 8) | offsetPosition[1];
-  return static_cast<int32>(data);
+  return static_cast<int32_t>(data);
 }
 
-int32 PdxHelper::readUInt16(uint8_t* offsetPosition) {
-  uint16 data = offsetPosition[0];
+int32_t PdxHelper::readUInt16(uint8_t* offsetPosition) {
+  uint16_t data = offsetPosition[0];
   data = (data << 8) | offsetPosition[1];
-  return static_cast<int32>(data);
+  return static_cast<int32_t>(data);
 }
 
-int32 PdxHelper::readByte(uint8_t* offsetPosition) {
-  return static_cast<int32>(offsetPosition[0]);
+int32_t PdxHelper::readByte(uint8_t* offsetPosition) {
+  return static_cast<int32_t>(offsetPosition[0]);
 }
 
-void PdxHelper::writeInt16(uint8_t* offsetPosition, int32 value) {
-  int16 val = static_cast<int16>(value);
+void PdxHelper::writeInt16(uint8_t* offsetPosition, int32_t value) {
+  int16_t val = static_cast<int16_t>(value);
   offsetPosition[0] = static_cast<uint8_t>(val >> 8);
   offsetPosition[1] = static_cast<uint8_t>(val);
 }
 
-void PdxHelper::writeByte(uint8_t* offsetPosition, int32 value) {
+void PdxHelper::writeByte(uint8_t* offsetPosition, int32_t value) {
   offsetPosition[0] = static_cast<uint8_t>(value);
 }
 
-int32 PdxHelper::readInt(uint8_t* offsetPosition, int size) {
+int32_t PdxHelper::readInt(uint8_t* offsetPosition, int size) {
   switch (size) {
     case 1:
       return readByte(offsetPosition);
@@ -566,7 +549,7 @@ int32 PdxHelper::readInt(uint8_t* offsetPosition, int size) {
   throw;
 }
 
-int32 PdxHelper::getEnumValue(const char* enumClassName, const char* enumName,
+int32_t PdxHelper::getEnumValue(const char* enumClassName, const char* enumName,
                               int hashcode) {
   EnumInfoPtr ei(new EnumInfo(enumClassName, enumName, hashcode));
   return PdxTypeRegistry::getEnumValue(ei);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxHelper.hpp b/src/cppcache/src/PdxHelper.hpp
index c87d876..9a84ef4 100644
--- a/src/cppcache/src/PdxHelper.hpp
+++ b/src/cppcache/src/PdxHelper.hpp
@@ -57,23 +57,23 @@ class PdxHelper {
                                            bool forceDeserialize,
                                            int32_t typeId, int32_t length);
 
-  static int32 readInt16(uint8_t* offsetPosition);
+  static int32_t readInt16(uint8_t* offsetPosition);
 
-  static int32 readUInt16(uint8_t* offsetPosition);
+  static int32_t readUInt16(uint8_t* offsetPosition);
 
-  static int32 readByte(uint8_t* offsetPosition);
+  static int32_t readByte(uint8_t* offsetPosition);
 
-  static int32 readInt32(uint8_t* offsetPosition);
+  static int32_t readInt32(uint8_t* offsetPosition);
 
-  static void writeInt32(uint8_t* offsetPosition, int32 value);
+  static void writeInt32(uint8_t* offsetPosition, int32_t value);
 
-  static void writeInt16(uint8_t* offsetPosition, int32 value);
+  static void writeInt16(uint8_t* offsetPosition, int32_t value);
 
-  static void writeByte(uint8_t* offsetPosition, int32 value);
+  static void writeByte(uint8_t* offsetPosition, int32_t value);
 
-  static int32 readInt(uint8_t* offsetPosition, int size);
+  static int32_t readInt(uint8_t* offsetPosition, int size);
 
-  static int32 getEnumValue(const char* enumClassName, const char* enumName,
+  static int32_t getEnumValue(const char* enumClassName, const char* enumName,
                             int hashcode);
 
   static EnumInfoPtr getEnum(int enumId);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxInstanceImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxInstanceImpl.cpp b/src/cppcache/src/PdxInstanceImpl.cpp
index ebafcda..b8ac1a0 100644
--- a/src/cppcache/src/PdxInstanceImpl.cpp
+++ b/src/cppcache/src/PdxInstanceImpl.cpp
@@ -1463,7 +1463,7 @@ CacheableStringPtr PdxInstanceImpl::toString() const {
 
 PdxSerializablePtr PdxInstanceImpl::getObject() {
   DataInput dataInput(m_buffer, m_bufferLength);
-  int64 sampleStartNanos = Utils::startStatOpTime();
+  int64_t sampleStartNanos = Utils::startStatOpTime();
   //[ToDo] do we have to call incPdxDeSerialization here?
   PdxSerializablePtr ret =
       PdxHelper::deserializePdx(dataInput, true, m_typeId, m_bufferLength);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxLocalReader.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxLocalReader.hpp b/src/cppcache/src/PdxLocalReader.hpp
index 9ce4d9a..8d9b86d 100644
--- a/src/cppcache/src/PdxLocalReader.hpp
+++ b/src/cppcache/src/PdxLocalReader.hpp
@@ -44,7 +44,7 @@ class PdxLocalReader : public PdxReader {
   PdxRemotePreservedDataPtr m_pdxRemotePreserveData;
   int32_t* m_localToRemoteMap;
   int32_t* m_remoteToLocalMap;
-  int32 m_remoteToLocalMapSize;
+  int32_t m_remoteToLocalMapSize;
 
   void initialize();
   void resettoPdxHead();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxLocalWriter.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxLocalWriter.cpp b/src/cppcache/src/PdxLocalWriter.cpp
index b6f75c0..7a865a4 100644
--- a/src/cppcache/src/PdxLocalWriter.cpp
+++ b/src/cppcache/src/PdxLocalWriter.cpp
@@ -133,8 +133,8 @@ void PdxLocalWriter::endObjectWriting() {
 }
 
 void PdxLocalWriter::writePdxHeader() {
-  int32 len = calculateLenWithOffsets();
-  int32 typeId = m_pdxType->getTypeId();
+  int32_t len = calculateLenWithOffsets();
+  int32_t typeId = m_pdxType->getTypeId();
 
   const uint8_t* starpos = m_dataOutput->getBuffer() + m_startPositionOffset;
   PdxHelper::writeInt32(const_cast<uint8_t*>(starpos), len);
@@ -143,7 +143,7 @@ void PdxLocalWriter::writePdxHeader() {
   writeOffsets(len);
 }
 
-void PdxLocalWriter::writeOffsets(int32 len) {
+void PdxLocalWriter::writeOffsets(int32_t len) {
   if (len <= 0xff) {
     for (int i = static_cast<int>(m_offsets.size()) - 1; i > 0; i--) {
       m_dataOutput->write(static_cast<uint8_t>(m_offsets[i]));
@@ -185,14 +185,14 @@ PdxWriterPtr PdxLocalWriter::writeUnreadFields(PdxUnreadFieldsPtr unread) {
   return PdxWriterPtr(this);
 }
 
-int32 PdxLocalWriter::calculateLenWithOffsets() {
+int32_t PdxLocalWriter::calculateLenWithOffsets() {
   int bufferLen = m_dataOutput->getBufferLength() - m_startPositionOffset;
-  int32 totalOffsets = 0;
+  int32_t totalOffsets = 0;
   if (m_pdxType->getNumberOfVarLenFields() > 0) {
     totalOffsets = m_pdxType->getNumberOfVarLenFields() -
                    1;  // for first var len no need to append offset
   }
-  int32 totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;
+  int32_t totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;
 
   if (totalLen <= 0xff) {  // 1 byte
     return totalLen;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxLocalWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxLocalWriter.hpp b/src/cppcache/src/PdxLocalWriter.hpp
index 22c4b14..705b169 100644
--- a/src/cppcache/src/PdxLocalWriter.hpp
+++ b/src/cppcache/src/PdxLocalWriter.hpp
@@ -36,10 +36,10 @@ class PdxLocalWriter : public PdxWriter {
   DataOutput* m_dataOutput;
   PdxTypePtr m_pdxType;
   const uint8_t* m_startPosition;
-  int32 m_startPositionOffset;
+  int32_t m_startPositionOffset;
   const char* m_domainClassName;
-  std::vector<int32> m_offsets;
-  int32 m_currentOffsetIndex;
+  std::vector<int32_t> m_offsets;
+  int32_t m_currentOffsetIndex;
 
   PdxRemotePreservedDataPtr m_preserveData;
   const char* m_pdxClassName;
@@ -66,9 +66,9 @@ class PdxLocalWriter : public PdxWriter {
 
   void writePdxHeader();
 
-  virtual void writeOffsets(int32 len);
+  virtual void writeOffsets(int32_t len);
 
-  virtual int32 calculateLenWithOffsets();
+  virtual int32_t calculateLenWithOffsets();
 
   virtual bool isFieldWritingStarted();
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxRemotePreservedData.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxRemotePreservedData.hpp b/src/cppcache/src/PdxRemotePreservedData.hpp
index 17591c3..152bf7a 100644
--- a/src/cppcache/src/PdxRemotePreservedData.hpp
+++ b/src/cppcache/src/PdxRemotePreservedData.hpp
@@ -32,9 +32,9 @@ typedef SharedPtr<PdxRemotePreservedData> PdxRemotePreservedDataPtr;
 class PdxRemotePreservedData : public PdxUnreadFields {
  private:
   std::vector<std::vector<int8_t> > m_preservedData;
-  int32 m_typeId;
-  int32 m_mergedTypeId;
-  int32 m_currentIndex;
+  int32_t m_typeId;
+  int32_t m_mergedTypeId;
+  int32_t m_currentIndex;
   SerializablePtr /*Object^*/ m_owner;
   long m_expiryTakId;
 
@@ -54,8 +54,8 @@ class PdxRemotePreservedData : public PdxUnreadFields {
 
     delete[] m_preservedData;*/
   }
-  PdxRemotePreservedData(int32 typeId, int32 mergedTypeId,
-                         int32 numberOfFields, /*Object^*/
+  PdxRemotePreservedData(int32_t typeId, int32_t mergedTypeId,
+                         int32_t numberOfFields, /*Object^*/
                          SerializablePtr owner) {
     m_typeId = typeId;
     m_mergedTypeId = mergedTypeId;
@@ -64,8 +64,8 @@ class PdxRemotePreservedData : public PdxUnreadFields {
     m_expiryTakId = 0;
   }
 
-  void initialize(int32 typeId, int32 mergedTypeId,
-                  int32 numberOfFields, /*Object^*/
+  void initialize(int32_t typeId, int32_t mergedTypeId,
+                  int32_t numberOfFields, /*Object^*/
                   SerializablePtr owner) {
     m_typeId = typeId;
     m_mergedTypeId = mergedTypeId;
@@ -74,7 +74,7 @@ class PdxRemotePreservedData : public PdxUnreadFields {
     m_expiryTakId = 0;
   }
 
-  inline int32 getMergedTypeId() { return m_mergedTypeId; }
+  inline int32_t getMergedTypeId() { return m_mergedTypeId; }
 
   inline void setPreservedDataExpiryTaskId(long expId) {
     m_expiryTakId = expId;
@@ -86,7 +86,7 @@ class PdxRemotePreservedData : public PdxUnreadFields {
 
   void setOwner(SerializablePtr val) { m_owner = val; }
 
-  inline std::vector<int8_t> getPreservedData(int32 idx) {
+  inline std::vector<int8_t> getPreservedData(int32_t idx) {
     return m_preservedData[idx];
   }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxRemoteWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxRemoteWriter.hpp b/src/cppcache/src/PdxRemoteWriter.hpp
index b3dd5bb..4b6d172 100644
--- a/src/cppcache/src/PdxRemoteWriter.hpp
+++ b/src/cppcache/src/PdxRemoteWriter.hpp
@@ -34,11 +34,11 @@ namespace client {
 
 class PdxRemoteWriter : public PdxLocalWriter {
  private:
-  int32* m_remoteTolocalMap;
-  int32 m_preserveDataIdx;
-  int32 m_currentDataIdx;
+  int32_t* m_remoteTolocalMap;
+  int32_t m_preserveDataIdx;
+  int32_t m_currentDataIdx;
 
-  int32 m_remoteTolocalMapLength;
+  int32_t m_remoteTolocalMapLength;
 
   void initialize();
   void writePreserveData();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxType.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxType.cpp b/src/cppcache/src/PdxType.cpp
index 5b39d36..3fd619a 100644
--- a/src/cppcache/src/PdxType.cpp
+++ b/src/cppcache/src/PdxType.cpp
@@ -167,7 +167,7 @@ Serializable* PdxType::fromData(DataInput& input) {
 
 void PdxType::addFixedLengthTypeField(const char* fieldName,
                                       const char* className, int8_t typeId,
-                                      int32 size) {
+                                      int32_t size) {
   if (fieldName == NULL /*|| *fieldName == '\0'*/ ||
       m_fieldNameVsPdxType.find(fieldName) !=
           m_fieldNameVsPdxType
@@ -191,7 +191,7 @@ void PdxType::addFixedLengthTypeField(const char* fieldName,
     throw IllegalStateException(excpStr);
   }
   PdxFieldTypePtr pfxPtr(new PdxFieldType(
-      fieldName, className, typeId, static_cast<int32>(m_pdxFieldTypes->size()),
+      fieldName, className, typeId, static_cast<int32_t>(m_pdxFieldTypes->size()),
       false, size, 0));
   m_pdxFieldTypes->push_back(pfxPtr);
   m_fieldNameVsPdxType[fieldName] = pfxPtr;
@@ -218,7 +218,7 @@ void PdxType::addVariableLengthTypeField(const char* fieldName,
   m_numberOfVarLenFields++;
   m_isVarLenFieldAdded = true;
   PdxFieldTypePtr pfxPtr(new PdxFieldType(
-      fieldName, className, typeId, static_cast<int32>(m_pdxFieldTypes->size()),
+      fieldName, className, typeId, static_cast<int32_t>(m_pdxFieldTypes->size()),
       true, -1, m_varLenFieldIdx));
   m_pdxFieldTypes->push_back(pfxPtr);
   m_fieldNameVsPdxType[fieldName] = pfxPtr;
@@ -247,7 +247,7 @@ void PdxType::initRemoteToLocal() {
   if (localPdxType != NULLPTR) {
     std::vector<PdxFieldTypePtr>* localPdxFields =
         localPdxType->getPdxFieldTypes();
-    int32 fieldIdx = 0;
+    int32_t fieldIdx = 0;
 
     m_remoteToLocalFieldMap = new int32_t[m_pdxFieldTypes->size()];
     LOGDEBUG(
@@ -310,7 +310,7 @@ void PdxType::initLocalToRemote() {
     int32_t fieldIdx = 0;
     // type which need to read/write should control local type
     int32_t localToRemoteFieldMapSize =
-        static_cast<int32>(localPdxType->m_pdxFieldTypes->size());
+        static_cast<int32_t>(localPdxType->m_pdxFieldTypes->size());
     m_localToRemoteFieldMap = new int32_t[localToRemoteFieldMapSize];
 
     for (int32_t i = 0; i < localToRemoteFieldMapSize &&
@@ -531,7 +531,7 @@ PdxTypePtr PdxType::mergeVersion(PdxTypePtr otherVersion) {
     if (!found) {
       PdxFieldTypePtr newFt(new PdxFieldType(
           (*it)->getFieldName(), (*it)->getClassName(), (*it)->getTypeId(),
-          static_cast<int32>(newone->m_pdxFieldTypes->size()),  // sequence id
+          static_cast<int32_t>(newone->m_pdxFieldTypes->size()),  // sequence id
           (*it)->IsVariableLengthType(), (*it)->getFixedSize(),
           ((*it)->IsVariableLengthType()
                ? varLenFields++ /*it increase after that*/
@@ -590,7 +590,7 @@ void PdxType::generatePositionMap() {
   foundVarLen = false;
   prevFixedSizeOffsets = 0;
   // now do optimization till you don't fine var len
-  for (uint32 i = 0; (i < m_pdxFieldTypes->size()) && !foundVarLen; i++) {
+  for (uint32_t i = 0; (i < m_pdxFieldTypes->size()) && !foundVarLen; i++) {
     PdxFieldTypePtr tmpft = m_pdxFieldTypes->at(i);
 
     if (tmpft->IsVariableLengthType()) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxType.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxType.hpp b/src/cppcache/src/PdxType.hpp
index c037fbe..157e01a 100644
--- a/src/cppcache/src/PdxType.hpp
+++ b/src/cppcache/src/PdxType.hpp
@@ -57,7 +57,6 @@ class PdxType : public Serializable,
                 private NonAssignable {
  private:
   ACE_RW_Thread_Mutex m_lockObj;
-  // SerializablePtr m_lockObj;
 
   static const char* m_javaPdxClass;
 
@@ -65,35 +64,24 @@ class PdxType : public Serializable,
 
   std::list<PdxTypePtr> m_otherVersions;
 
-  // TODO
-  // Serializable* m_pdxDomainType;
-
   char* m_className;
 
-  int32 m_geodeTypeId;
+  int32_t m_geodeTypeId;
 
   bool m_isLocal;
 
-  int32 m_numberOfVarLenFields;
+  int32_t m_numberOfVarLenFields;
 
-  int32 m_varLenFieldIdx;
+  int32_t m_varLenFieldIdx;
 
-  int32 m_numberOfFieldsExtra;
+  int32_t m_numberOfFieldsExtra;
 
   bool m_isVarLenFieldAdded;
 
-  // TODO:
   int32_t* m_remoteToLocalFieldMap;
 
-  // TODO:
   int32_t* m_localToRemoteFieldMap;
 
-  // TODO:
-  // int32 **m_positionMap;
-
-  // TODO:
-  // CacheableHashMapPtr m_fieldNameVsPdxType;
-
   NameVsPdxType m_fieldNameVsPdxType;
 
   bool m_noJavaClass;
@@ -111,12 +99,6 @@ class PdxType : public Serializable,
   PdxTypePtr clone();
   void generatePositionMap();
 
-  // first has more fields than second
-  /*PdxType isContains(PdxType &first, PdxType &second);
-  PdxType clone();
-
-  void generatePositionMap();
-  */
   PdxTypePtr isLocalTypeContains(PdxTypePtr otherType);
   PdxTypePtr isRemoteTypeContains(PdxTypePtr localType);
 
@@ -163,27 +145,27 @@ class PdxType : public Serializable,
     return size;
   }
 
-  virtual int32 getTypeId() const { return m_geodeTypeId; }
+  virtual int32_t getTypeId() const { return m_geodeTypeId; }
 
-  virtual void setTypeId(int32 typeId) { m_geodeTypeId = typeId; }
+  virtual void setTypeId(int32_t typeId) { m_geodeTypeId = typeId; }
 
-  int32 getNumberOfVarLenFields() const { return m_numberOfVarLenFields; }
+  int32_t getNumberOfVarLenFields() const { return m_numberOfVarLenFields; }
 
-  void setNumberOfVarLenFields(int32 value) { m_numberOfVarLenFields = value; }
+  void setNumberOfVarLenFields(int32_t value) { m_numberOfVarLenFields = value; }
 
-  int32 getTotalFields() const {
-    return static_cast<int32>(m_pdxFieldTypes->size());
+  int32_t getTotalFields() const {
+    return static_cast<int32_t>(m_pdxFieldTypes->size());
   }
 
   char* getPdxClassName() const { return m_className; }
 
   void setPdxClassName(char* className) { m_className = className; }
 
-  int32 getNumberOfExtraFields() const { return m_numberOfFieldsExtra; }
+  int32_t getNumberOfExtraFields() const { return m_numberOfFieldsExtra; }
 
-  void setVarLenFieldIdx(int32 value) { m_varLenFieldIdx = value; }
+  void setVarLenFieldIdx(int32_t value) { m_varLenFieldIdx = value; }
 
-  int32 getVarLenFieldIdx() const { return m_varLenFieldIdx; }
+  int32_t getVarLenFieldIdx() const { return m_varLenFieldIdx; }
 
   PdxFieldTypePtr getPdxField(const char* fieldName) {
     NameVsPdxType::iterator iter = m_fieldNameVsPdxType.find(fieldName);
@@ -202,7 +184,7 @@ class PdxType : public Serializable,
   }
 
   void addFixedLengthTypeField(const char* fieldName, const char* className,
-                               int8_t typeId, int32 size);
+                               int8_t typeId, int32_t size);
   void addVariableLengthTypeField(const char* fieldName, const char* className,
                                   int8_t typeId);
   void InitializeType();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxTypeRegistry.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxTypeRegistry.cpp b/src/cppcache/src/PdxTypeRegistry.cpp
index 2858040..d3d1fba 100644
--- a/src/cppcache/src/PdxTypeRegistry.cpp
+++ b/src/cppcache/src/PdxTypeRegistry.cpp
@@ -89,7 +89,7 @@ int PdxTypeRegistry::testGetNumberOfPdxIds() {
 
 int PdxTypeRegistry::testNumberOfPreservedData() { return preserveData.size(); }
 
-int32 PdxTypeRegistry::getPDXIdForType(const char* type, const char* poolname,
+int32_t PdxTypeRegistry::getPDXIdForType(const char* type, const char* poolname,
                                        PdxTypePtr nType, bool checkIfThere) {
   // WriteGuard guard(g_readerWriterLock);
   if (checkIfThere) {
@@ -109,7 +109,7 @@ int32 PdxTypeRegistry::getPDXIdForType(const char* type, const char* poolname,
   return typeId;
 }
 
-int32 PdxTypeRegistry::getPDXIdForType(PdxTypePtr nType, const char* poolname) {
+int32_t PdxTypeRegistry::getPDXIdForType(PdxTypePtr nType, const char* poolname) {
   PdxTypeToTypeIdMap* tmp = pdxTypeToTypeIdMap;
   int32_t typeId = 0;
   PdxTypeToTypeIdMap::iterator iter = tmp->find(nType);
@@ -159,13 +159,13 @@ void PdxTypeRegistry::clear() {
   }
 }
 
-void PdxTypeRegistry::addPdxType(int32 typeId, PdxTypePtr pdxType) {
+void PdxTypeRegistry::addPdxType(int32_t typeId, PdxTypePtr pdxType) {
   WriteGuard guard(g_readerWriterLock);
-  std::pair<int32, PdxTypePtr> pc(typeId, pdxType);
+  std::pair<int32_t, PdxTypePtr> pc(typeId, pdxType);
   typeIdToPdxType->insert(pc);
 }
 
-PdxTypePtr PdxTypeRegistry::getPdxType(int32 typeId) {
+PdxTypePtr PdxTypeRegistry::getPdxType(int32_t typeId) {
   ReadGuard guard(g_readerWriterLock);
   PdxTypePtr retValue = NULLPTR;
   TypeIdVsPdxType::iterator iter;
@@ -196,13 +196,13 @@ PdxTypePtr PdxTypeRegistry::getLocalPdxType(const char* localType) {
   return NULLPTR;
 }
 
-void PdxTypeRegistry::setMergedType(int32 remoteTypeId, PdxTypePtr mergedType) {
+void PdxTypeRegistry::setMergedType(int32_t remoteTypeId, PdxTypePtr mergedType) {
   WriteGuard guard(g_readerWriterLock);
-  std::pair<int32, PdxTypePtr> mergedTypePair(remoteTypeId, mergedType);
+  std::pair<int32_t, PdxTypePtr> mergedTypePair(remoteTypeId, mergedType);
   remoteTypeIdToMergedPdxType->insert(mergedTypePair);
 }
 
-PdxTypePtr PdxTypeRegistry::getMergedType(int32 remoteTypeId) {
+PdxTypePtr PdxTypeRegistry::getMergedType(int32_t remoteTypeId) {
   PdxTypePtr retVal = NULLPTR;
   TypeIdVsPdxType::iterator it;
   it = remoteTypeIdToMergedPdxType->find(remoteTypeId);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxTypeRegistry.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxTypeRegistry.hpp b/src/cppcache/src/PdxTypeRegistry.hpp
index fa483b7..173fe36 100644
--- a/src/cppcache/src/PdxTypeRegistry.hpp
+++ b/src/cppcache/src/PdxTypeRegistry.hpp
@@ -41,7 +41,7 @@ struct PdxTypeLessThan {
   }
 };
 
-typedef std::map<int32, PdxTypePtr> TypeIdVsPdxType;
+typedef std::map<int32_t, PdxTypePtr> TypeIdVsPdxType;
 typedef std::map</*char**/ std::string, PdxTypePtr> TypeNameVsPdxType;
 typedef HashMapT<PdxSerializablePtr, PdxRemotePreservedDataPtr>
     PreservedHashMap;
@@ -88,18 +88,18 @@ class CPPCACHE_EXPORT PdxTypeRegistry {
   // test hook
   static int testNumberOfPreservedData();
 
-  static void addPdxType(int32 typeId, PdxTypePtr pdxType);
+  static void addPdxType(int32_t typeId, PdxTypePtr pdxType);
 
-  static PdxTypePtr getPdxType(int32 typeId);
+  static PdxTypePtr getPdxType(int32_t typeId);
 
   static void addLocalPdxType(const char* localType, PdxTypePtr pdxType);
 
   // newly added
   static PdxTypePtr getLocalPdxType(const char* localType);
 
-  static void setMergedType(int32 remoteTypeId, PdxTypePtr mergedType);
+  static void setMergedType(int32_t remoteTypeId, PdxTypePtr mergedType);
 
-  static PdxTypePtr getMergedType(int32 remoteTypeId);
+  static PdxTypePtr getMergedType(int32_t remoteTypeId);
 
   static void setPreserveData(PdxSerializablePtr obj,
                               PdxRemotePreservedDataPtr preserveDataPtr);
@@ -108,7 +108,7 @@ class CPPCACHE_EXPORT PdxTypeRegistry {
 
   static void clear();
 
-  static int32 getPDXIdForType(const char* type, const char* poolname,
+  static int32_t getPDXIdForType(const char* type, const char* poolname,
                                PdxTypePtr nType, bool checkIfThere);
 
   static bool getPdxIgnoreUnreadFields() { return pdxIgnoreUnreadFields; }
@@ -127,7 +127,7 @@ class CPPCACHE_EXPORT PdxTypeRegistry {
 
   static EnumInfoPtr getEnum(int32_t enumVal);
 
-  static int32 getPDXIdForType(PdxTypePtr nType, const char* poolname);
+  static int32_t getPDXIdForType(PdxTypePtr nType, const char* poolname);
 
   static ACE_RW_Thread_Mutex& getPreservedDataLock() {
     return g_preservedDataLock;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxWriterWithTypeCollector.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxWriterWithTypeCollector.cpp b/src/cppcache/src/PdxWriterWithTypeCollector.cpp
index 29dceed..0b394e1 100644
--- a/src/cppcache/src/PdxWriterWithTypeCollector.cpp
+++ b/src/cppcache/src/PdxWriterWithTypeCollector.cpp
@@ -51,7 +51,7 @@ void PdxWriterWithTypeCollector::endObjectWriting() {
   PdxLocalWriter::writePdxHeader();
 }
 
-void PdxWriterWithTypeCollector::writeOffsets(int32 len) {
+void PdxWriterWithTypeCollector::writeOffsets(int32_t len) {
   if (len <= 0xff) {
     for (int i = static_cast<int>(m_offsets.size()) - 1; i > 0; i--) {
       m_dataOutput->write(static_cast<uint8_t>(m_offsets[i]));
@@ -67,14 +67,14 @@ void PdxWriterWithTypeCollector::writeOffsets(int32 len) {
   }
 }
 
-int32 PdxWriterWithTypeCollector::calculateLenWithOffsets() {
+int32_t PdxWriterWithTypeCollector::calculateLenWithOffsets() {
   int bufferLen = m_dataOutput->getBufferLength() - m_startPositionOffset;
-  int32 totalOffsets = 0;
+  int32_t totalOffsets = 0;
   if (m_offsets.size() > 0) {
-    totalOffsets = static_cast<int32>(m_offsets.size()) -
+    totalOffsets = static_cast<int32_t>(m_offsets.size()) -
                    1;  // for first var len no need to append offset
   }
-  int32 totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;
+  int32_t totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;
 
   if (totalLen <= 0xff) {
     return totalLen;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PdxWriterWithTypeCollector.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PdxWriterWithTypeCollector.hpp b/src/cppcache/src/PdxWriterWithTypeCollector.hpp
index e976119..a203f51 100644
--- a/src/cppcache/src/PdxWriterWithTypeCollector.hpp
+++ b/src/cppcache/src/PdxWriterWithTypeCollector.hpp
@@ -29,7 +29,7 @@ namespace client {
 
 class PdxWriterWithTypeCollector : public PdxLocalWriter {
  private:
-  std::vector<int32> m_offsets;
+  std::vector<int32_t> m_offsets;
   void initialize();
 
  public:
@@ -46,9 +46,9 @@ class PdxWriterWithTypeCollector : public PdxLocalWriter {
 
   virtual bool isFieldWritingStarted();
 
-  virtual int32 calculateLenWithOffsets();
+  virtual int32_t calculateLenWithOffsets();
 
-  virtual void writeOffsets(int32 len);
+  virtual void writeOffsets(int32_t len);
 
   /**
    *Write a 8-bit integer or byte to the PdxWriter.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/PoolStatistics.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PoolStatistics.hpp b/src/cppcache/src/PoolStatistics.hpp
index ba7202a..e107b44 100644
--- a/src/cppcache/src/PoolStatistics.hpp
+++ b/src/cppcache/src/PoolStatistics.hpp
@@ -45,11 +45,11 @@ class PoolStats {
     statistics::StatisticsManager::getExistingInstance()->forceSample();
   }
 
-  void setLocators(int32 curVal) { getStats()->setInt(m_locatorsId, curVal); }
+  void setLocators(int32_t curVal) { getStats()->setInt(m_locatorsId, curVal); }
 
-  void setServers(int32 curVal) { getStats()->setInt(m_serversId, curVal); }
+  void setServers(int32_t curVal) { getStats()->setInt(m_serversId, curVal); }
 
-  void setSubsServers(int32 curVal) {
+  void setSubsServers(int32_t curVal) {
     getStats()->setInt(m_subsServsId, curVal);
   }
 
@@ -57,7 +57,7 @@ class PoolStats {
 
   void incLoctorResposes() { getStats()->incLong(m_locRespsId, 1); }
 
-  void setCurPoolConnections(int32 curVal) {
+  void setCurPoolConnections(int32_t curVal) {
     getStats()->setInt(m_poolConnsId, curVal);
   }
 
@@ -79,13 +79,13 @@ class PoolStats {
     getStats()->incInt(m_loadCondDisconnectsId, 1);
   }
 
-  void setCurWaitingConnections(int32 curVal) {
+  void setCurWaitingConnections(int32_t curVal) {
     getStats()->setInt(m_waitingConnectionsId, curVal);
   }
 
   void incWaitingConnections() { getStats()->incInt(m_totalWaitingConnsId, 1); }
 
-  void setCurClientOps(int32 curVal) {
+  void setCurClientOps(int32_t curVal) {
     getStats()->setInt(m_curClientOpsId, curVal);
   }
 
@@ -95,7 +95,7 @@ class PoolStats {
 
   void incTimeoutClientOps() { getStats()->incInt(m_clientOpsTimeoutId, 1); }
 
-  void incReceivedBytes(int64 value) {  // counter
+  void incReceivedBytes(int64_t value) {  // counter
     getStats()->incLong(m_receivedBytesId, value);
   }
 
@@ -109,20 +109,20 @@ class PoolStats {
   void incDeltaMessageFailures() {  // counter
     getStats()->incLong(m_deltaMessageFailuresId, 1);
   }
-  void incProcessedDeltaMessagesTime(int64 value) {  // counter
+  void incProcessedDeltaMessagesTime(int64_t value) {  // counter
     getStats()->incLong(m_processedDeltaMessagesTimeId, value);
   }
 
-  void incTotalWaitingConnTime(int64 value) {  // counter
+  void incTotalWaitingConnTime(int64_t value) {  // counter
     getStats()->incLong(m_totalWaitingConnTimeId, value);
   }
-  void incClientOpsSuccessTime(int64 value) {  // counter
+  void incClientOpsSuccessTime(int64_t value) {  // counter
     getStats()->incLong(m_clientOpsSuccessTimeId, value);
   }
   void incQueryExecutionId() {  // counter
     getStats()->incInt(m_queryExecutionsId, 1);
   }
-  void incQueryExecutionTimeId(int64 value) {  // counter
+  void incQueryExecutionTimeId(int64_t value) {  // counter
     getStats()->incLong(m_queryExecutionTimeId, value);
   }
   inline apache::geode::statistics::Statistics* getStats() {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/RegionStats.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionStats.hpp b/src/cppcache/src/RegionStats.hpp
index 384b850..87ebe18 100644
--- a/src/cppcache/src/RegionStats.hpp
+++ b/src/cppcache/src/RegionStats.hpp
@@ -129,7 +129,7 @@ class CPPCACHE_EXPORT RegionStats {
 
 class RegionStatType {
  private:
-  static int8 instanceFlag;
+  static int8_t instanceFlag;
   static RegionStatType* single;
   static SpinLock m_singletonLock;
   static SpinLock m_statTypeLock;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/RemoteQuery.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RemoteQuery.cpp b/src/cppcache/src/RemoteQuery.cpp
index 5e4f4ad..cf617ce 100644
--- a/src/cppcache/src/RemoteQuery.cpp
+++ b/src/cppcache/src/RemoteQuery.cpp
@@ -70,7 +70,7 @@ SelectResultsPtr RemoteQuery::execute(uint32_t timeout, const char* func,
     pool->getStats().incQueryExecutionId();
   }
   /*get the start time for QueryExecutionTime stat*/
-  int64 sampleStartNanos = Utils::startStatOpTime();
+  int64_t sampleStartNanos = Utils::startStatOpTime();
   TcrMessageReply reply(true, tcdm);
   ChunkedQueryResponse* resultCollector = (new ChunkedQueryResponse(reply));
   reply.setChunkedResultHandler(

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcpConn.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcpConn.hpp b/src/cppcache/src/TcpConn.hpp
index 279b85a..436a6a4 100644
--- a/src/cppcache/src/TcpConn.hpp
+++ b/src/cppcache/src/TcpConn.hpp
@@ -135,7 +135,7 @@ class CPPCACHE_EXPORT TcpConn : public Connector {
     setOption(level, option, (void*)&val, sizeof(bool));
   }
 
-  virtual uint16 getPort();
+  virtual uint16_t getPort();
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcpSslConn.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcpSslConn.hpp b/src/cppcache/src/TcpSslConn.hpp
index 02e4a6d..5246ef9 100644
--- a/src/cppcache/src/TcpSslConn.hpp
+++ b/src/cppcache/src/TcpSslConn.hpp
@@ -82,7 +82,7 @@ class TcpSslConn : public TcpConn {
     }
   }
 
-  uint16 getPort();
+  uint16_t getPort();
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrConnection.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrConnection.cpp b/src/cppcache/src/TcrConnection.cpp
index f2838ad..874ba42 100644
--- a/src/cppcache/src/TcrConnection.cpp
+++ b/src/cppcache/src/TcrConnection.cpp
@@ -662,7 +662,7 @@ inline ConnErrType TcrConnection::receiveData(char* buffer, int32_t length,
              length, defaultWaitSecs);
     if (m_poolDM != NULL) {
       LOGDEBUG("TcrConnection::receiveData readBytes = %d", readBytes);
-      m_poolDM->getStats().incReceivedBytes(static_cast<int64>(readBytes));
+      m_poolDM->getStats().incReceivedBytes(static_cast<int64_t>(readBytes));
     }
     receiveTimeoutSec -= defaultWaitSecs;
     if ((length == startLen) && isNotificationMessage) {  // no data read
@@ -756,7 +756,7 @@ inline ConnErrType TcrConnection::sendData(uint32_t& timeSpent,
 
 char* TcrConnection::sendRequest(const char* buffer, int32_t len,
                                  size_t* recvLen, uint32_t sendTimeoutSec,
-                                 uint32_t receiveTimeoutSec, int32 request) {
+                                 uint32_t receiveTimeoutSec, int32_t request) {
   LOGDEBUG("TcrConnection::sendRequest");
   uint32_t timeSpent = 0;
 
@@ -899,7 +899,7 @@ char* TcrConnection::receive(size_t* recvLen, ConnErrType* opErr,
 char* TcrConnection::readMessage(size_t* recvLen, uint32_t receiveTimeoutSec,
                                  bool doHeaderTimeoutRetries,
                                  ConnErrType* opErr, bool isNotificationMessage,
-                                 int32 request) {
+                                 int32_t request) {
   char msg_header[HEADER_LENGTH];
   int32_t msgType, msgLen;
   ConnErrType error;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrConnection.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrConnection.hpp b/src/cppcache/src/TcrConnection.hpp
index 18cef17..5cd5aa5 100644
--- a/src/cppcache/src/TcrConnection.hpp
+++ b/src/cppcache/src/TcrConnection.hpp
@@ -159,7 +159,7 @@ class CPPCACHE_EXPORT TcrConnection {
   char* sendRequest(const char* buffer, int32_t len, size_t* recvLen,
                     uint32_t sendTimeoutSec = DEFAULT_WRITE_TIMEOUT,
                     uint32_t receiveTimeoutSec = DEFAULT_READ_TIMEOUT_SECS,
-                    int32 request = -1);
+                    int32_t request = -1);
 
   /**
   * send a synchronized request to server for REGISTER_INTEREST_LIST.
@@ -226,7 +226,7 @@ class CPPCACHE_EXPORT TcrConnection {
   */
   char* readMessage(size_t* recvLen, uint32_t receiveTimeoutSec,
                     bool doHeaderTimeoutRetries, ConnErrType* opErr,
-                    bool isNotificationMessage = false, int32 request = -1);
+                    bool isNotificationMessage = false, int32_t request = -1);
 
   /**
   * This method reads an interest list response  message from the socket
@@ -252,7 +252,7 @@ class CPPCACHE_EXPORT TcrConnection {
     return m_hasServerQueue;
   }
 
-  uint16 inline getPort() { return m_port; }
+  uint16_t inline getPort() { return m_port; }
 
   TcrEndpoint* getEndpointObject() const { return m_endpointObj; }
   bool isBeingUsed() { return m_isBeingUsed; }
@@ -389,7 +389,7 @@ class CPPCACHE_EXPORT TcrConnection {
   Connector* m_conn;
   ServerQueueStatus m_hasServerQueue;
   int32_t m_queueSize;
-  uint16 m_port;
+  uint16_t m_port;
 
   // semaphore to synchronize with the chunked response processing thread
   ACE_Semaphore m_chunksProcessSema;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrEndpoint.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrEndpoint.cpp b/src/cppcache/src/TcrEndpoint.cpp
index 9d7923a..cfe0900 100644
--- a/src/cppcache/src/TcrEndpoint.cpp
+++ b/src/cppcache/src/TcrEndpoint.cpp
@@ -615,7 +615,7 @@ int TcrEndpoint::receiveNotification(volatile bool& isRunning) {
         msg->setData(data, static_cast<int32_t>(dataLen),
                      this->getDistributedMemberID());
         data = NULL;  // memory is released by TcrMessage setData().
-        handleNotificationStats(static_cast<int64>(dataLen));
+        handleNotificationStats(static_cast<int64_t>(dataLen));
         LOGDEBUG("receive notification %d", msg->getMessageType());
 
         if (!isRunning) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrEndpoint.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrEndpoint.hpp b/src/cppcache/src/TcrEndpoint.hpp
index 6dd421f..77ab3ab 100644
--- a/src/cppcache/src/TcrEndpoint.hpp
+++ b/src/cppcache/src/TcrEndpoint.hpp
@@ -197,7 +197,7 @@ class CPPCACHE_EXPORT TcrEndpoint {
                                              TcrConnection* conn);
   virtual void closeFailedConnection(TcrConnection*& conn);
   void closeConnection(TcrConnection*& conn);
-  virtual void handleNotificationStats(int64 byteLength){};
+  virtual void handleNotificationStats(int64_t byteLength){};
   virtual void closeNotification();
   std::list<Task<TcrEndpoint>*> m_notifyReceiverList;
   std::list<TcrConnection*> m_notifyConnectionList;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrMessage.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrMessage.cpp b/src/cppcache/src/TcrMessage.cpp
index 52d8d96..b17c0bc 100644
--- a/src/cppcache/src/TcrMessage.cpp
+++ b/src/cppcache/src/TcrMessage.cpp
@@ -1079,7 +1079,7 @@ void TcrMessage::handleByteArrayResponse(const char* bytearray, int32_t len,
         input.read(&isHA);
         int8_t oFW;
         input.read(&oFW);
-        m_functionAttributes = new std::vector<int8>();
+        m_functionAttributes = new std::vector<int8_t>();
         m_functionAttributes->push_back(hR);
         m_functionAttributes->push_back(isHA);
         m_functionAttributes->push_back(oFW);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrMessage.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrMessage.hpp b/src/cppcache/src/TcrMessage.hpp
index 524612c..1e3cc8b 100644
--- a/src/cppcache/src/TcrMessage.hpp
+++ b/src/cppcache/src/TcrMessage.hpp
@@ -348,10 +348,10 @@ class CPPCACHE_EXPORT TcrMessage {
   uint32_t getMessageTypeForCq() const { return m_msgTypeForCq; }
   bool isInterestListPassed() const { return m_isInterestListPassed; }
   bool shouldIgnore() const { return m_shouldIgnore; }
-  int8 getMetaDataVersion() const { return m_metaDataVersion; }
+  int8_t getMetaDataVersion() const { return m_metaDataVersion; }
   uint32_t getEntryNotFound() const { return m_entryNotFound; }
-  int8 getserverGroupVersion() const { return m_serverGroupVersion; }
-  std::vector<int8>* getFunctionAttributes() { return m_functionAttributes; }
+  int8_t getserverGroupVersion() const { return m_serverGroupVersion; }
+  std::vector<int8_t>* getFunctionAttributes() { return m_functionAttributes; }
 
   // set the DM for chunked response messages
   void setDM(ThinClientBaseDM* dm) { m_tcdm = dm; }
@@ -609,8 +609,8 @@ class CPPCACHE_EXPORT TcrMessage {
   bool m_hasCqsPart;
   bool m_isInterestListPassed;
   bool m_shouldIgnore;
-  int8 m_metaDataVersion;
-  int8 m_serverGroupVersion;
+  int8_t m_metaDataVersion;
+  int8_t m_serverGroupVersion;
   std::vector<BucketServerLocationPtr> m_bucketServerLocations;
   std::vector<std::vector<BucketServerLocationPtr> >* m_metadata;
   int32_t m_bucketCount;
@@ -629,7 +629,7 @@ class CPPCACHE_EXPORT TcrMessage {
   BucketServerLocationPtr m_bucketServerLocation;
   uint32_t m_entryNotFound;
   std::vector<FixedPartitionAttributesImplPtr>* m_fpaSet;
-  std::vector<int8>* m_functionAttributes;
+  std::vector<int8_t>* m_functionAttributes;
   uint8_t m_hasResult;
   CacheableHashMapPtr m_tombstoneVersions;
   CacheableHashSetPtr m_tombstoneKeys;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrPoolEndPoint.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrPoolEndPoint.cpp b/src/cppcache/src/TcrPoolEndPoint.cpp
index f50b181..c88554d 100644
--- a/src/cppcache/src/TcrPoolEndPoint.cpp
+++ b/src/cppcache/src/TcrPoolEndPoint.cpp
@@ -141,7 +141,7 @@ bool TcrPoolEndPoint::handleIOException(const std::string& message,
   return TcrEndpoint::handleIOException(message, conn);
 }
 
-void TcrPoolEndPoint::handleNotificationStats(int64 byteLength) {
+void TcrPoolEndPoint::handleNotificationStats(int64_t byteLength) {
   m_dm->getStats().incReceivedBytes(byteLength);
   m_dm->getStats().incMessageBeingReceived();
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/TcrPoolEndPoint.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrPoolEndPoint.hpp b/src/cppcache/src/TcrPoolEndPoint.hpp
index 4dca475..66c26ae 100644
--- a/src/cppcache/src/TcrPoolEndPoint.hpp
+++ b/src/cppcache/src/TcrPoolEndPoint.hpp
@@ -49,7 +49,7 @@ class TcrPoolEndPoint : public TcrEndpoint {
   using TcrEndpoint::handleIOException;
   virtual bool handleIOException(const std::string& message,
                                  TcrConnection*& conn, bool isBgThread = false);
-  void handleNotificationStats(int64 byteLength);
+  void handleNotificationStats(int64_t byteLength);
   virtual ~TcrPoolEndPoint() { m_dm = NULL; }
   virtual bool isMultiUserMode();
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientHARegion.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientHARegion.cpp b/src/cppcache/src/ThinClientHARegion.cpp
index 9c02629..ae2fc2f 100644
--- a/src/cppcache/src/ThinClientHARegion.cpp
+++ b/src/cppcache/src/ThinClientHARegion.cpp
@@ -108,7 +108,7 @@ void ThinClientHARegion::handleMarker() {
 
   if (m_listener != NULLPTR && !m_processedMarker) {
     RegionEvent event(RegionPtr(this), NULLPTR, false);
-    int64 sampleStartNanos = Utils::startStatOpTime();
+    int64_t sampleStartNanos = Utils::startStatOpTime();
     try {
       m_listener->afterRegionLive(event);
     } catch (const Exception& ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientPoolDM.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientPoolDM.cpp b/src/cppcache/src/ThinClientPoolDM.cpp
index d85e240..f6fc356 100644
--- a/src/cppcache/src/ThinClientPoolDM.cpp
+++ b/src/cppcache/src/ThinClientPoolDM.cpp
@@ -1870,7 +1870,7 @@ TcrConnection* ThinClientPoolDM::getConnectionFromQueue(
   getStats().incWaitingConnections();
 
   /*get the start time for connectionWaitTime stat*/
-  int64 sampleStartNanos = Utils::startStatOpTime();
+  int64_t sampleStartNanos = Utils::startStatOpTime();
   TcrConnection* mp =
       getUntil(timeoutTime, error, excludeServers, maxConnLimit);
   /*Update the time stat for clientOpsTime */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientPoolDM.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientPoolDM.hpp b/src/cppcache/src/ThinClientPoolDM.hpp
index d94a99a..a4e1713 100644
--- a/src/cppcache/src/ThinClientPoolDM.hpp
+++ b/src/cppcache/src/ThinClientPoolDM.hpp
@@ -397,7 +397,7 @@ class ThinClientPoolDM
 
   volatile ThinClientLocatorHelper* m_locHelper;
 
-  volatile int32 m_poolSize;  // Actual Size of Pool
+  volatile int32_t m_poolSize;  // Actual Size of Pool
   int m_numRegions;
 
   // for selectEndpoint
@@ -419,7 +419,7 @@ class ThinClientPoolDM
   int manageConnectionsInternal(volatile bool& isRunning);
   void cleanStaleConnections(volatile bool& isRunning);
   void restoreMinConnections(volatile bool& isRunning);
-  volatile int32 m_clientOps;  // Actual Size of Pool
+  volatile int32_t m_clientOps;  // Actual Size of Pool
   statistics::PoolStatsSampler* m_PoolStatsSampler;
   ClientMetadataService* m_clientMetadataService;
   friend class CacheImpl;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientRedundancyManager.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientRedundancyManager.cpp b/src/cppcache/src/ThinClientRedundancyManager.cpp
index 7552757..4a025dd 100644
--- a/src/cppcache/src/ThinClientRedundancyManager.cpp
+++ b/src/cppcache/src/ThinClientRedundancyManager.cpp
@@ -448,7 +448,7 @@ GfErrType ThinClientRedundancyManager::maintainRedundancyLevel(
   // Update pool stats
   if (m_poolHADM) {
     m_poolHADM->getStats().setSubsServers(
-        static_cast<int32>(m_redundantEndpoints.size()));
+        static_cast<int32_t>(m_redundantEndpoints.size()));
   }
 
   if (isRedundancySatisfied) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientRegion.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientRegion.cpp b/src/cppcache/src/ThinClientRegion.cpp
index 3f977d2..387546c 100644
--- a/src/cppcache/src/ThinClientRegion.cpp
+++ b/src/cppcache/src/ThinClientRegion.cpp
@@ -3436,7 +3436,7 @@ bool ThinClientRegion::executeFunctionSH(
 }
 
 GfErrType ThinClientRegion::getFuncAttributes(const char* func,
-                                              std::vector<int8>** attr) {
+                                              std::vector<int8_t>** attr) {
   GfErrType err = GF_NOERR;
 
   // do TCR GET_FUNCTION_ATTRIBUTES
@@ -3503,7 +3503,7 @@ void ThinClientRegion::txPut(const CacheableKeyPtr& key,
                              const UserDataPtr& aCallbackArgument,
                              VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  int64 sampleStartNanos = Utils::startStatOpTime();
+  int64_t sampleStartNanos = Utils::startStatOpTime();
   GfErrType err = putNoThrowTX(key, value, aCallbackArgument, oldValue, -1,
                                CacheEventFlags::NORMAL, versionTag);
   Utils::updateStatOpTime(m_regionStats->getStat(),

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/ThinClientRegion.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ThinClientRegion.hpp b/src/cppcache/src/ThinClientRegion.hpp
index 101d5fb..7885b2e 100644
--- a/src/cppcache/src/ThinClientRegion.hpp
+++ b/src/cppcache/src/ThinClientRegion.hpp
@@ -149,7 +149,7 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
                        CacheableVectorPtr routingObj, uint8_t getResult,
                        ResultCollectorPtr rc, int32_t retryAttempts,
                        uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
-  GfErrType getFuncAttributes(const char* func, std::vector<int8>** attr);
+  GfErrType getFuncAttributes(const char* func, std::vector<int8_t>** attr);
 
   ACE_RW_Thread_Mutex& getMataDataMutex() { return m_RegionMutex; }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/Utils.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/Utils.hpp b/src/cppcache/src/Utils.hpp
index e0bf0fd..56520c3 100644
--- a/src/cppcache/src/Utils.hpp
+++ b/src/cppcache/src/Utils.hpp
@@ -148,7 +148,7 @@ class CPPCACHE_EXPORT Utils {
     }
   }
 
-  inline static int64 startStatOpTime() {
+  inline static int64_t startStatOpTime() {
     if (DistributedSystem::getSystemProperties() != NULL) {
       return (DistributedSystem::getSystemProperties()
                   ->getEnableTimeStatistics())
@@ -182,7 +182,7 @@ class CPPCACHE_EXPORT Utils {
   }
 
   inline static void updateStatOpTime(statistics::Statistics* m_regionStats,
-                                      int32 statId, int64 start) {
+                                      int32_t statId, int64_t start) {
     if (DistributedSystem::getSystemProperties() != NULL) {
       if (DistributedSystem::getSystemProperties()->getEnableTimeStatistics()) {
         m_regionStats->incLong(statId, startStatOpTime() - start);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/VersionedCacheableObjectPartList.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/VersionedCacheableObjectPartList.hpp b/src/cppcache/src/VersionedCacheableObjectPartList.hpp
index b1af78f..8db6010 100644
--- a/src/cppcache/src/VersionedCacheableObjectPartList.hpp
+++ b/src/cppcache/src/VersionedCacheableObjectPartList.hpp
@@ -66,7 +66,7 @@ class VersionedCacheableObjectPartList : public CacheableObjectPartList {
   bool m_hasTags;
   bool m_hasKeys;
   std::vector<VersionTagPtr> m_versionTags;
-  std::vector<uint8> m_byteArray;
+  std::vector<uint8_t> m_byteArray;
   uint16_t m_endpointMemId;
   VectorOfCacheableKeyPtr m_tempKeys;
   ACE_Recursive_Thread_Mutex& m_responseLock;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/hostsolaris.asm
----------------------------------------------------------------------
diff --git a/src/cppcache/src/hostsolaris.asm b/src/cppcache/src/hostsolaris.asm
index 7751205..03ae101 100644
--- a/src/cppcache/src/hostsolaris.asm
+++ b/src/cppcache/src/hostsolaris.asm
@@ -125,7 +125,7 @@ HostAsmUnlock:
  *
  * Name - HostAsmTryLock
  *
- * bool HostAsmTryLock(SpinLockField *lockPtr, int32 count, uint32 lockVal);
+ * bool HostAsmTryLock(SpinLockField *lockPtr, int32_t count, uint32_t lockVal);
  * Purpose -
  *      Try to get access to the specified lock.  If it succeeds in getting
  *      the lock in the number of tries specified in by count,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/AtomicStatisticsImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/AtomicStatisticsImpl.cpp b/src/cppcache/src/statistics/AtomicStatisticsImpl.cpp
index 949e178..adf982c 100644
--- a/src/cppcache/src/statistics/AtomicStatisticsImpl.cpp
+++ b/src/cppcache/src/statistics/AtomicStatisticsImpl.cpp
@@ -32,9 +32,9 @@ using namespace apache::geode::statistics;
  */
 //////////////////////  Static Methods  //////////////////////
 
-int64 AtomicStatisticsImpl::calcNumericId(StatisticsFactory* system,
-                                          int64 userValue) {
-  int64 result;
+int64_t AtomicStatisticsImpl::calcNumericId(StatisticsFactory* system,
+                                          int64_t userValue) {
+  int64_t result;
   if (userValue != 0) {
     result = userValue;
   } else {
@@ -75,8 +75,8 @@ const char* AtomicStatisticsImpl::calcTextId(StatisticsFactory* system,
  */
 AtomicStatisticsImpl::AtomicStatisticsImpl(StatisticsType* typeArg,
                                            const char* textIdArg,
-                                           int64 numericIdArg,
-                                           int64 uniqueIdArg,
+                                           int64_t numericIdArg,
+                                           int64_t uniqueIdArg,
                                            StatisticsFactory* system)
 
 {
@@ -89,14 +89,14 @@ AtomicStatisticsImpl::AtomicStatisticsImpl(StatisticsType* typeArg,
     this->closed = false;
     this->statsType = dynamic_cast<StatisticsTypeImpl*>(typeArg);
     GF_D_ASSERT(this->statsType != NULL);
-    int32 intCount = statsType->getIntStatCount();
-    int32 longCount = statsType->getLongStatCount();
-    int32 doubleCount = statsType->getDoubleStatCount();
+    int32_t intCount = statsType->getIntStatCount();
+    int32_t longCount = statsType->getLongStatCount();
+    int32_t doubleCount = statsType->getDoubleStatCount();
 
     if (intCount > 0) {
       intStorage =
-          new ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int32>[ intCount ];
-      for (int32 i = 0; i < intCount; i++) {
+          new ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int32_t>[ intCount ];
+      for (int32_t i = 0; i < intCount; i++) {
         intStorage[i] = 0;  // Un-initialized state
       }
 
@@ -105,8 +105,8 @@ AtomicStatisticsImpl::AtomicStatisticsImpl(StatisticsType* typeArg,
     }
     if (longCount > 0) {
       longStorage =
-          new ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int64>[ longCount ];
-      for (int32 i = 0; i < longCount; i++) {
+          new ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int64_t>[ longCount ];
+      for (int32_t i = 0; i < longCount; i++) {
         longStorage[i] = 0;  // Un-initialized state
       }
 
@@ -116,7 +116,7 @@ AtomicStatisticsImpl::AtomicStatisticsImpl(StatisticsType* typeArg,
     if (doubleCount > 0) {
       doubleStorage =
           new ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, double>[ doubleCount ];
-      for (int32 i = 0; i < doubleCount; i++) {
+      for (int32_t i = 0; i < doubleCount; i++) {
         doubleStorage[i] = 0;  // Un-initialized state
       }
     } else {
@@ -162,7 +162,7 @@ void AtomicStatisticsImpl::close() {
 
 ////////////////////////  store() Methods  ///////////////////////
 
-void AtomicStatisticsImpl::_setInt(int32 offset, int32 value) {
+void AtomicStatisticsImpl::_setInt(int32_t offset, int32_t value) {
   if (offset >= statsType->getIntStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -173,7 +173,7 @@ void AtomicStatisticsImpl::_setInt(int32 offset, int32 value) {
   intStorage[offset] = value;
 }
 
-void AtomicStatisticsImpl::_setLong(int32 offset, int64 value) {
+void AtomicStatisticsImpl::_setLong(int32_t offset, int64_t value) {
   if (offset >= statsType->getLongStatCount()) {
     char s[128] = {'\0'};
     /* adongre  - Coverity II
@@ -197,7 +197,7 @@ void AtomicStatisticsImpl::_setLong(int32 offset, int64 value) {
   longStorage[offset] = value;
 }
 
-void AtomicStatisticsImpl::_setDouble(int32 offset, double value) {
+void AtomicStatisticsImpl::_setDouble(int32_t offset, double value) {
   if (offset >= statsType->getDoubleStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -212,7 +212,7 @@ void AtomicStatisticsImpl::_setDouble(int32 offset, double value) {
 
 ///////////////////////  get() Methods  ///////////////////////
 
-int32 AtomicStatisticsImpl::_getInt(int32 offset) {
+int32_t AtomicStatisticsImpl::_getInt(int32_t offset) {
   if (offset >= statsType->getIntStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -224,7 +224,7 @@ int32 AtomicStatisticsImpl::_getInt(int32 offset) {
   return intStorage[offset].value();
 }
 
-int64 AtomicStatisticsImpl::_getLong(int32 offset) {
+int64_t AtomicStatisticsImpl::_getLong(int32_t offset) {
   if (offset >= statsType->getLongStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -235,7 +235,7 @@ int64 AtomicStatisticsImpl::_getLong(int32 offset) {
   return longStorage[offset].value();
 }
 
-double AtomicStatisticsImpl::_getDouble(int32 offset) {
+double AtomicStatisticsImpl::_getDouble(int32_t offset) {
   if (offset >= statsType->getDoubleStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -247,7 +247,7 @@ double AtomicStatisticsImpl::_getDouble(int32 offset) {
   return doubleStorage[offset].value();
 }
 
-int64 AtomicStatisticsImpl::_getRawBits(StatisticDescriptor* statDscp) {
+int64_t AtomicStatisticsImpl::_getRawBits(StatisticDescriptor* statDscp) {
   StatisticDescriptorImpl* stat =
       dynamic_cast<StatisticDescriptorImpl*>(statDscp);
   switch (stat->getTypeCode()) {
@@ -259,7 +259,7 @@ int64 AtomicStatisticsImpl::_getRawBits(StatisticDescriptor* statDscp) {
 
     case DOUBLE_TYPE: {
       double value = _getDouble(stat->getId());
-      int64* temp = reinterpret_cast<int64*>(&value);
+      int64_t* temp = reinterpret_cast<int64_t*>(&value);
       return *temp;
     }
     default:
@@ -269,11 +269,11 @@ int64 AtomicStatisticsImpl::_getRawBits(StatisticDescriptor* statDscp) {
   }
 }
 
-int64 AtomicStatisticsImpl::getRawBits(char* name) {
+int64_t AtomicStatisticsImpl::getRawBits(char* name) {
   return getRawBits(nameToDescriptor(name));
 }
 
-int64 AtomicStatisticsImpl::getRawBits(StatisticDescriptor* descriptor) {
+int64_t AtomicStatisticsImpl::getRawBits(StatisticDescriptor* descriptor) {
   if (isOpen()) {
     return _getRawBits(descriptor);
   } else {
@@ -283,7 +283,7 @@ int64 AtomicStatisticsImpl::getRawBits(StatisticDescriptor* descriptor) {
 
 ////////////////////////  inc() Methods  ////////////////////////
 
-int32 AtomicStatisticsImpl::_incInt(int32 offset, int32 delta) {
+int32_t AtomicStatisticsImpl::_incInt(int32_t offset, int32_t delta) {
   if (offset >= statsType->getIntStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -295,7 +295,7 @@ int32 AtomicStatisticsImpl::_incInt(int32 offset, int32 delta) {
   return (intStorage[offset] += delta);
 }
 
-int64 AtomicStatisticsImpl::_incLong(int32 offset, int64 delta) {
+int64_t AtomicStatisticsImpl::_incLong(int32_t offset, int64_t delta) {
   if (offset >= statsType->getLongStatCount()) {
     char s[128] = {'\0'};
     /* adongre  - Coverity II
@@ -320,7 +320,7 @@ int64 AtomicStatisticsImpl::_incLong(int32 offset, int64 delta) {
   return (longStorage[offset] += delta);
 }
 
-double AtomicStatisticsImpl::_incDouble(int32 offset, double delta) {
+double AtomicStatisticsImpl::_incDouble(int32_t offset, double delta) {
   if (offset >= statsType->getDoubleStatCount()) {
     char s[128] = {'\0'};
     ACE_OS::snprintf(
@@ -337,7 +337,7 @@ double AtomicStatisticsImpl::_incDouble(int32 offset, double delta) {
 
 //////////////////////  Instance Methods  //////////////////////
 
-int32 AtomicStatisticsImpl::nameToId(const char* name) {
+int32_t AtomicStatisticsImpl::nameToId(const char* name) {
   return statsType->nameToId(name);
 }
 
@@ -355,43 +355,43 @@ StatisticsType* AtomicStatisticsImpl::getType() { return statsType; }
 
 const char* AtomicStatisticsImpl::getTextId() { return textIdStr.c_str(); }
 
-int64 AtomicStatisticsImpl::getNumericId() { return numericId; }
+int64_t AtomicStatisticsImpl::getNumericId() { return numericId; }
 
 /**
  * Gets the unique id for this resource
  */
-int64 AtomicStatisticsImpl::getUniqueId() { return uniqueId; }
+int64_t AtomicStatisticsImpl::getUniqueId() { return uniqueId; }
 
 ////////////////////////  set() Methods  ///////////////////////
 
-void AtomicStatisticsImpl::setInt(char* name, int32 value) {
-  int32 id = getIntId(nameToDescriptor(name));
+void AtomicStatisticsImpl::setInt(char* name, int32_t value) {
+  int32_t id = getIntId(nameToDescriptor(name));
   setInt(id, value);
 }
 
 void AtomicStatisticsImpl::setInt(StatisticDescriptor* descriptor,
-                                  int32 value) {
-  int32 id = getIntId(descriptor);
+                                  int32_t value) {
+  int32_t id = getIntId(descriptor);
   setInt(id, value);
 }
 
-void AtomicStatisticsImpl::setInt(int32 id, int32 value) {
+void AtomicStatisticsImpl::setInt(int32_t id, int32_t value) {
   if (isOpen()) {
     _setInt(id, value);
   }
 }
 ////////////////////////////////LONG METHODS/////////////////////////////
 
-void AtomicStatisticsImpl::setLong(char* name, int64 value) {
+void AtomicStatisticsImpl::setLong(char* name, int64_t value) {
   setLong(nameToDescriptor(name), value);
 }
 
 void AtomicStatisticsImpl::setLong(StatisticDescriptor* descriptor,
-                                   int64 value) {
+                                   int64_t value) {
   setLong(getLongId(descriptor), value);
 }
 
-void AtomicStatisticsImpl::setLong(int32 id, int64 value) {
+void AtomicStatisticsImpl::setLong(int32_t id, int64_t value) {
   if (isOpen()) {
     _setLong(id, value);
   }
@@ -407,23 +407,23 @@ void AtomicStatisticsImpl::setDouble(StatisticDescriptor* descriptor,
   setDouble(getDoubleId(descriptor), value);
 }
 
-void AtomicStatisticsImpl::setDouble(int32 id, double value) {
+void AtomicStatisticsImpl::setDouble(int32_t id, double value) {
   if (isOpen()) {
     _setDouble(id, value);
   }
 }
 
-int32 AtomicStatisticsImpl::getInt(char* name) {
-  int32 id = getIntId(nameToDescriptor(name));
+int32_t AtomicStatisticsImpl::getInt(char* name) {
+  int32_t id = getIntId(nameToDescriptor(name));
   return getInt(id);
 }
 
-int32 AtomicStatisticsImpl::getInt(StatisticDescriptor* descriptor) {
-  int32 id = getIntId(descriptor);
+int32_t AtomicStatisticsImpl::getInt(StatisticDescriptor* descriptor) {
+  int32_t id = getIntId(descriptor);
   return getInt(id);
 }
 
-int32 AtomicStatisticsImpl::getInt(int32 id) {
+int32_t AtomicStatisticsImpl::getInt(int32_t id) {
   if (isOpen()) {
     return _getInt(id);
   } else {
@@ -431,15 +431,15 @@ int32 AtomicStatisticsImpl::getInt(int32 id) {
   }
 }
 
-int64 AtomicStatisticsImpl::getLong(char* name) {
+int64_t AtomicStatisticsImpl::getLong(char* name) {
   return getLong(nameToDescriptor(name));
 }
 
-int64 AtomicStatisticsImpl::getLong(StatisticDescriptor* descriptor) {
+int64_t AtomicStatisticsImpl::getLong(StatisticDescriptor* descriptor) {
   return getLong(getLongId(descriptor));
 }
 
-int64 AtomicStatisticsImpl::getLong(int32 id) {
+int64_t AtomicStatisticsImpl::getLong(int32_t id) {
   if (isOpen()) {
     return _getLong(id);
   } else {
@@ -455,7 +455,7 @@ double AtomicStatisticsImpl::getDouble(StatisticDescriptor* descriptor) {
   return getDouble(getDoubleId(descriptor));
 }
 
-double AtomicStatisticsImpl::getDouble(int32 id) {
+double AtomicStatisticsImpl::getDouble(int32_t id) {
   if (isOpen()) {
     return _getDouble(id);
   } else {
@@ -464,20 +464,20 @@ double AtomicStatisticsImpl::getDouble(int32 id) {
 }
 
 /*
- *Increment the value of the int32 decriptor by delta
+ *Increment the value of the int32_t decriptor by delta
  */
-int32 AtomicStatisticsImpl::incInt(char* name, int32 delta) {
-  int32 id = getIntId(nameToDescriptor(name));
+int32_t AtomicStatisticsImpl::incInt(char* name, int32_t delta) {
+  int32_t id = getIntId(nameToDescriptor(name));
   return incInt(id, delta);
 }
 
-int32 AtomicStatisticsImpl::incInt(StatisticDescriptor* descriptor,
-                                   int32 delta) {
-  int32 id = getIntId(descriptor);
+int32_t AtomicStatisticsImpl::incInt(StatisticDescriptor* descriptor,
+                                   int32_t delta) {
+  int32_t id = getIntId(descriptor);
   return incInt(id, delta);
 }
 
-int32 AtomicStatisticsImpl::incInt(int32 id, int32 delta) {
+int32_t AtomicStatisticsImpl::incInt(int32_t id, int32_t delta) {
   if (isOpen()) {
     return _incInt(id, delta);
   } else {
@@ -486,19 +486,19 @@ int32 AtomicStatisticsImpl::incInt(int32 id, int32 delta) {
 }
 
 /*
- *Increment the value of the int64 decriptor by delta
+ *Increment the value of the int64_t decriptor by delta
  */
 
-int64 AtomicStatisticsImpl::incLong(char* name, int64 delta) {
+int64_t AtomicStatisticsImpl::incLong(char* name, int64_t delta) {
   return incLong(nameToDescriptor(name), delta);
 }
 
-int64 AtomicStatisticsImpl::incLong(StatisticDescriptor* descriptor,
-                                    int64 delta) {
+int64_t AtomicStatisticsImpl::incLong(StatisticDescriptor* descriptor,
+                                    int64_t delta) {
   return incLong(getLongId(descriptor), delta);
 }
 
-int64 AtomicStatisticsImpl::incLong(int32 id, int64 delta) {
+int64_t AtomicStatisticsImpl::incLong(int32_t id, int64_t delta) {
   if (isOpen()) {
     return _incLong(id, delta);
   } else {
@@ -519,7 +519,7 @@ double AtomicStatisticsImpl::incDouble(StatisticDescriptor* descriptor,
   return incDouble(getDoubleId(descriptor), delta);
 }
 
-double AtomicStatisticsImpl::incDouble(int32 id, double delta) {
+double AtomicStatisticsImpl::incDouble(int32_t id, double delta) {
   if (isOpen()) {
     return _incDouble(id, delta);
   } else {
@@ -527,19 +527,19 @@ double AtomicStatisticsImpl::incDouble(int32 id, double delta) {
   }
 }
 
-int32 AtomicStatisticsImpl::getIntId(StatisticDescriptor* descriptor) {
+int32_t AtomicStatisticsImpl::getIntId(StatisticDescriptor* descriptor) {
   StatisticDescriptorImpl* realDescriptor =
       dynamic_cast<StatisticDescriptorImpl*>(descriptor);
   return realDescriptor->checkInt();
 }
 
-int32 AtomicStatisticsImpl::getLongId(StatisticDescriptor* descriptor) {
+int32_t AtomicStatisticsImpl::getLongId(StatisticDescriptor* descriptor) {
   StatisticDescriptorImpl* realDescriptor =
       dynamic_cast<StatisticDescriptorImpl*>(descriptor);
   return realDescriptor->checkLong();
 }
 
-int32 AtomicStatisticsImpl::getDoubleId(StatisticDescriptor* descriptor) {
+int32_t AtomicStatisticsImpl::getDoubleId(StatisticDescriptor* descriptor) {
   StatisticDescriptorImpl* realDescriptor =
       dynamic_cast<StatisticDescriptorImpl*>(descriptor);
   return realDescriptor->checkDouble();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/AtomicStatisticsImpl.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/AtomicStatisticsImpl.hpp b/src/cppcache/src/statistics/AtomicStatisticsImpl.hpp
index 06c9c98..6ea6fbd 100644
--- a/src/cppcache/src/statistics/AtomicStatisticsImpl.hpp
+++ b/src/cppcache/src/statistics/AtomicStatisticsImpl.hpp
@@ -72,20 +72,20 @@ class AtomicStatisticsImpl : public Statistics, private NonCopyable {
   std::string textIdStr;
 
   /** Numeric information display with these statistics */
-  int64 numericId;
+  int64_t numericId;
 
   /** Are these statistics closed? */
   bool closed;
 
   /** Uniquely identifies this instance */
-  int64 uniqueId;
+  int64_t uniqueId;
 
   /****************************************************************************/
-  /** An array containing the values of the int32 statistics */
-  ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int32>* intStorage;
+  /** An array containing the values of the int32_t statistics */
+  ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int32_t>* intStorage;
 
-  /** An array containing the values of the int64 statistics */
-  ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int64>* longStorage;
+  /** An array containing the values of the int64_t statistics */
+  ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, int64_t>* longStorage;
 
   /** An array containing the values of the double statistics */
   ACE_Atomic_Op<ACE_Recursive_Thread_Mutex, double>* doubleStorage;
@@ -93,15 +93,15 @@ class AtomicStatisticsImpl : public Statistics, private NonCopyable {
   ///////////////////////Private Methods//////////////////////////
   bool isOpen();
 
-  int32 getIntId(StatisticDescriptor* descriptor);
+  int32_t getIntId(StatisticDescriptor* descriptor);
 
-  int32 getLongId(StatisticDescriptor* descriptor);
+  int32_t getLongId(StatisticDescriptor* descriptor);
 
-  int32 getDoubleId(StatisticDescriptor* descriptor);
+  int32_t getDoubleId(StatisticDescriptor* descriptor);
 
   //////////////////////  Static private Methods  //////////////////////
 
-  int64 calcNumericId(StatisticsFactory* system, int64 userValue);
+  int64_t calcNumericId(StatisticsFactory* system, int64_t userValue);
 
   const char* calcTextId(StatisticsFactory* system, const char* userValue);
 
@@ -125,7 +125,7 @@ class AtomicStatisticsImpl : public Statistics, private NonCopyable {
 
  public:
   AtomicStatisticsImpl(StatisticsType* type, const char* textId,
-                       int64 numericId, int64 uniqueId,
+                       int64_t numericId, int64_t uniqueId,
                        StatisticsFactory* system);
 
   //////////////////////  Instance Methods  //////////////////////
@@ -133,7 +133,7 @@ class AtomicStatisticsImpl : public Statistics, private NonCopyable {
 
   bool usesSystemCalls();
 
-  int32 nameToId(const char* name);
+  int32_t nameToId(const char* name);
 
   StatisticDescriptor* nameToDescriptor(const char* name);
 
@@ -150,98 +150,98 @@ class AtomicStatisticsImpl : public Statistics, private NonCopyable {
 
   const char* getTextId();
 
-  int64 getNumericId();
+  int64_t getNumericId();
 
-  int64 getUniqueId();
+  int64_t getUniqueId();
 
   ////////////////////////  set() Methods  ///////////////////////
 
-  void setInt(char* name, int32 value);
+  void setInt(char* name, int32_t value);
 
-  void setInt(StatisticDescriptor* descriptor, int32 value);
+  void setInt(StatisticDescriptor* descriptor, int32_t value);
 
-  void setInt(int32 offset, int32 value);
+  void setInt(int32_t offset, int32_t value);
 
-  void setLong(char* name, int64 value);
+  void setLong(char* name, int64_t value);
 
-  void setLong(StatisticDescriptor* descriptor, int64 value);
+  void setLong(StatisticDescriptor* descriptor, int64_t value);
 
-  void setLong(int32 id, int64 value);
+  void setLong(int32_t id, int64_t value);
 
   void setDouble(char* name, double value);
 
   void setDouble(StatisticDescriptor* descriptor, double value);
 
-  void setDouble(int32 id, double value);
+  void setDouble(int32_t id, double value);
 
   ///////////////////////  get() Methods  ///////////////////////
 
-  int32 getInt(char* name);
+  int32_t getInt(char* name);
 
-  int32 getInt(StatisticDescriptor* descriptor);
+  int32_t getInt(StatisticDescriptor* descriptor);
 
-  int32 getInt(int32 offset);
+  int32_t getInt(int32_t offset);
 
-  int64 getLong(char* name);
+  int64_t getLong(char* name);
 
-  int64 getLong(StatisticDescriptor* descriptor);
+  int64_t getLong(StatisticDescriptor* descriptor);
 
-  int64 getLong(int32 id);
+  int64_t getLong(int32_t id);
 
   double getDouble(char* name);
 
   double getDouble(StatisticDescriptor* descriptor);
 
-  double getDouble(int32 id);
+  double getDouble(int32_t id);
 
-  int64 getRawBits(StatisticDescriptor* descriptor);
+  int64_t getRawBits(StatisticDescriptor* descriptor);
 
-  int64 getRawBits(char* name);
+  int64_t getRawBits(char* name);
 
   ////////////////////////  inc() Methods  ////////////////////////
 
-  int32 incInt(char* name, int32 delta);
+  int32_t incInt(char* name, int32_t delta);
 
-  int32 incInt(StatisticDescriptor* descriptor, int32 delta);
+  int32_t incInt(StatisticDescriptor* descriptor, int32_t delta);
 
-  int32 incInt(int32 offset, int32 delta);
+  int32_t incInt(int32_t offset, int32_t delta);
 
-  int64 incLong(char* name, int64 delta);
+  int64_t incLong(char* name, int64_t delta);
 
-  int64 incLong(StatisticDescriptor* descriptor, int64 delta);
+  int64_t incLong(StatisticDescriptor* descriptor, int64_t delta);
 
-  int64 incLong(int32 id, int64 delta);
+  int64_t incLong(int32_t id, int64_t delta);
 
   double incDouble(char* name, double delta);
 
   double incDouble(StatisticDescriptor* descriptor, double delta);
 
-  double incDouble(int32 id, double delta);
+  double incDouble(int32_t id, double delta);
 
  protected:
-  void _setInt(int32 offset, int32 value);
+  void _setInt(int32_t offset, int32_t value);
 
-  void _setLong(int32 offset, int64 value);
+  void _setLong(int32_t offset, int64_t value);
 
-  void _setDouble(int32 offset, double value);
+  void _setDouble(int32_t offset, double value);
 
-  int32 _getInt(int32 offset);
+  int32_t _getInt(int32_t offset);
 
-  int64 _getLong(int32 offset);
+  int64_t _getLong(int32_t offset);
 
-  double _getDouble(int32 offset);
+  double _getDouble(int32_t offset);
 
   /**
    * Returns the bits that represent the raw value of the
    * specified statistic descriptor.
    */
-  int64 _getRawBits(StatisticDescriptor* stat);
+  int64_t _getRawBits(StatisticDescriptor* stat);
 
-  int32 _incInt(int32 offset, int32 delta);
+  int32_t _incInt(int32_t offset, int32_t delta);
 
-  int64 _incLong(int32 offset, int64 delta);
+  int64_t _incLong(int32_t offset, int64_t delta);
 
-  double _incDouble(int32 offset, double delta);
+  double _incDouble(int32_t offset, double delta);
 
 };  // class
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/GeodeStatisticsFactory.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/GeodeStatisticsFactory.cpp b/src/cppcache/src/statistics/GeodeStatisticsFactory.cpp
index 251873e..3f3c2bf 100644
--- a/src/cppcache/src/statistics/GeodeStatisticsFactory.cpp
+++ b/src/cppcache/src/statistics/GeodeStatisticsFactory.cpp
@@ -103,7 +103,7 @@ GeodeStatisticsFactory::~GeodeStatisticsFactory() {
 
 const char* GeodeStatisticsFactory::getName() { return m_name; }
 
-int64 GeodeStatisticsFactory::getId() { return m_id; }
+int64_t GeodeStatisticsFactory::getId() { return m_id; }
 
 Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type) {
   return createAtomicStatistics(type, NULL, 0);
@@ -116,19 +116,19 @@ Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type,
 
 Statistics* GeodeStatisticsFactory::createStatistics(StatisticsType* type,
                                                      const char* textId,
-                                                     int64 numericId) {
+                                                     int64_t numericId) {
   return createAtomicStatistics(type, textId, 0);
 }
 
 Statistics* GeodeStatisticsFactory::createOsStatistics(StatisticsType* type,
                                                        const char* textId,
-                                                       int64 numericId) {
+                                                       int64_t numericId) {
   // Validate input
   if (type == NULL) {
     throw IllegalArgumentException("StatisticsType* is Null");
   }
 
-  int64 myUniqueId;
+  int64_t myUniqueId;
   {
     ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_statsListUniqueIdLock);
     myUniqueId = m_statsListUniqueId++;
@@ -153,12 +153,12 @@ Statistics* GeodeStatisticsFactory::createAtomicStatistics(StatisticsType* type,
 
 Statistics* GeodeStatisticsFactory::createAtomicStatistics(StatisticsType* type,
                                                            const char* textId,
-                                                           int64 numericId) {
+                                                           int64_t numericId) {
   // Validate input
   if (type == NULL) {
     throw IllegalArgumentException("StatisticsType* is Null");
   }
-  int64 myUniqueId;
+  int64_t myUniqueId;
 
   {
     ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_statsListUniqueIdLock);
@@ -205,7 +205,7 @@ StatisticsTypeImpl* GeodeStatisticsFactory::addType(StatisticsTypeImpl* st) {
 StatisticsType* GeodeStatisticsFactory::createType(const char* name,
                                                    const char* description,
                                                    StatisticDescriptor** stats,
-                                                   int32 statsLength) {
+                                                   int32_t statsLength) {
   StatisticsTypeImpl* st =
       new StatisticsTypeImpl(name, description, stats, statsLength);
 
@@ -235,42 +235,42 @@ StatisticsType* GeodeStatisticsFactory::findType(const char* name) {
 
 StatisticDescriptor* GeodeStatisticsFactory::createIntCounter(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createIntCounter(name, description, units,
                                                    largerBetter);
 }
 
 StatisticDescriptor* GeodeStatisticsFactory::createLongCounter(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createLongCounter(name, description, units,
                                                     largerBetter);
 }
 
 StatisticDescriptor* GeodeStatisticsFactory::createDoubleCounter(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createDoubleCounter(name, description, units,
                                                       largerBetter);
 }
 
 StatisticDescriptor* GeodeStatisticsFactory::createIntGauge(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createIntGauge(name, description, units,
                                                  largerBetter);
 }
 
 StatisticDescriptor* GeodeStatisticsFactory::createLongGauge(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createLongGauge(name, description, units,
                                                   largerBetter);
 }
 
 StatisticDescriptor* GeodeStatisticsFactory::createDoubleGauge(
     const char* name, const char* description, const char* units,
-    int8 largerBetter) {
+    bool largerBetter) {
   return StatisticDescriptorImpl::createDoubleGauge(name, description, units,
                                                     largerBetter);
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/GeodeStatisticsFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/GeodeStatisticsFactory.hpp b/src/cppcache/src/statistics/GeodeStatisticsFactory.hpp
index fc0e198..49ab21a 100644
--- a/src/cppcache/src/statistics/GeodeStatisticsFactory.hpp
+++ b/src/cppcache/src/statistics/GeodeStatisticsFactory.hpp
@@ -55,7 +55,7 @@ class GeodeStatisticsFactory : public StatisticsFactory {
 
   const char* m_name;
 
-  int64 m_id;
+  int64_t m_id;
 
   StatisticsManager* m_statMngr;
 
@@ -65,7 +65,7 @@ class GeodeStatisticsFactory : public StatisticsFactory {
 
   GeodeStatisticsFactory(StatisticsManager* statMngr);
 
-  int64 m_statsListUniqueId;  // Creates a unique id for each stats object in
+  int64_t m_statsListUniqueId;  // Creates a unique id for each stats object in
                               // the list
 
   ACE_Recursive_Thread_Mutex m_statsListUniqueIdLock;
@@ -85,7 +85,7 @@ class GeodeStatisticsFactory : public StatisticsFactory {
 
   const char* getName();
 
-  int64 getId();
+  int64_t getId();
 
   static GeodeStatisticsFactory* initInstance(StatisticsManager* statMngr);
 
@@ -98,22 +98,22 @@ class GeodeStatisticsFactory : public StatisticsFactory {
   Statistics* createStatistics(StatisticsType* type, const char* textId);
 
   Statistics* createStatistics(StatisticsType* type, const char* textId,
-                               int64 numericId);
+                               int64_t numericId);
 
   Statistics* createOsStatistics(StatisticsType* type, const char* textId,
-                                 int64 numericId);
+                                 int64_t numericId);
 
   Statistics* createAtomicStatistics(StatisticsType* type);
 
   Statistics* createAtomicStatistics(StatisticsType* type, const char* textId);
 
   Statistics* createAtomicStatistics(StatisticsType* type, const char* textId,
-                                     int64 numericId);
+                                     int64_t numericId);
 
   //------------ StatisticsFactory methods: Statistics Type
   //------------------------------
   StatisticsType* createType(const char* name, const char* description,
-                             StatisticDescriptor** stats, int32 statsLength);
+                             StatisticDescriptor** stats, int32_t statsLength);
 
   StatisticsType* findType(const char* name);
 
@@ -121,27 +121,27 @@ class GeodeStatisticsFactory : public StatisticsFactory {
   //---------------------
   StatisticDescriptor* createIntCounter(const char* name,
                                         const char* description,
-                                        const char* units, int8 largerBetter);
+                                        const char* units, bool largerBetter);
 
   StatisticDescriptor* createLongCounter(const char* name,
                                          const char* description,
-                                         const char* units, int8 largerBetter);
+                                         const char* units, bool largerBetter);
 
   StatisticDescriptor* createDoubleCounter(const char* name,
                                            const char* description,
                                            const char* units,
-                                           int8 largerBetter);
+                                           bool largerBetter);
 
   StatisticDescriptor* createIntGauge(const char* name, const char* description,
-                                      const char* units, int8 largerBetter);
+                                      const char* units, bool largerBetter);
 
   StatisticDescriptor* createLongGauge(const char* name,
                                        const char* description,
-                                       const char* units, int8 largerBetter);
+                                       const char* units, bool largerBetter);
 
   StatisticDescriptor* createDoubleGauge(const char* name,
                                          const char* description,
-                                         const char* units, int8 largerBetter);
+                                         const char* units, bool largerBetter);
 
   /** Return the first instance that matches the type, or NULL */
   Statistics* findFirstStatisticsByType(StatisticsType* type);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/HostStatHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/HostStatHelper.cpp b/src/cppcache/src/statistics/HostStatHelper.cpp
index 015ea59..ff5437c 100644
--- a/src/cppcache/src/statistics/HostStatHelper.cpp
+++ b/src/cppcache/src/statistics/HostStatHelper.cpp
@@ -29,8 +29,8 @@ using namespace apache::geode::statistics;
  *
  */
 
-int32 HostStatHelper::PROCESS_STAT_FLAG = 1;
-int32 HostStatHelper::SYSTEM_STAT_FLAG = 2;
+int32_t HostStatHelper::PROCESS_STAT_FLAG = 1;
+int32_t HostStatHelper::SYSTEM_STAT_FLAG = 2;
 GFS_OSTYPES HostStatHelper::osCode =
     static_cast<GFS_OSTYPES>(0);  // Default OS is Linux
 ProcessStats* HostStatHelper::processStats = NULL;
@@ -83,7 +83,7 @@ void HostStatHelper::refresh() {
  * Creates and returns a {@link Statistics} with
  * the given pid and name.
  */
-void HostStatHelper::newProcessStats(int64 pid, const char* name) {
+void HostStatHelper::newProcessStats(int64_t pid, const char* name) {
   // Init OsCode
   initOSCode();
 
@@ -127,20 +127,20 @@ void HostStatHelper::cleanup() {
   }
 }
 
-int32 HostStatHelper::getCpuUsage() {
+int32_t HostStatHelper::getCpuUsage() {
   if (HostStatHelper::processStats != NULL) {
     return HostStatHelper::processStats->getCpuUsage();
   }
   return 0;
 }
 
-int64 HostStatHelper::getCpuTime() {
+int64_t HostStatHelper::getCpuTime() {
   if (HostStatHelper::processStats != NULL) {
     return HostStatHelper::processStats->getAllCpuTime();
   }
   return 0;
 }
-int32 HostStatHelper::getNumThreads() {
+int32_t HostStatHelper::getNumThreads() {
   if (HostStatHelper::processStats != NULL) {
     return HostStatHelper::processStats->getNumThreads();
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fd204478/src/cppcache/src/statistics/HostStatHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/statistics/HostStatHelper.hpp b/src/cppcache/src/statistics/HostStatHelper.hpp
index 6c5a2aa..eb63531 100644
--- a/src/cppcache/src/statistics/HostStatHelper.hpp
+++ b/src/cppcache/src/statistics/HostStatHelper.hpp
@@ -54,9 +54,9 @@ namespace statistics {
 
 class CPPCACHE_EXPORT HostStatHelper {
  private:
-  static int32 PROCESS_STAT_FLAG;
+  static int32_t PROCESS_STAT_FLAG;
 
-  static int32 SYSTEM_STAT_FLAG;
+  static int32_t SYSTEM_STAT_FLAG;
 
   static GFS_OSTYPES osCode;
 
@@ -65,14 +65,14 @@ class CPPCACHE_EXPORT HostStatHelper {
   static void initOSCode();
 
  public:
-  static int32 getCpuUsage();
-  static int64 getCpuTime();
+  static int32_t getCpuUsage();
+  static int64_t getCpuTime();
 
-  static int32 getNumThreads();
+  static int32_t getNumThreads();
 
   static void refresh();
 
-  static void newProcessStats(int64 pid, const char* name);
+  static void newProcessStats(int64_t pid, const char* name);
 
   static void close();
 


Mime
View raw message