CPP-764 - Move internal components from namespace cass to namespace datastax::internal (#233)

Author: mpenick

cpp-driver/gtests/src/integration/driver_utils.cpp

@@ -24,15 +24,18 @@
 #include "request_handler.hpp"
 #include "statement.hpp"
 
+using namespace datastax::internal;
+using namespace datastax::internal::core;
+
 std::vector<std::string> test::driver::internals::Utils::attempted_hosts(
   CassFuture* future) {
   std::vector<std::string> attempted_hosts;
   if (future) {
-    cass::Future* cass_future = static_cast<cass::Future*>(future);
-    if (cass_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      cass::ResponseFuture* response = static_cast<cass::ResponseFuture*>(cass_future);
-      cass::AddressVec attempted_addresses = response->attempted_addresses();
-      for (cass::AddressVec::iterator iterator = attempted_addresses.begin();
+    Future* cass_future = static_cast<Future*>(future);
+    if (cass_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      ResponseFuture* response = static_cast<ResponseFuture*>(cass_future);
+      AddressVec attempted_addresses = response->attempted_addresses();
+      for (AddressVec::iterator iterator = attempted_addresses.begin();
         iterator != attempted_addresses.end(); ++iterator) {
         attempted_hosts.push_back(iterator->to_string().c_str());
       }
@@ -48,9 +51,9 @@ unsigned int test::driver::internals::Utils::connect_timeout(CassCluster* cluste
 
 std::string test::driver::internals::Utils::contact_points(CassCluster* cluster) {
   std::string contact_points;
-  const cass::ContactPointList& contact_points_list =
+  const ContactPointList& contact_points_list =
     cluster->config().contact_points();
-  for (cass::ContactPointList::const_iterator it = contact_points_list.begin();
+  for (ContactPointList::const_iterator it = contact_points_list.begin();
        it != contact_points_list.end(); ++it) {
     if (contact_points.size() > 0) {
       contact_points.push_back(',');
@@ -61,26 +64,26 @@ std::string test::driver::internals::Utils::contact_points(CassCluster* cluster)
 }
 
 std::string test::driver::internals::Utils::driver_name() {
-  return cass::driver_name();
+  return datastax::internal::driver_name();
 }
 
 std::string test::driver::internals::Utils::driver_version() {
-  return cass::driver_version();
+  return datastax::internal::driver_version();
 }
 
 std::string test::driver::internals::Utils::host(CassFuture* future) {
   if (future) {
-    cass::Future* cass_future = static_cast<cass::Future*>(future);
-    if (cass_future->type() == cass::Future::FUTURE_TYPE_RESPONSE) {
-      return static_cast<cass::ResponseFuture*>(cass_future)->address().to_string().c_str();
+    Future* cass_future = static_cast<Future*>(future);
+    if (cass_future->type() == Future::FUTURE_TYPE_RESPONSE) {
+      return static_cast<ResponseFuture*>(cass_future)->address().to_string().c_str();
     }
   }
   return "";
 }
 
 int64_t test::driver::internals::Utils::murmur3_hash(
   const std::string& value) {
-  return cass::MurmurHash3_x64_128(value.data(), value.size(), 0);
+  return MurmurHash3_x64_128(value.data(), value.size(), 0);
 }
 
 int test::driver::internals::Utils::port(CassCluster* cluster) {
@@ -90,7 +93,7 @@ int test::driver::internals::Utils::port(CassCluster* cluster) {
 void test::driver::internals::Utils::set_record_attempted_hosts(
   CassStatement* statement, bool enable) {
   if (statement) {
-    static_cast<cass::Statement*>(statement)
+    static_cast<Statement*>(statement)
       ->set_record_attempted_addresses(enable);
   }
 }

cpp-driver/gtests/src/integration/logger.cpp

@@ -25,6 +25,7 @@
 #include <iostream>
 #include <sstream>
 
+using namespace datastax::internal;
 using namespace test::driver;
 
 #define LOGGER_DIRECTORY "log"
@@ -75,12 +76,12 @@ void Logger::initialize(const std::string& test_case, const std::string& test_na
 }
 
 void Logger::add_critera(const std::string& criteria) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.push_back(criteria);
 }
 
 void test::driver::Logger::clear_critera() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.clear();
 }
 
@@ -90,7 +91,7 @@ size_t Logger::count() {
 
 void Logger::log(const CassLogMessage* log, void* data) {
   Logger* logger = static_cast<Logger*>(data);
-  cass::ScopedMutex lock(&(logger->mutex_));
+  ScopedMutex lock(&(logger->mutex_));
 
   // Get the log message
   std::string message = log->message;
@@ -133,13 +134,13 @@ void Logger::log(const CassLogMessage* log, void* data) {
 }
 
 void test::driver::Logger::reset() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   search_criteria_.clear();
   count_ = 0;
 }
 
 void test::driver::Logger::reset_count() {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   count_ = 0;
 }
 

cpp-driver/gtests/src/integration/policies/ignore_retry_policy.hpp

@@ -27,48 +27,48 @@ namespace driver {
 /**
  * Retry policy that will create an ignore decision for retry
  */
-class IgnoreRetryPolicy : public cass::DefaultRetryPolicy {
+class IgnoreRetryPolicy : public datastax::internal::core::DefaultRetryPolicy {
 public:
   IgnoreRetryPolicy()
-    : cass::DefaultRetryPolicy() { }
+    : datastax::internal::core::DefaultRetryPolicy() { }
 
   /**
    * Create an instance of the retry policy for use with the driver
    *
    * @return Driver ready retry policy
    */
   static ::test::driver::RetryPolicy policy() {
-    cass::RetryPolicy* policy = new IgnoreRetryPolicy();
+    datastax::internal::core::RetryPolicy* policy = new IgnoreRetryPolicy();
     policy->inc_ref();
     return CassRetryPolicy::to(policy);
   }
 
-  RetryDecision on_read_timeout(const cass::Request* request,
+  RetryDecision on_read_timeout(const datastax::internal::core::Request* request,
                                 CassConsistency cl,
                                 int received,
                                 int required,
                                 bool data_recevied,
                                 int num_retries) const {
     return RetryDecision::ignore();
   }
-  RetryDecision on_write_timeout(const cass::Request* request,
+  RetryDecision on_write_timeout(const datastax::internal::core::Request* request,
                                  CassConsistency cl,
                                  int received,
                                  int required,
                                  CassWriteType write_type,
                                  int num_retries) const {
     return RetryDecision::ignore();
   }
-  virtual RetryDecision on_unavailable(const cass::Request* request,
+  virtual RetryDecision on_unavailable(const datastax::internal::core::Request* request,
                                        CassConsistency cl,
                                        int required,
                                        int alive,
                                        int num_retries) const {
     return RetryDecision::ignore();
   }
-  virtual RetryDecision on_request_error(const cass::Request* request,
+  virtual RetryDecision on_request_error(const datastax::internal::core::Request* request,
                                          CassConsistency cl,
-                                         const cass::ErrorResponse* error,
+                                         const datastax::internal::core::ErrorResponse* error,
                                          int num_retries) const {
     return RetryDecision::ignore();
   }

cpp-driver/gtests/src/integration/policies/next_host_retry_policy.hpp

@@ -27,48 +27,48 @@ namespace driver {
 /**
  * Retry policy that will retry the statement on the next host
  */
-class NextHostRetryPolicy : public cass::DefaultRetryPolicy {
+class NextHostRetryPolicy : public datastax::internal::core::DefaultRetryPolicy {
 public:
   NextHostRetryPolicy()
-    : cass::DefaultRetryPolicy() { }
+    : datastax::internal::core::DefaultRetryPolicy() { }
 
   /**
    * Create an instance of the retry policy for use with the driver
    *
    * @return Driver ready retry policy
    */
   static ::test::driver::RetryPolicy policy() {
-    cass::RetryPolicy* policy = new NextHostRetryPolicy();
+    datastax::internal::core::RetryPolicy* policy = new NextHostRetryPolicy();
     policy->inc_ref();
     return CassRetryPolicy::to(policy);
   }
 
-  RetryDecision on_read_timeout(const cass::Request* request,
+  RetryDecision on_read_timeout(const datastax::internal::core::Request* request,
                                 CassConsistency cl,
                                 int received,
                                 int required,
                                 bool data_recevied,
                                 int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  RetryDecision on_write_timeout(const cass::Request* request,
+  RetryDecision on_write_timeout(const datastax::internal::core::Request* request,
                                  CassConsistency cl,
                                  int received,
                                  int required,
                                  CassWriteType write_type,
                                  int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  virtual RetryDecision on_unavailable(const cass::Request* request,
+  virtual RetryDecision on_unavailable(const datastax::internal::core::Request* request,
                                        CassConsistency cl,
                                        int required,
                                        int alive,
                                        int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }
-  virtual RetryDecision on_request_error(const cass::Request* request,
+  virtual RetryDecision on_request_error(const datastax::internal::core::Request* request,
                                          CassConsistency cl,
-                                         const cass::ErrorResponse* error,
+                                         const datastax::internal::core::ErrorResponse* error,
                                          int num_retries) const {
     return RetryDecision::retry_next_host(cl);
   }

cpp-driver/gtests/src/integration/rest_client.cpp

@@ -25,6 +25,8 @@
 #define HTTP_EOL "\r\n"
 #define OUTPUT_BUFFER_SIZE 10240ul
 
+using namespace datastax::internal::core;
+
 // Static initializations
 uv_buf_t RestClient::write_buf_;
 uv_write_t RestClient::write_req_;
@@ -62,8 +64,8 @@ const Response RestClient::send_request(const Request& request) {
   http_request.loop = &loop;
 
   // Create the IPv4 socket address
-  const cass::Address address(request.address.c_str(),
-                              static_cast<int>(request.port));
+  const Address address(request.address.c_str(),
+                        static_cast<int>(request.port));
 
   // Initialize the client TCP request
   uv_tcp_t tcp;

cpp-driver/gtests/src/integration/shared_ptr.hpp

@@ -27,8 +27,8 @@ struct StdDeleter {
 /**
  * Reference counted objects container
  */
-template<typename T, class D = cass::DefaultDeleter<T> >
-class ObjectRef : public cass::RefCounted< ObjectRef<T, D> > {
+template<typename T, class D = datastax::internal::DefaultDeleter<T> >
+class ObjectRef : public datastax::internal::RefCounted< ObjectRef<T, D> > {
 public:
   ObjectRef(T* ptr)
     : ptr_(ptr) {}
@@ -56,14 +56,14 @@ class ObjectRef : public cass::RefCounted< ObjectRef<T, D> > {
 /**
  * Shared pointer for object references
  */
-template<typename T, class D = cass::DefaultDeleter<T> >
+template<typename T, class D = datastax::internal::DefaultDeleter<T> >
 class SharedPtr {
 public:
   SharedPtr(T* ptr = NULL)
     : object_(NULL) {
     if (ptr) {
       ObjectRef<T, D>* object_ref = new ObjectRef<T, D>(ptr);
-      object_ = cass::SharedRefPtr<ObjectRef<T, D> >(object_ref);
+      object_ = datastax::internal::SharedRefPtr<ObjectRef<T, D> >(object_ref);
     }
   }
 
@@ -101,7 +101,7 @@ class SharedPtr {
   /**
    * Object reference
    */
-  cass::SharedRefPtr<ObjectRef<T, D> > object_;
+  datastax::internal::SharedRefPtr<ObjectRef<T, D> > object_;
 };
 
 #endif // __SHARED_PTR_HPP__

cpp-driver/gtests/src/integration/simulacron/simulacron_cluster.cpp

@@ -39,6 +39,8 @@
 #define MAX_TOKEN static_cast<uint64_t>(INT64_MAX) - 1
 #define DATA_CENTER_PREFIX "dc"
 
+using datastax::internal::ScopedMutex;
+
 // Initialize the mutex, running status, thread, and default data center nodes
 uv_mutex_t test::SimulacronCluster::mutex_;
 bool test::SimulacronCluster::is_ready_ = false;
@@ -275,15 +277,15 @@ void test::SimulacronCluster::remove_primed_queries(unsigned int node /*= 0*/) {
 void test::SimulacronCluster::handle_exit(uv_process_t* process,
                                           int64_t error_code,
                                           int term_signal) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   TEST_LOG("Process " << process->pid << " Terminated: " << error_code);
   uv_close(reinterpret_cast<uv_handle_t*>(process), NULL);
 }
 
 void test::SimulacronCluster::handle_allocation(uv_handle_t* handle,
                                                 size_t suggested_size,
                                                 uv_buf_t* buffer) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   buffer->base = new char[OUTPUT_BUFFER_SIZE];
   buffer->len = OUTPUT_BUFFER_SIZE;
 }
@@ -352,7 +354,7 @@ void test::SimulacronCluster::handle_thread_create(void* arg) {
 
 void test::SimulacronCluster::handle_read(uv_stream_t* stream,
   ssize_t buffer_length, const uv_buf_t* buffer) {
-  cass::ScopedMutex lock(&mutex_);
+  ScopedMutex lock(&mutex_);
   if (buffer_length > 0) {
     // Process the buffer and log it
     std::string message(buffer->base, buffer_length);

cpp-driver/gtests/src/integration/tests/test_null_string_params.cpp

@@ -27,6 +27,8 @@
 // Name of materialized view used in this test file.
 #define VIEW_NAME "my_view"
 
+using namespace datastax::internal::core;
+
 /**
  * Null string api args test, without initially creating a connection.
  */
@@ -672,8 +674,8 @@ CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, UserTypeFunctions) {
  */
 CASSANDRA_INTEGRATION_TEST_F(SchemaNullStringApiArgsTest, MiscellaneousFunctions) {
   CHECK_VERSION(2.2.0);
-  cass::ResultResponse response;
-  cass::Row r(&response);
+  ResultResponse response;
+  datastax::internal::core::Row r(&response);
   CassRow* row = CassRow::to(&r);
   EXPECT_EQ(NULL, cass_row_get_column_by_name(row, NULL));
 

cpp-driver/gtests/src/integration/tests/test_session.cpp

@@ -24,6 +24,8 @@
 #define EVENT_MAXIMUM_WAIT_TIME_MS 5000
 #define EVENT_WAIT_FOR_NAP_MS 100
 
+using namespace datastax::internal;
+
 class SessionTest : public Integration {
 public:
   typedef std::pair<CassHostListenerEvent, std::string> Event;
@@ -42,7 +44,7 @@ class SessionTest : public Integration {
   }
 
   void check_event(CassHostListenerEvent expected_event, short expected_node) {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     std::stringstream expected_address;
     expected_address << ccm_->get_ip_prefix() << expected_node;
     Event event = events_.front();
@@ -61,11 +63,11 @@ class SessionTest : public Integration {
 
 protected:
   size_t event_count() {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     return events_.size();
   }
   void add_event(CassHostListenerEvent event, CassInet inet) {
-    cass::ScopedMutex l(&mutex_);
+    ScopedMutex l(&mutex_);
     char address[CASS_INET_STRING_LENGTH];
 
     cass_inet_string(inet, address);