Backport fixes

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "googletest"]
+	path = hazelcast/test/googletest
+	url = git@github.com:ihsandemir/googletest.git
+	branch = hazelcasttest

CMakeLists.txt

@@ -21,15 +21,14 @@ project (HazelcastClient)
 #  -DHZ_BIT=[32 | 64]
 #  -DHZ_CODE_COVERAGE=ON
 #  -DHZ_VALGRIND=ON
-#  -DHZ_ADDRESS_SANITIZER=ON
 
 INCLUDE(TestBigEndian)
 
 SET(HZ_VERSION 3.6.1-SNAPSHOT)
 
 message(STATUS "Preparing hazelcast client ..... ")
 
-include_directories( ${CMAKE_SOURCE_DIR}/external/include/)
+include_directories(${CMAKE_SOURCE_DIR}/external/include/)
 
 #detect endianness
 TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
@@ -51,13 +50,6 @@ IF(NOT (${HZ_BIT} MATCHES "32") AND NOT (${HZ_BIT} MATCHES "64") )
   set(HZ_BIT 64)
 ENDIF(NOT (${HZ_BIT} MATCHES "32") AND NOT (${HZ_BIT} MATCHES "64"))
 
-SET(HZ_BIT_FLAG " ")
-IF(${HZ_BIT} MATCHES "32") 
-  SET(HZ_BIT_FLAG " -m32 ")
-ENDIF(${HZ_BIT} MATCHES "32")
-
-message(STATUS "${HZ_BIT} Bit")
-
 IF(NOT (${HZ_LIB_TYPE} MATCHES "STATIC") AND NOT (${HZ_LIB_TYPE} MATCHES "SHARED") )
 	message( STATUS "Build needs HZ_LIB_TYPE. Setting default as -DHZ_LIB_TYPE=STATIC (other option -DHZ_LIB_TYPE=SHARED)" )
 	set(HZ_LIB_TYPE STATIC)
@@ -86,22 +78,35 @@ IF(${HZ_VALGRIND} MATCHES "ON")
 	set(HZ_VALGRIND_LINK_FLAGS " -O0 ") 
 ENDIF(${HZ_VALGRIND} MATCHES "ON")
 
+set(HZ_C11_FLAGS "")
+IF(${HZ_USE_C11} MATCHES "ON")
+	set(HZ_C11_FLAGS "-std=c++11")
+	message(STATUS "C++11 compiler is turned on.")
+ENDIF(${HZ_USE_C11} MATCHES "ON")
+
 message(STATUS "${CMAKE_SYSTEM}")
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	message(STATUS "APPLE ENVIRONMENT DETECTED")
 
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -Werror")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall")
+	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -Werror ${HZ_C11_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall ${HZ_C11_FLAGS}")
 
 	link_libraries(${HZ_LIB_NAME} )
 
 ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 	message(STATUS "LINUX ENVIRONMENT DETECTED")
-
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -Werror ${HZ_BIT_FLAG} ${HZ_CODE_COVERAGE_COMPILE_FLAGS} ${HZ_VALGRIND_COMPILE_FLAGS}")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall ${HZ_BIT_FLAG} ${HZ_CODE_COVERAGE_COMPILE_FLAGS} ${HZ_VALGRIND_COMPILE_FLAGS}")
+
+	SET(HZ_BIT_FLAG " ")
+	IF(${HZ_BIT} MATCHES "32")
+		SET(HZ_BIT_FLAG " -m32 ")
+	ENDIF(${HZ_BIT} MATCHES "32")
+
+	message(STATUS "${HZ_BIT} Bit")
+
+	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -Werror ${HZ_BIT_FLAG} ${HZ_CODE_COVERAGE_COMPILE_FLAGS} ${HZ_VALGRIND_COMPILE_FLAGS} ${HZ_C11_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall ${HZ_BIT_FLAG} ${HZ_CODE_COVERAGE_COMPILE_FLAGS} ${HZ_VALGRIND_COMPILE_FLAGS} ${HZ_C11_FLAGS}")
 
 	link_libraries(${HZ_LIB_NAME} pthread rt )
 
@@ -117,12 +122,18 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		add_definitions(-DHAZELCAST_EXPORTS=0)
 	ENDIF(${HZ_LIB_TYPE} MATCHES "SHARED")
 
-	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MP /EHsc")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MP /EHsc")
+	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MP /EHsc ${HZ_C11_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MP /EHsc ${HZ_C11_FLAGS}")
 
 	link_libraries(${HZ_LIB_NAME})
-
 ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 
-ADD_SUBDIRECTORY(hazelcast/test)
-ADD_SUBDIRECTORY(examples)
+IF(${HZ_BUILD_TESTS} MATCHES "ON")
+	SET(BUILD_GTEST "ON")
+	SET(DBUILD_GMOCK "OFF")
+	ADD_SUBDIRECTORY(hazelcast/test)
+ENDIF(${HZ_BUILD_TESTS} MATCHES "ON")
+
+IF(${HZ_BUILD_EXAMPLES} MATCHES "ON")
+	ADD_SUBDIRECTORY(examples)
+ENDIF(${HZ_BUILD_EXAMPLES} MATCHES "ON")

README.md

@@ -21,6 +21,14 @@ API Documentation can be generated via doxygen from root with following command
 doxygen docsConfig
 ```
 
+## How to download
+
+Clone the project from github:
+
+git clone --recursive git@github.com:hazelcast/hazelcast-cpp-client.git
+
+We use --recursive flag for our dependency on googletest framework.
+
 ## How to build
 
 First create a build directory from the root of the project and in the directory run the following commands depending on your environment.
@@ -40,9 +48,6 @@ First create a build directory from the root of the project and in the directory
   	cmake .. -G Xcode -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug
 
 	cmake .. -G Xcode -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY=archive -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=library
-### For Linux Address Sanitizer
-
-        cmake .. -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug -DHZ_ADDRESS_SANITIZER=ON
 
 ### valgrind sample run with suppresions
 
@@ -56,6 +61,16 @@ First create a build directory from the root of the project and in the directory
 	cmake .. -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Release
 	cmake .. -DHZ_LIB_TYPE=SHARED -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Release
 
+### For building the tests
+
+    Add the -DHZ_BUILD_TESTS=ON flag to the cmake flags. e.g.:
+    cmake .. -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug -DHZ_BUILD_TESTS=ON
+
+### For building the examples
+
+    Add the -DHZ_BUILD_EXAMPLES=ON flag to the cmake flags. e.g.:
+    cmake .. -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug -DHZ_BUILD_EXAMPLES=ON
+
 ### For linux valgrind
 
 	cmake .. -DHZ_LIB_TYPE=STATIC -DHZ_BIT=64 -DCMAKE_BUILD_TYPE=Debug -DHZ_VALGRIND=ON

examples/CMakeLists.txt

@@ -1,4 +1,4 @@
-#
+#
 # Copyright (c) 2008-2015, Hazelcast, Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,129 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+cmake_minimum_required (VERSION 3.1)
+project (HazelcastExamples)
+
+INCLUDE(TestBigEndian)
+
+# if HAZELCAST_INSTALL_DIR option is provided, the examples shall compile with the released library
+if (NOT("${HAZELCAST_INSTALL_DIR}x" STREQUAL "x"))
+    message (STATUS "Using hazelcast installation at ${HAZELCAST_INSTALL_DIR}.")
+
+    if(NOT("${HZ_VERSION}x" MATCHES "x"))
+        message(FATAL_ERROR "Release verification require that this folder is NOT included from a parent CMakeLists.txt.")
+    endif (NOT("${HZ_VERSION}x" MATCHES "x"))
+
+    if ("${HZ_BIT}x" STREQUAL "x")
+        message(FATAL_ERROR "You have to specify HZ_BIT variable!")
+    endif()
+
+    IF(NOT (${HZ_LIB_TYPE} MATCHES "STATIC") AND NOT (${HZ_LIB_TYPE} MATCHES "SHARED") )
+        message( STATUS "Build needs HZ_LIB_TYPE. Setting default as -DHZ_LIB_TYPE=STATIC (other option -DHZ_LIB_TYPE=SHARED)" )
+        set(HZ_LIB_TYPE STATIC)
+    ENDIF(NOT (${HZ_LIB_TYPE} MATCHES "STATIC") AND NOT (${HZ_LIB_TYPE} MATCHES "SHARED") )
+
+    SET(HZ_VERSION 3.7-SNAPSHOT)
+
+    IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+        SET(HAZELCAST_PLATFORM_INSTALL_DIR ${HAZELCAST_INSTALL_DIR}\\${CMAKE_SYSTEM_NAME}_${HZ_BIT})
+    ELSE()
+        SET(HAZELCAST_PLATFORM_INSTALL_DIR ${HAZELCAST_INSTALL_DIR}/${CMAKE_SYSTEM_NAME}_${HZ_BIT})
+    ENDIF()
+
+    message(STATUS "Shall try building the examples with installed Hazelcast client at ${HAZELCAST_PLATFORM_INSTALL_DIR}")
+    message(STATUS "Include directories: ${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/include ${HAZELCAST_PLATFORM_INSTALL_DIR}/external/include")
+    message(STATUS "Link directory: ${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/lib")
+
+    #detect endianness
+    TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
+    if (${IS_BIG_ENDIAN})
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DHZ_BIG_ENDIAN")
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DHZ_BIG_ENDIAN")
+    ENDIF (${IS_BIG_ENDIAN})
+
+    include_directories(${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/include ${HAZELCAST_PLATFORM_INSTALL_DIR}/external/include)
+
+    SET(HZ_LIB_NAME HazelcastClient${HZ_VERSION}_${HZ_BIT})
+
+    ADD_LIBRARY(${HZ_LIB_NAME} ${HZ_LIB_TYPE} IMPORTED)
+
+    message(STATUS "${CMAKE_SYSTEM}")
+
+    IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+        message(STATUS "APPLE ENVIRONMENT DETECTED")
+
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall")
+
+        set(HZ_LIB_PATH "")
+        IF (${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/lib/lib${HZ_LIB_NAME}.a")
+        ELSE(${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/lib/lib${HZ_LIB_NAME}.dylib")
+        ENDIF(${HZ_LIB_TYPE} MATCHES "STATIC")
+
+        message(STATUS "Using ${HZ_LIB_TYPE} library at ${HZ_LIB_PATH}")
+
+        set_property(TARGET ${HZ_LIB_NAME} PROPERTY IMPORTED_LOCATION "${HZ_LIB_PATH}")
+
+        link_libraries(${HZ_LIB_NAME} )
+
+    ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+
+    IF( ${CMAKE_SYSTEM_NAME} MATCHES "Linux" )
+        message(STATUS "LINUX ENVIRONMENT DETECTED")
+
+        SET(HZ_BIT_FLAG " ")
+        IF(${HZ_BIT} MATCHES "32")
+            SET(HZ_BIT_FLAG " -m32 ")
+        ENDIF(${HZ_BIT} MATCHES "32")
+
+        message(STATUS "${HZ_BIT} Bit")
+
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall ${HZ_BIT_FLAG}")
+
+        set(HZ_LIB_PATH "")
+        IF (${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/lib/lib${HZ_LIB_NAME}.a")
+        ELSE(${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}/hazelcast/lib/lib${HZ_LIB_NAME}.so")
+        ENDIF(${HZ_LIB_TYPE} MATCHES "STATIC")
+
+        message(STATUS "Using ${HZ_LIB_TYPE} library at ${HZ_LIB_PATH}")
+
+        set_property(TARGET ${HZ_LIB_NAME} PROPERTY IMPORTED_LOCATION "${HZ_LIB_PATH}")
+
+        link_libraries(${HZ_LIB_NAME} pthread rt )
+    ENDIF( ${CMAKE_SYSTEM_NAME} MATCHES "Linux" )
+
+    IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+        message(STATUS "WINDOWS ENVIRONMENT DETECTED ${CMAKE_GENERATOR} ${CMAKE_BUILD_TYPE} ")
+
+        add_definitions(-D__WIN${HZ_BIT}__ -DWIN${HZ_BIT} -D_WIN${HZ_BIT})
+
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /EHsc")
+
+        add_definitions(-DHAZELCAST_EXPORTS=0)
+
+        IF (${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}\\hazelcast\\lib\\static\\${HZ_LIB_NAME}.lib")
+            set_property(TARGET ${HZ_LIB_NAME} PROPERTY IMPORTED_LOCATION ${HZ_LIB_PATH})
+
+            message(STATUS "Using ${HZ_LIB_TYPE} library at ${HZ_LIB_PATH}")
+        ELSE(${HZ_LIB_TYPE} MATCHES "STATIC")
+            set(HZ_LIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}\\hazelcast\\lib\\shared\\${HZ_LIB_NAME}.dll")
+            set(HZ_LIB_IMPLIB_PATH "${HAZELCAST_PLATFORM_INSTALL_DIR}\\hazelcast\\lib\\shared\\${HZ_LIB_NAME}.lib")
+
+            set_property(TARGET ${HZ_LIB_NAME} PROPERTY IMPORTED_LOCATION ${HZ_LIB_PATH})
+            set_property(TARGET ${HZ_LIB_NAME} PROPERTY IMPORTED_IMPLIB ${HZ_LIB_IMPLIB_PATH})
+
+            message(STATUS "Using ${HZ_LIB_TYPE} library at ${HZ_LIB_PATH}")
+        ENDIF(${HZ_LIB_TYPE} MATCHES "STATIC")
+
+        link_libraries(${HZ_LIB_NAME})
+    ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+endif (NOT("${HAZELCAST_INSTALL_DIR}x" STREQUAL "x"))
+
 add_subdirectory(CommandLineTool)
 add_subdirectory(transactions)
 add_subdirectory(spi)
@@ -29,3 +152,4 @@ add_subdirectory(distributed-collections)
 
 
 
+

examples/distributed-map/locking/PessimisticUpdate.cpp

@@ -76,7 +76,7 @@ int main() {
             map.unlock(key);
         } catch (hazelcast::client::exception::IException &e) {
             map.unlock(key);
-            throw;
+            throw e;
         }
     }
     std::cout << "Finished! Result = " << map.get(key)->amount << std::endl;

examples/distributed-primitives/lock/RaceFree.cpp

@@ -49,7 +49,7 @@ int main() {
             }
         } catch (hazelcast::client::exception::IException &e) {
             lock.unlock();
-            throw;
+            throw e;
         }
 
         if (k % 2 == 0) {

examples/distributed-primitives/semaphore/Semaphore.cpp

@@ -35,7 +35,7 @@ int main() {
             resource.decrementAndGet();
         } catch (hazelcast::client::exception::IException &e) {
             semaphore.release();
-            throw;
+            throw e;
         }
     }
 

examples/serialization/custom/main.cpp

@@ -35,15 +35,13 @@ class Person {
         return name;
     }
 
-    int getTypeId() const{
-        return 666;
-    }
-
 private:
     std::string name;
 };
 
-
+int getHazelcastTypeId(const Person* p){
+    return 666;
+}
 
 class CustomSerializer : public hazelcast::client::serialization::Serializer<Person> {
 public:
@@ -62,7 +60,7 @@ class CustomSerializer : public hazelcast::client::serialization::Serializer<Per
         assert(i == 666);
     }
 
-    int getTypeId() const {
+    int getHazelcastTypeId() const {
         return 666;
     };
 };

hazelcast/include/hazelcast/client/exception/IException.h

@@ -28,6 +28,7 @@
 #if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
 #pragma warning(push)
 #pragma warning(disable: 4251) //for dll export	
+#pragma warning(disable: 4275) //for dll export	
 #endif 
 
 namespace hazelcast {

hazelcast/include/hazelcast/client/serialization/IdentifiedDataSerializable.h

@@ -44,7 +44,9 @@ namespace hazelcast {
                 /**
                  * Destructor
                  */
-                virtual ~IdentifiedDataSerializable();
+                virtual ~IdentifiedDataSerializable(){
+
+                }
 
                 /**
                  * @return factory id
@@ -68,12 +70,6 @@ namespace hazelcast {
                  */
                 virtual void readData(ObjectDataInput &reader) = 0;
 
-                /**
-                 * Not public api. Do not override this method.
-                 * @return type id
-                 */
-                virtual int getTypeId() const;
-
             };
         }
 

hazelcast/include/hazelcast/client/serialization/ObjectDataInput.h

@@ -32,6 +32,7 @@
 #include "hazelcast/client/exception/HazelcastSerializationException.h"
 #include "hazelcast/client/serialization/pimpl/SerializationConstants.h"
 #include "hazelcast/util/IOUtil.h"
+#include "hazelcast/client/serialization/TypeIDS.h"
 #include <vector>
 #include <boost/shared_ptr.hpp>
 #include <string>
@@ -201,7 +202,7 @@ namespace hazelcast {
                         return boost::shared_ptr<T>(static_cast<T *>(NULL));
                     } else {
                         std::auto_ptr<T> result(new T);
-                        constants.checkClassType(result->getTypeId() , typeId);
+                        constants.checkClassType(getHazelcastTypeId(result.get()) , typeId);
                         if (constants.CONSTANT_TYPE_DATA == typeId) {
                             readDataSerializable(reinterpret_cast<IdentifiedDataSerializable *>(result.get()));
                         } else if (constants.CONSTANT_TYPE_PORTABLE == typeId) {