Rerun clang-format

Author: Michael Penick

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

@@ -158,7 +158,7 @@ class Integration : public testing::Test {
   /**
    * Handle for interacting with CCM
    */
-  SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge>> ccm_;
+  SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > ccm_;
   /**
    * Logger instance for handling driver log messages
    */

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

@@ -51,7 +51,7 @@ class Comparable {
  * value to be NULL.
  */
 template <typename T>
-class NullableValue : public Comparable<NullableValue<T>> {
+class NullableValue : public Comparable<NullableValue<T> > {
 public:
   /**
    * Constructor for a NULL value

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

@@ -512,7 +512,7 @@ const std::string& Options::public_key() { return public_key_; }
 
 const std::string& Options::private_key() { return private_key_; }
 
-SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge>> Options::ccm() {
+SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > Options::ccm() {
   return new CCM::Bridge(Options::server_version(), Options::use_git(), Options::branch_tag(),
                          Options::use_install_dir(), Options::install_dir(), Options::is_dse(),
                          CCM::Bridge::DEFAULT_DSE_WORKLOAD, Options::cluster_prefix(),

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

@@ -220,7 +220,7 @@ class Options {
    *
    * @return CCM instance
    */
-  static SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge>> ccm();
+  static SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > ccm();
 
 private:
   /**

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

@@ -27,8 +27,8 @@ struct StdDeleter {
 /**
  * Reference counted objects container
  */
-template <typename T, class D = datastax::internal::DefaultDeleter<T>>
-class ObjectRef : public datastax::internal::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) {}
@@ -52,14 +52,14 @@ class ObjectRef : public datastax::internal::RefCounted<ObjectRef<T, D>> {
 /**
  * Shared pointer for object references
  */
-template <typename T, class D = datastax::internal::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_ = datastax::internal::SharedRefPtr<ObjectRef<T, D>>(object_ref);
+      object_ = datastax::internal::SharedRefPtr<ObjectRef<T, D> >(object_ref);
     }
   }
 
@@ -92,7 +92,7 @@ class SharedPtr {
   /**
    * Object reference
    */
-  datastax::internal::SharedRefPtr<ObjectRef<T, D>> object_;
+  datastax::internal::SharedRefPtr<ObjectRef<T, D> > object_;
 };
 
 #endif // __SHARED_PTR_HPP__

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

@@ -278,7 +278,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullList) {
 
     // Bind the NULL collection and insert
     statement.bind<Integer>(0, Integer(i));
-    statement.bind<test::driver::List<TypeParam>>(1, value);
+    statement.bind<test::driver::List<TypeParam> >(1, value);
     this->session_.execute(statement);
 
     // Validate the insert and result
@@ -287,7 +287,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullList) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::List<TypeParam> select_value =
-        result.first_row().next().as<test::driver::List<TypeParam>>();
+        result.first_row().next().as<test::driver::List<TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -322,7 +322,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullMap) {
 
     // Bind the NULL collection and insert
     statement.bind<Integer>(0, Integer(i));
-    statement.bind<test::driver::Map<TypeParam, TypeParam>>(1, value);
+    statement.bind<test::driver::Map<TypeParam, TypeParam> >(1, value);
     this->session_.execute(statement);
 
     // Validate the insert and result
@@ -331,7 +331,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullMap) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::Map<TypeParam, TypeParam> select_value =
-        result.first_row().next().as<test::driver::Map<TypeParam, TypeParam>>();
+        result.first_row().next().as<test::driver::Map<TypeParam, TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -366,7 +366,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullSet) {
 
     // Bind the NULL collection and insert
     statement.bind<Integer>(0, Integer(i));
-    statement.bind<test::driver::Set<TypeParam>>(1, value);
+    statement.bind<test::driver::Set<TypeParam> >(1, value);
     this->session_.execute(statement);
 
     // Validate the insert and result
@@ -375,7 +375,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, BasicNullSet) {
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
     test::driver::Set<TypeParam> select_value =
-        result.first_row().next().as<test::driver::Set<TypeParam>>();
+        result.first_row().next().as<test::driver::Set<TypeParam> >();
     ASSERT_EQ(value, select_value);
     ASSERT_TRUE(select_value.is_null());
   }
@@ -411,23 +411,23 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, List) {
 
     // Bind both the primary key and the value with the Cassandra type list and insert
     if (this->is_key_allowed_) {
-      statement.bind<List<TypeParam>>(0, list);
+      statement.bind<List<TypeParam> >(0, list);
     } else {
       statement.bind<Integer>(0, Integer(i));
     }
-    statement.bind<List<TypeParam>>(1, list);
+    statement.bind<List<TypeParam> >(1, list);
     this->session_.execute(statement);
 
     // Validate the result
     Statement select_statement(this->select_query_, 1);
     if (this->is_key_allowed_) {
-      select_statement.bind<List<TypeParam>>(0, list);
+      select_statement.bind<List<TypeParam> >(0, list);
     } else {
       select_statement.bind<Integer>(0, Integer(i));
     }
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
-    List<TypeParam> result_list(result.first_row().next().as<List<TypeParam>>());
+    List<TypeParam> result_list(result.first_row().next().as<List<TypeParam> >());
     ASSERT_EQ(list.value(), result_list.value());
   }
 }
@@ -465,23 +465,23 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Set) {
 
     // Bind both the primary key and the value with the Cassandra type set and insert
     if (this->is_key_allowed_) {
-      statement.bind<Set<TypeParam>>(0, set);
+      statement.bind<Set<TypeParam> >(0, set);
     } else {
       statement.bind<Integer>(0, Integer(i));
     }
-    statement.bind<Set<TypeParam>>(1, set);
+    statement.bind<Set<TypeParam> >(1, set);
     this->session_.execute(statement);
 
     // Validate the result
     Statement select_statement(this->select_query_, 1);
     if (this->is_key_allowed_) {
-      select_statement.bind<Set<TypeParam>>(0, set);
+      select_statement.bind<Set<TypeParam> >(0, set);
     } else {
       select_statement.bind<Integer>(0, Integer(i));
     }
     Result result = this->session_.execute(select_statement);
     ASSERT_EQ(1u, result.row_count());
-    Set<TypeParam> result_set = result.first_row().next().as<Set<TypeParam>>();
+    Set<TypeParam> result_set = result.first_row().next().as<Set<TypeParam> >();
     ASSERT_EQ(set.value(), result_set.value());
   }
 }
@@ -524,17 +524,17 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Map) {
       Statement& statement = statements[i];
 
       // Bind both the primary key and the value with the Cassandra type map and insert
-      statement.bind<Map<TypeParam, TypeParam>>(0, map);
-      statement.bind<Map<TypeParam, TypeParam>>(1, map);
+      statement.bind<Map<TypeParam, TypeParam> >(0, map);
+      statement.bind<Map<TypeParam, TypeParam> >(1, map);
       this->session_.execute(statement);
 
       // Validate the result
       Statement select_statement(this->select_query_, 1);
-      select_statement.bind<Map<TypeParam, TypeParam>>(0, map);
+      select_statement.bind<Map<TypeParam, TypeParam> >(0, map);
       Result result = this->session_.execute(select_statement);
       ASSERT_EQ(1u, result.row_count());
       Column column = result.first_row().next();
-      Map<TypeParam, TypeParam> result_map(column.as<Map<TypeParam, TypeParam>>());
+      Map<TypeParam, TypeParam> result_map(column.as<Map<TypeParam, TypeParam> >());
       ASSERT_EQ(map_values, result_map.value());
     }
   } else {
@@ -559,7 +559,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Map) {
 
       // Bind both the primary key and the value with the Cassandra type map and insert
       statement.bind<Integer>(0, Integer(i));
-      statement.bind<Map<Integer, TypeParam>>(1, map);
+      statement.bind<Map<Integer, TypeParam> >(1, map);
       this->session_.execute(statement);
 
       // Validate the result
@@ -568,7 +568,7 @@ CASSANDRA_INTEGRATION_TYPED_TEST_P(CassandraTypesTest, Map) {
       Result result = this->session_.execute(select_statement);
       ASSERT_EQ(1u, result.row_count());
       Column column = result.first_row().next();
-      Map<Integer, TypeParam> result_map(column.as<Map<Integer, TypeParam>>());
+      Map<Integer, TypeParam> result_map(column.as<Map<Integer, TypeParam> >());
       ASSERT_EQ(map_values, result_map.value());
     }
   }

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

@@ -163,7 +163,7 @@ class ExecutionProfileTest : public Integration {
       // Get the data center and token values
       Row row = result.first_row();
       Text data_center = row.next().as<Text>();
-      std::set<Text> tokens = row.next().as<Set<Text>>().value();
+      std::set<Text> tokens = row.next().as<Set<Text> >().value();
 
       // Iterate over the tokens and update the token/host mapping
       for (std::set<Text>::const_iterator it = tokens.begin(); it != tokens.end(); ++it) {

cpp-driver/gtests/src/integration/values/list.hpp

@@ -29,7 +29,7 @@ namespace test { namespace driver {
 template <typename T>
 class List
     : public Collection
-    , Comparable<List<T>> {
+    , Comparable<List<T> > {
 public:
   List()
       : Collection(CASS_COLLECTION_TYPE_LIST) {}

cpp-driver/gtests/src/integration/values/set.hpp

@@ -27,7 +27,7 @@ namespace test { namespace driver {
 template <typename T>
 class Set
     : public Collection
-    , Comparable<Set<T>> {
+    , Comparable<Set<T> > {
 public:
   Set()
       : Collection(CASS_COLLECTION_TYPE_SET) {}

cpp-driver/gtests/src/unit/mockssandra.cpp

@@ -704,7 +704,7 @@ inline const char* decode_uuid(const char* input, CassUuid* output) {
 }
 
 inline const char* decode_string_map(const char* input, const char* end,
-                                     Vector<std::pair<String, String>>* output) {
+                                     Vector<std::pair<String, String> >* output) {
 
   uint16_t len = 0;
   const char* pos = decode_uint16(input, end, &len);