[1] Updates for linting

cpp/src/arrow/flight/client.cc

@@ -105,7 +105,7 @@ struct ClientRpc {
               std::chrono::system_clock::now() + options.timeout);
       context.set_deadline(deadline);
     }
-    for (auto metadata: options.metadata) {
+    for (auto metadata : options.metadata) {
       context.AddMetadata(metadata.first, metadata.second);
     }
   }
@@ -998,7 +998,8 @@ class FlightClient::FlightClientImpl {
     return Status::OK();
   }
 
-  Status AuthenticateBasicToken(std::string username, std::string password, std::pair<std::string, std::string>* bearer_token) {
+  Status AuthenticateBasicToken(std::string username, std::string password,
+                                std::pair<std::string, std::string>* bearer_token) {
     // Add bearer token factory to middleware so it can intercept the bearer token.
     middleware.push_back(std::make_shared<ClientBearerTokenFactory>(bearer_token));
     ClientRpc rpc({});
@@ -1227,7 +1228,7 @@ Status FlightClient::Authenticate(const FlightCallOptions& options,
 }
 
 Status FlightClient::AuthenticateBasicToken(
-    std::string username, std::string password, 
+    std::string username, std::string password,
     std::pair<std::string, std::string>* bearer_token) {
   return impl_->AuthenticateBasicToken(username, password, bearer_token);
 }

cpp/src/arrow/flight/client.h

@@ -194,10 +194,12 @@ class ARROW_FLIGHT_EXPORT FlightClient {
                       std::unique_ptr<ClientAuthHandler> auth_handler);
 
   /// \brief Authenticate to the server using the given handler.
-  /// \param[in] options Per-RPC options
-  /// \param[in] auth_handler The authentication mechanism to use
+  /// \param[in] username Username to use
+  /// \param[in] password Password to use
+  /// \param[in] bearer_token Bearer token retreived if applicable
   /// \return Status OK if the client authenticated successfully
-  Status AuthenticateBasicToken(std::string username, std::string password, std::pair<std::string, std::string>* bearer_token);
+  Status AuthenticateBasicToken(std::string username, std::string password, 
+                                std::pair<std::string, std::string>* bearer_token);
 
   /// \brief Perform the indicated action, returning an iterator to the stream
   /// of results, if any

cpp/src/arrow/flight/client_header_auth_middleware.cc

@@ -28,12 +28,14 @@ namespace flight {
 
   std::string base64_encode(const std::string& input);
 
-  ClientBearerTokenMiddleware::ClientBearerTokenMiddleware(std::pair<std::string, std::string>* bearer_token_) 
+  ClientBearerTokenMiddleware::ClientBearerTokenMiddleware(
+    std::pair<std::string, std::string>* bearer_token_)
         : bearer_token(bearer_token_) { }
 
   void ClientBearerTokenMiddleware::SendingHeaders(AddCallHeaders* outgoing_headers) { }
 
-  void ClientBearerTokenMiddleware::ReceivedHeaders(const CallHeaders& incoming_headers) {
+  void ClientBearerTokenMiddleware::ReceivedHeaders(
+    const CallHeaders& incoming_headers) {
     // Grab the auth token if one exists.
     auto bearer_iter = incoming_headers.find(AUTH_HEADER);
     if (bearer_iter == incoming_headers.end()) {
@@ -43,9 +45,9 @@ namespace flight {
     // Check if the value of the auth token starts with the bearer prefix, latch the token.
     std::string bearer_val = bearer_iter->second.to_string();
     if (bearer_val.size() > BEARER_PREFIX.size()) {
-      bool hasPrefix = std::equal(bearer_val.begin(), bearer_val.begin() + BEARER_PREFIX.size(), BEARER_PREFIX.begin(), 
-        [] (const char& char1, const char& char2) { 
-          return (std::toupper(char1) == std::toupper(char2)); 
+      bool hasPrefix = std::equal(bearer_val.begin(), bearer_val.begin() + BEARER_PREFIX.size(), BEARER_PREFIX.begin(),
+        [] (const char& char1, const char& char2) {
+          return (std::toupper(char1) == std::toupper(char2));
         }
       );
       if (hasPrefix) {
@@ -55,7 +57,7 @@ namespace flight {
   }
 
   void ClientBearerTokenMiddleware::CallCompleted(const Status& status) { }
-  
+
   void ClientBearerTokenFactory::StartCall(const CallInfo& info, std::unique_ptr<ClientMiddleware>* middleware) {
     *middleware = std::unique_ptr<ClientBearerTokenMiddleware>(new ClientBearerTokenMiddleware(bearer_token));
   }
@@ -68,28 +70,28 @@ namespace flight {
   std::string string_format(const std::string& format, const Args... args) {
     // Check size requirement for new string and increment by 1 for null terminator.
     size_t size = std::snprintf(nullptr, 0, format.c_str(), args ...) + 1;
-    if(size <= 0){ 
-      throw std::runtime_error("Error during string formatting. Format: '" + format + "'."); 
+    if(size <= 0){
+      throw std::runtime_error("Error during string formatting. Format: '" + format + "'.");
     }
 
     // Create buffer for new string and write string in.
-    std::unique_ptr<char[]> buf(new char[size]); 
+    std::unique_ptr<char[]> buf(new char[size]);
     std::snprintf(buf.get(), size, format.c_str(), args...);
-    
+
     // Convert to std::string, subtracting size by 1 to trim null terminator.
     return std::string(buf.get(), buf.get() + size - 1);
   }
-  
+
   void AddBasicAuthHeaders(grpc::ClientContext* context, const std::string& username, const std::string& password) {
     const std::string formatted_credentials = string_format("%s:%s", username.c_str(), password.c_str());
     context->AddMetadata(AUTH_HEADER, BASIC_PREFIX + base64_encode(formatted_credentials));
   }
- 
+
   std::string base64_encode(const std::string& input) {
-     static const std::string base64_chars = 
+     static const std::string base64_chars =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-     auto get_encoded_length = [] (const std::string& in) { 
-       return 4 * ((in.size() + 2) / 3); 
+     auto get_encoded_length = [] (const std::string& in) {
+       return 4 * ((in.size() + 2) / 3);
      };
      auto get_overwrite_count = [] (const std::string& in) {
        const std::string::size_type remainder = in.length() % 3;
@@ -110,10 +112,12 @@ namespace flight {
              encoded.push_back(base64_chars[(octriple >> j * 6) & 0x3F]);
          }
      }
-     
+
      // Round up to nearest multiple of 3 and replace characters at end based on rounding.
      int overwrite_count = get_overwrite_count(input);
-     encoded.replace(encoded.length() - overwrite_count, encoded.length(), overwrite_count, '=');
+     encoded.replace(encoded.length() - overwrite_count, 
+                     encoded.length(), 
+                     overwrite_count, '=');
      return encoded;
   }
 }  // namespace flight

cpp/src/arrow/flight/client_header_auth_middleware.h

@@ -20,9 +20,9 @@
 
 #pragma once
 
-#include "client_middleware.h"
-#include "client_auth.h"
-#include "client.h"
+#include "arrow/flight/client_middleware.h"
+#include "arrow/flight/client_auth.h"
+#include "arrow/flight/client.h"
 
 #ifdef GRPCPP_PP_INCLUDE
 #include <grpcpp/grpcpp.h>
@@ -45,11 +45,14 @@ const std::string BASIC_PREFIX = "Basic ";
 namespace arrow {
 namespace flight {
 
-void ARROW_FLIGHT_EXPORT AddBasicAuthHeaders(grpc::ClientContext* context, const std::string& username, const std::string& password);
+void ARROW_FLIGHT_EXPORT AddBasicAuthHeaders(grpc::ClientContext* context, 
+                                             const std::string& username, 
+                                             const std::string& password);
 
 class ARROW_FLIGHT_EXPORT ClientBearerTokenMiddleware : public ClientMiddleware {
  public:
-  explicit ClientBearerTokenMiddleware(std::pair<std::string, std::string>* bearer_token_);
+  explicit ClientBearerTokenMiddleware(
+    std::pair<std::string, std::string>* bearer_token_);
 
   void SendingHeaders(AddCallHeaders* outgoing_headers);
   void ReceivedHeaders(const CallHeaders& incoming_headers);
@@ -61,11 +64,12 @@ class ARROW_FLIGHT_EXPORT ClientBearerTokenMiddleware : public ClientMiddleware
 
 class ARROW_FLIGHT_EXPORT ClientBearerTokenFactory : public ClientMiddlewareFactory {
  public:
-  explicit ClientBearerTokenFactory(std::pair<std::string, std::string>* bearer_token_) : bearer_token(bearer_token_) {}
+  explicit ClientBearerTokenFactory(std::pair<std::string, std::string>* bearer_token_)
+    : bearer_token(bearer_token_) {}
 
   void StartCall(const CallInfo& info, std::unique_ptr<ClientMiddleware>* middleware);
   void Reset();
-  
+
  private:
   std::pair<std::string, std::string>* bearer_token;
 };