CPP-692 - Fix C++98 compiler issues (#428)

Author: mpenick

gtests/src/unit/mockssandra.hpp

@@ -208,7 +208,7 @@ class ServerConnection : public RefCounted<ServerConnection> {
      STATE_CLOSING,
      STATE_ERROR,
      STATE_PENDING,
-     STATE_LISTENING,
+     STATE_LISTENING
    };
 
    Tcp tcp_;
@@ -254,7 +254,7 @@ enum {
   QUERY_FLAG_SERIAL_CONSISTENCY = 0x10,
   QUERY_FLAG_TIMESTAMP = 0x20,
   QUERY_FLAG_NAMES_FOR_VALUES = 0x40,
-  QUERY_FLAG_KEYSPACE = 0x80,
+  QUERY_FLAG_KEYSPACE = 0x80
 };
 
 enum {
@@ -362,11 +362,16 @@ class Type {
   void encode(int protocol_version, String* output) const;
 
 private:
+  Type()
+    : type_(-1) { }
+
   Type(int type)
     : type_(type) { }
 
+  friend class Vector<Type>;
+
 private:
-  const int type_;
+  int type_;
   String custom_;
   Vector<String> names_;
   Vector<Type> types_;
@@ -518,7 +523,7 @@ class Row {
     : values_(values) { }
 
 private:
-  const Vector<Value> values_;
+  Vector<Value> values_;
 };
 
 class ResultSet {
@@ -575,6 +580,7 @@ struct Exception : public std::exception {
   Exception(int code, const String& message)
     : code(code)
     , message(message) { }
+  virtual ~Exception() throw() { }
   const int code;
   const String message;
 };
@@ -1067,7 +1073,7 @@ class TopologyChangeEvent : public Event {
   enum Type {
     NEW_NODE,
     MOVED_NODE,
-    REMOVED_NODE,
+    REMOVED_NODE
   };
 
   TopologyChangeEvent(Type type, const Address& address)
@@ -1153,12 +1159,21 @@ class Cluster {
       : host(host)
       , connection(connection)
       , is_removed(false) { }
+
     Server(const Server& server)
       : host(server.host)
       , connection(server.connection)
       , is_removed(server.is_removed.load()) { }
-    const Host host;
-    const internal::ServerConnection::Ptr connection;
+
+    Server& operator=(const Server& server) {
+      host = server.host;
+      connection = server.connection;
+      is_removed.store(server.is_removed.load());
+      return *this;
+    }
+
+    Host host;
+    internal::ServerConnection::Ptr connection;
     cass::Atomic<bool> is_removed;
   };
 

gtests/src/unit/tests/test_cluster.cpp

@@ -136,13 +136,13 @@ class ClusterUnitTest : public EventLoopTest {
     struct Event {
       enum Type {
         NODE_ADD,
-        NODE_REMOVE,
+        NODE_REMOVE
       };
       Event(Type type, const Address& address)
         : type(type)
         , address(address) { }
-      const Type type;
-      const Address address;
+      Type type;
+      Address address;
     };
     typedef Vector<Event> Events;
 

gtests/src/unit/tests/test_control_connection.cpp

@@ -200,7 +200,7 @@ class ControlConnectionUnitTest : public LoopTest {
                                 const String& target_name) {
       RecordingControlConnectionListener::on_update_schema(type, result,
                                                            keyspace_name, target_name);
-      if (type == SchemaType::COLUMN || type == SchemaType::INDEX) return;
+      if (type == COLUMN || type == INDEX) return;
       if (--remaining_ <= 0) connection_->close();
     }
 

gtests/src/unit/tests/test_copy_on_write.cpp

@@ -23,7 +23,7 @@
 #include "vector.hpp"
 
 TEST(CopyOnWriteUnitTest, Simple) {
-  cass::Vector<int>* ptr = cass::Memory::allocate<cass::Vector<int>>();
+  cass::Vector<int>* ptr = cass::Memory::allocate<cass::Vector<int> >();
   cass::CopyOnWritePtr<cass::Vector<int> > vec(ptr);
 
   // Only a single reference so no copy should be made

gtests/src/unit/tests/test_future.cpp

@@ -41,24 +41,24 @@ void start_timer(void* arg) {
 }
 
 TEST(FutureUnitTest, Types) {
-  cass::Future generic(cass::Future::Type::FUTURE_TYPE_GENERIC);
-  cass::Future session(cass::Future::Type::FUTURE_TYPE_SESSION);
-  cass::Future response(cass::Future::Type::FUTURE_TYPE_RESPONSE);
+  cass::Future generic(cass::Future::FUTURE_TYPE_GENERIC);
+  cass::Future session(cass::Future::FUTURE_TYPE_SESSION);
+  cass::Future response(cass::Future::FUTURE_TYPE_RESPONSE);
 
-  ASSERT_EQ(cass::Future::Type::FUTURE_TYPE_GENERIC, generic.type());
-  ASSERT_EQ(cass::Future::Type::FUTURE_TYPE_SESSION, session.type());
-  ASSERT_EQ(cass::Future::Type::FUTURE_TYPE_RESPONSE, response.type());
+  ASSERT_EQ(cass::Future::FUTURE_TYPE_GENERIC, generic.type());
+  ASSERT_EQ(cass::Future::FUTURE_TYPE_SESSION, session.type());
+  ASSERT_EQ(cass::Future::FUTURE_TYPE_RESPONSE, response.type());
 }
 
 TEST(FutureUnitTest, Ready) {
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   ASSERT_FALSE(future.ready());
   future.set();
   ASSERT_TRUE(future.ready());
 }
 
 TEST(FutureUnitTest, Wait) {
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   uv_thread_t thread;
   ASSERT_EQ(0, uv_thread_create(&thread, start_timer, &future));
 
@@ -69,7 +69,7 @@ TEST(FutureUnitTest, Wait) {
 }
 
 TEST(FutureUnitTest, WaitFor) {
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   uv_thread_t thread;
   ASSERT_EQ(0, uv_thread_create(&thread, start_timer, &future));
 
@@ -85,7 +85,7 @@ TEST(FutureUnitTest, WaitFor) {
 }
 
 TEST(FutureUnitTest, Error) {
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   future.set_error(CASS_ERROR_LIB_BAD_PARAMS, "FutureUnitTest error message");
   ASSERT_TRUE(future.ready());
   ASSERT_TRUE(future.error());
@@ -95,7 +95,7 @@ TEST(FutureUnitTest, Error) {
 
 TEST(FutureUnitTest, Callback) {
   bool is_future_callback_called = false;
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   ASSERT_TRUE(future.set_callback(&on_future_callback, &is_future_callback_called));
 
   ASSERT_FALSE(is_future_callback_called);
@@ -105,14 +105,14 @@ TEST(FutureUnitTest, Callback) {
 }
 
 TEST(FutureUnitTest, CallbackAlreadyAssigned) {
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
   ASSERT_TRUE(future.set_callback(&on_future_callback, NULL));
   ASSERT_FALSE(future.set_callback(&on_future_callback, NULL));
 }
 
 TEST(FutureUnitTest, CallbackAfterFutureIsSet) {
   bool is_future_callback_called = false;
-  cass::Future future(cass::Future::Type::FUTURE_TYPE_GENERIC);
+  cass::Future future(cass::Future::FUTURE_TYPE_GENERIC);
 
   ASSERT_FALSE(is_future_callback_called);
   future.set();

gtests/src/unit/tests/test_pool.cpp

@@ -76,12 +76,11 @@ class PoolUnitTest : public LoopTest {
       , public Status<RequestState::Enum> {
   public:
     RequestStatus(uv_loop_t* loop, int num_nodes = NUM_NODES)
-      : Status()
-      , loop_(loop)
+      : loop_(loop)
       , remaining_(num_nodes) { }
 
     virtual void set(RequestState::Enum state) {
-      Status::set(state);
+      Status<RequestStatus::Enum>::set(state);
       if (--remaining_ == 0) uv_stop(loop_);
     }
 
@@ -176,7 +175,7 @@ class PoolUnitTest : public LoopTest {
 
   private:
     virtual void set(ListenerState::Enum state) {
-      Status::set(state);
+      Status<ListenerState::Enum>::set(state);
       if (--remaining_ == 0) uv_stop(loop_);
     }
 

gtests/src/unit/tests/test_request_processor.cpp

@@ -171,15 +171,15 @@ class RequestProcessorUnitTest : public EventLoopTest {
       future->set_processor(initializer->release_processor());
     } else {
       switch (initializer->error_code()) {
-        case RequestProcessorInitializer::RequestProcessorError::REQUEST_PROCESSOR_ERROR_KEYSPACE:
+        case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_KEYSPACE:
           future->set_error(CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE,
                             initializer->error_message());
           break;
-        case RequestProcessorInitializer::RequestProcessorError::REQUEST_PROCESSOR_ERROR_NO_HOSTS_AVAILABLE:
+        case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_NO_HOSTS_AVAILABLE:
           future->set_error(CASS_ERROR_LIB_NO_HOSTS_AVAILABLE,
                             "Unable to connect to any contact points");
           break;
-        case RequestProcessorInitializer::RequestProcessorError::REQUEST_PROCESSOR_ERROR_UNABLE_TO_INIT:
+        case RequestProcessorInitializer::REQUEST_PROCESSOR_ERROR_UNABLE_TO_INIT:
           future->set_error(CASS_ERROR_LIB_UNABLE_TO_INIT,
                             initializer->error_message());
           break;

gtests/src/unit/unit.hpp

@@ -46,7 +46,7 @@ class Unit : public testing::Test {
       START_NODE,
       STOP_NODE,
       ADD_NODE,
-      REMOVE_NODE,
+      REMOVE_NODE
     };
 
     /**

src/event_loop.cpp

@@ -185,10 +185,12 @@ void EventLoop::on_check(Check *check) {
 }
 
 void EventLoop::on_task(Async* async) {
-  Task* task;
+  Task* task = NULL;
   while (tasks_.dequeue(task)) {
-    task->run(this);
-    Memory::deallocate(task);
+    if (task) {
+      task->run(this);
+      Memory::deallocate(task);
+    }
   }
 
   if (is_closing_.load() && tasks_.is_empty()) {