Run clang-format

Author: Michael Penick

cpp-driver/examples/async/async.c

@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -41,7 +41,6 @@ void print_error(CassFuture* future) {
   fprintf(stderr, "Error: %.*s\n", (int)message_length, message);
 }
 
-
 CassCluster* create_cluster(const char* hosts) {
   CassCluster* cluster = cass_cluster_new();
   cass_cluster_set_contact_points(cluster, hosts);
@@ -90,7 +89,7 @@ void insert_into_async(CassSession* session, const char* key) {
 
   size_t i;
   for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
-     char key_buffer[64];
+    char key_buffer[64];
     statement = cass_statement_new(query, 6);
 
     sprintf(key_buffer, "%s%u", key, (unsigned int)i);
@@ -135,13 +134,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.async (key text, \
+  execute_query(session, "CREATE TABLE examples.async (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \

cpp-driver/examples/auth/auth.c

@@ -35,8 +35,7 @@ typedef struct Credentials_ {
   const char* username;
 } Credentials;
 
-void on_auth_initial(CassAuthenticator* auth,
-                       void* data) {
+void on_auth_initial(CassAuthenticator* auth, void* data) {
   /*
    * This callback is used to initiate a request to begin an authentication
    * exchange. Required resources can be acquired and initialized here.
@@ -52,7 +51,7 @@ void on_auth_initial(CassAuthenticator* auth,
    * authentication callbacks were set and is available to all
    * authentication exchanges.
    */
-  const Credentials* credentials = (const Credentials *)data;
+  const Credentials* credentials = (const Credentials*)data;
 
   size_t username_size = strlen(credentials->username);
   size_t password_size = strlen(credentials->password);
@@ -68,20 +67,14 @@ void on_auth_initial(CassAuthenticator* auth,
   memcpy(response + username_size + 2, credentials->password, password_size);
 }
 
-void on_auth_challenge(CassAuthenticator* auth,
-                       void* data,
-                       const char* token,
-                       size_t token_size) {
+void on_auth_challenge(CassAuthenticator* auth, void* data, const char* token, size_t token_size) {
   /*
    * Not used for plain text authentication, but this is to be used
    * for handling an authentication challenge initiated by the server.
    */
 }
 
-void on_auth_success(CassAuthenticator* auth,
-                     void* data,
-                     const char* token,
-                     size_t token_size ) {
+void on_auth_success(CassAuthenticator* auth, void* data, const char* token, size_t token_size) {
   /*
    * Not used for plain text authentication, but this is to be used
    * for handling the success phase of an exchange.
@@ -104,17 +97,10 @@ int main(int argc, char* argv[]) {
   char* hosts = "127.0.0.1,127.0.0.2,127.0.0.3";
 
   /* Setup authentication callbacks and credentials */
-  CassAuthenticatorCallbacks auth_callbacks = {
-    on_auth_initial,
-    on_auth_challenge,
-    on_auth_success,
-    on_auth_cleanup
-  };
-
-  Credentials credentials = {
-    "cassandra",
-    "cassandra"
-  };
+  CassAuthenticatorCallbacks auth_callbacks = { on_auth_initial, on_auth_challenge, on_auth_success,
+                                                on_auth_cleanup };
+
+  Credentials credentials = { "cassandra", "cassandra" };
 
   /* Add contact points */
   if (argc > 1) {
@@ -123,10 +109,7 @@ int main(int argc, char* argv[]) {
   cass_cluster_set_contact_points(cluster, hosts);
 
   /* Set custom authentication callbacks and credentials */
-  cass_cluster_set_authenticator_callbacks(cluster,
-                                           &auth_callbacks,
-                                           NULL,
-                                           &credentials);
+  cass_cluster_set_authenticator_callbacks(cluster, &auth_callbacks, NULL, &credentials);
 
   /* Provide the cluster object as configuration to connect the session */
   connect_future = cass_session_connect(session, cluster);
@@ -138,8 +121,7 @@ int main(int argc, char* argv[]) {
     const char* message;
     size_t message_length;
     cass_future_error_message(connect_future, &message, &message_length);
-    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
-                                                        message);
+    fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message);
   }
 
   cass_future_free(connect_future);

cpp-driver/examples/basic/basic.c

@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -92,7 +92,8 @@ CassError insert_into_basic(CassSession* session, const char* key, const Basic*
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
-  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
+  const char* query =
+      "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
 
   statement = cass_statement_new(query, 6);
 
@@ -175,13 +176,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \

cpp-driver/examples/batch/batch.c

@@ -26,15 +26,15 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
 struct Pair_ {
-    const char* key;
-    const char* value;
+  const char* key;
+  const char* value;
 };
 
 typedef struct Pair_ Pair;
@@ -105,7 +105,8 @@ CassError prepare_insert_into_batch(CassSession* session, const CassPrepared** p
   return rc;
 }
 
-CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepared* prepared, const Pair* pairs) {
+CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepared* prepared,
+                                          const Pair* pairs) {
   CassError rc = CASS_OK;
   CassFuture* future = NULL;
   CassBatch* batch = cass_batch_new(CASS_BATCH_TYPE_LOGGED);
@@ -120,13 +121,15 @@ CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepar
   }
 
   {
-    CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES ('c', '3')", 0);
+    CassStatement* statement =
+        cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES ('c', '3')", 0);
     cass_batch_add_statement(batch, statement);
     cass_statement_free(statement);
   }
 
   {
-    CassStatement* statement = cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES (?, ?)", 2);
+    CassStatement* statement =
+        cass_statement_new("INSERT INTO examples.pairs (key, value) VALUES (?, ?)", 2);
     cass_statement_bind_string(statement, 0, "d");
     cass_statement_bind_string(statement, 1, "4");
     cass_batch_add_statement(batch, statement);
@@ -147,14 +150,13 @@ CassError insert_into_batch_with_prepared(CassSession* session, const CassPrepar
   return rc;
 }
 
-
 int main(int argc, char* argv[]) {
   CassCluster* cluster = NULL;
   CassSession* session = cass_session_new();
   const CassPrepared* prepared = NULL;
   char* hosts = "127.0.0.1";
 
-  Pair pairs[] = { {"a", "1"}, {"b", "2"}, { NULL, NULL} };
+  Pair pairs[] = { { "a", "1" }, { "b", "2" }, { NULL, NULL } };
 
   if (argc > 1) {
     hosts = argv[1];
@@ -167,13 +169,10 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.pairs (key text, \
+  execute_query(session, "CREATE TABLE examples.pairs (key text, \
                                               value text, \
                                               PRIMARY KEY (key));");
 

cpp-driver/examples/bind_by_name/bind_by_name.c

@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "cassandra.h"
 
@@ -106,7 +106,8 @@ CassError prepare_query(CassSession* session, const char* query, const CassPrepa
   return rc;
 }
 
-CassError insert_into_basic(CassSession* session, const CassPrepared* prepared, const char* key, const Basic* basic) {
+CassError insert_into_basic(CassSession* session, const CassPrepared* prepared, const char* key,
+                            const Basic* basic) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -135,7 +136,8 @@ CassError insert_into_basic(CassSession* session, const CassPrepared* prepared,
   return rc;
 }
 
-CassError select_from_basic(CassSession* session, const CassPrepared * prepared, const char* key, Basic* basic) {
+CassError select_from_basic(CassSession* session, const CassPrepared* prepared, const char* key,
+                            Basic* basic) {
   CassError rc = CASS_OK;
   CassStatement* statement = NULL;
   CassFuture* future = NULL;
@@ -183,10 +185,9 @@ int main(int argc, char* argv[]) {
   const CassPrepared* select_prepared = NULL;
   char* hosts = "127.0.0.1";
 
-  const char* insert_query
-    = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
-  const char* select_query
-    = "SELECT * FROM examples.basic WHERE key = ?";
+  const char* insert_query =
+      "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";
+  const char* select_query = "SELECT * FROM examples.basic WHERE key = ?";
 
   if (argc > 1) {
     hosts = argv[1];
@@ -199,25 +200,21 @@ int main(int argc, char* argv[]) {
     return -1;
   }
 
-  execute_query(session,
-                "CREATE KEYSPACE examples WITH replication = { \
+  execute_query(session, "CREATE KEYSPACE examples WITH replication = { \
                            'class': 'SimpleStrategy', 'replication_factor': '3' };");
 
-
-  execute_query(session,
-                "CREATE TABLE examples.basic (key text, \
+  execute_query(session, "CREATE TABLE examples.basic (key text, \
                                               bln boolean, \
                                               flt float, dbl double,\
                                               i32 int, i64 bigint, \
                                               PRIMARY KEY (key));");
 
-
   if (prepare_query(session, insert_query, &insert_prepared) == CASS_OK) {
     insert_into_basic(session, insert_prepared, "prepared_test", &input);
     cass_prepared_free(insert_prepared);
   }
 
-  if (prepare_query(session, select_query,  &select_prepared) == CASS_OK) {
+  if (prepare_query(session, select_query, &select_prepared) == CASS_OK) {
     select_from_basic(session, select_prepared, "prepared_test", &output);
 
     assert(input.bln == output.bln);

cpp-driver/examples/callbacks/callbacks.c

@@ -26,9 +26,9 @@
 */
 
 #include <assert.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <uv.h>
 
@@ -76,14 +76,14 @@ CassCluster* create_cluster(const char* hosts) {
   return cluster;
 }
 
-void connect_session(CassSession* session, const CassCluster* cluster, CassFutureCallback callback) {
+void connect_session(CassSession* session, const CassCluster* cluster,
+                     CassFutureCallback callback) {
   CassFuture* future = cass_session_connect(session, cluster);
   cass_future_set_callback(future, callback, session);
   cass_future_free(future);
 }
 
-void execute_query(CassSession* session, const char* query,
-                   CassFutureCallback callback) {
+void execute_query(CassSession* session, const char* query, CassFutureCallback callback) {
   CassStatement* statement = cass_statement_new(query, 0);
   CassFuture* future = cass_session_execute(session, statement);
   cass_future_set_callback(future, callback, session);
@@ -113,9 +113,7 @@ void on_create_keyspace(CassFuture* future, void* data) {
     print_error(future);
   }
 
-  execute_query((CassSession*)data,
-                "USE examples",
-                on_set_keyspace);
+  execute_query((CassSession*)data, "USE examples", on_set_keyspace);
 }
 
 void on_set_keyspace(CassFuture* future, void* data) {
@@ -163,10 +161,8 @@ void on_insert(CassFuture* future, void* data) {
     signal_exit();
   } else {
     const char* select_query = "SELECT * FROM callbacks";
-    CassStatement* statement
-        = cass_statement_new(select_query, 0);
-    CassFuture* select_future
-        = cass_session_execute((CassSession*)data, statement);
+    CassStatement* statement = cass_statement_new(select_query, 0);
+    CassFuture* select_future = cass_session_execute((CassSession*)data, statement);
 
     cass_future_set_callback(select_future, on_select, data);