buffet: fixed the style of using 'const' with pointers and references
Using 'const type*' and 'const type&' instead of 'type const*'...
BUG=None
TEST=Code still compiles.
Change-Id: I3de0e32067563d0e6fd91dcc9a4cd2232bb76b1a
Reviewed-on: https://chromium-review.googlesource.com/195434
Reviewed-by: Alex Vakulenko <avakulenko@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
old mode 100755
new mode 100644
diff --git a/buffet/data_encoding.cc b/buffet/data_encoding.cc
index 1c0013a..0049193 100644
--- a/buffet/data_encoding.cc
+++ b/buffet/data_encoding.cc
@@ -29,7 +29,7 @@
namespace chromeos {
namespace data_encoding {
-std::string UrlEncode(char const* data, bool encodeSpaceAsPlus) {
+std::string UrlEncode(const char* data, bool encodeSpaceAsPlus) {
std::string result;
while(*data) {
@@ -53,7 +53,7 @@
return result;
}
-std::string UrlDecode(char const* data) {
+std::string UrlDecode(const char* data) {
std::string result;
while (*data) {
char c = *data++;
@@ -72,11 +72,11 @@
return result;
}
-std::string WebParamsEncode(WebParamList const& params,
+std::string WebParamsEncode(const WebParamList& params,
bool encodeSpaceAsPlus) {
std::vector<std::string> pairs;
pairs.reserve(params.size());
- for (auto const& p : params) {
+ for (auto&& p : params) {
std::string key = UrlEncode(p.first.c_str(), encodeSpaceAsPlus);
std::string value = UrlEncode(p.second.c_str(), encodeSpaceAsPlus);
pairs.push_back(string_utils::Join('=', key, value));
@@ -85,7 +85,7 @@
return string_utils::Join('&', pairs);
}
-WebParamList WebParamsDecode(std::string const& data) {
+WebParamList WebParamsDecode(const std::string& data) {
WebParamList result;
std::vector<std::string> params = string_utils::Split(data, '&');
for (auto p : params) {
diff --git a/buffet/data_encoding.h b/buffet/data_encoding.h
index 7a4eda0..b7223bd 100644
--- a/buffet/data_encoding.h
+++ b/buffet/data_encoding.h
@@ -16,28 +16,28 @@
// Encode/escape string to be used in the query portion of a URL.
// If |encodeSpaceAsPlus| is set to true, spaces are encoded as '+' instead
// of "%20"
-std::string UrlEncode(char const* data, bool encodeSpaceAsPlus);
+std::string UrlEncode(const char* data, bool encodeSpaceAsPlus);
-inline std::string UrlEncode(char const* data) {
+inline std::string UrlEncode(const char* data) {
return UrlEncode(data, true);
}
// Decodes/unescapes a URL. Replaces all %XX sequences with actual characters.
// Also replaces '+' with spaces.
-std::string UrlDecode(char const* data);
+std::string UrlDecode(const char* data);
// Converts a list of key-value pairs into a string compatible with
// 'application/x-www-form-urlencoded' content encoding.
-std::string WebParamsEncode(WebParamList const& params, bool encodeSpaceAsPlus);
+std::string WebParamsEncode(const WebParamList& params, bool encodeSpaceAsPlus);
-inline std::string WebParamsEncode(WebParamList const& params) {
+inline std::string WebParamsEncode(const WebParamList& params) {
return WebParamsEncode(params, true);
}
// Parses a string of '&'-delimited key-value pairs (separated by '=') and
// encoded in a way compatible with 'application/x-www-form-urlencoded'
// content encoding.
-WebParamList WebParamsDecode(std::string const& data);
+WebParamList WebParamsDecode(const std::string& data);
} // namespace data_encoding
} // namespace chromeos
diff --git a/buffet/http_request.cc b/buffet/http_request.cc
index 3e9ec71..db1ecb9 100644
--- a/buffet/http_request.cc
+++ b/buffet/http_request.cc
@@ -98,11 +98,11 @@
//**************************************************************************
//********************** Request Class **********************
//**************************************************************************
-Request::Request(std::string const& url, char const* method) :
+Request::Request(const std::string& url, const char* method) :
transport_(new curl::Transport(url, method)) {
}
-Request::Request(std::string const& url) :
+Request::Request(const std::string& url) :
transport_(new curl::Transport(url, nullptr)) {
}
@@ -133,7 +133,7 @@
return std::unique_ptr<Response>();
}
-void Request::SetAccept(char const* accept_mime_types) {
+void Request::SetAccept(const char* accept_mime_types) {
if (transport_)
transport_->SetAccept(accept_mime_types);
}
@@ -146,7 +146,7 @@
return transport_ ? transport_->GetRequestURL() : std::string();
}
-void Request::SetContentType(char const* contentType) {
+void Request::SetContentType(const char* contentType) {
if (transport_)
transport_->SetContentType(contentType);
}
@@ -155,21 +155,21 @@
return transport_ ? transport_->GetContentType() : std::string();
}
-void Request::AddHeader(char const* header, char const* value) {
+void Request::AddHeader(const char* header, const char* value) {
if (transport_)
transport_->AddHeader(header, value);
}
-void Request::AddHeaders(HeaderList const& headers) {
+void Request::AddHeaders(const HeaderList& headers) {
for (auto&& pair : headers)
AddHeader(pair.first.c_str(), pair.second.c_str());
}
-bool Request::AddRequestBody(void const* data, size_t size) {
+bool Request::AddRequestBody(const void* data, size_t size) {
return transport_ && transport_->AddRequestBody(data, size);
}
-void Request::SetMethod(char const* method) {
+void Request::SetMethod(const char* method) {
if (transport_)
transport_->SetMethod(method);
}
@@ -178,7 +178,7 @@
return transport_ ? transport_->GetMethod() : std::string();
}
-void Request::SetReferer(char const* referer) {
+void Request::SetReferer(const char* referer) {
if (transport_)
transport_->SetReferer(referer);
}
@@ -187,7 +187,7 @@
return transport_ ? transport_->GetReferer() : std::string();
}
-void Request::SetUserAgent(char const* user_agent) {
+void Request::SetUserAgent(const char* user_agent) {
if (transport_)
transport_->SetUserAgent(user_agent);
}
@@ -249,14 +249,14 @@
std::string Response::GetDataAsString() const {
if (transport_) {
auto data = transport_->GetResponseData();
- char const* data_buf = reinterpret_cast<char const*>(data.data());
+ const char* data_buf = reinterpret_cast<const char*>(data.data());
return std::string(data_buf, data_buf + data.size());
}
return std::string();
}
-std::string Response::GetHeader(char const* header_name) const {
+std::string Response::GetHeader(const char* header_name) const {
if (transport_)
return transport_->GetResponseHeader(header_name);
diff --git a/buffet/http_request.h b/buffet/http_request.h
index fcdc9bd..185c84e 100644
--- a/buffet/http_request.h
+++ b/buffet/http_request.h
@@ -210,30 +210,30 @@
// to send the request to. Optional |method| is the HTTP request verb. If
// omitted, "GET" is used.
// Uses the default libcurl-based implementation of TransportInterface
- Request(std::string const& url, char const* method);
- Request(std::string const& url);
+ Request(const std::string& url, const char* method);
+ Request(const std::string& url);
// Custom constructor that allows non-default implementations
// of TransportInterface to be used.
Request(std::shared_ptr<TransportInterface> transport);
// Gets/Sets "Accept:" header value. The default value is "*/*" if not set.
- void SetAccept(char const* accept_mime_types);
+ void SetAccept(const char* accept_mime_types);
std::string GetAccept() const;
// Gets/Sets "Content-Type:" header value
- void SetContentType(char const* content_type);
+ void SetContentType(const char* content_type);
std::string GetContentType() const;
// Adds additional HTTP request header
- void AddHeader(char const* header, char const* value);
- void AddHeaders(HeaderList const& headers);
+ void AddHeader(const char* header, const char* value);
+ void AddHeaders(const HeaderList& headers);
// Removes HTTP request header
- void RemoveHeader(char const* header);
+ void RemoveHeader(const char* header);
// Adds a request body. This is not to be used with GET method
- bool AddRequestBody(void const* data, size_t size);
+ bool AddRequestBody(const void* data, size_t size);
// Makes a request for a subrange of data. Specifies a partial range with
// either from beginning of the data to the specified offset (if |bytes| is
@@ -248,18 +248,18 @@
void AddRange(uint64_t from_byte, uint64_t to_byte);
// Gets/Sets an HTTP request verb to be used with request
- void SetMethod(char const* method);
+ void SetMethod(const char* method);
std::string GetMethod() const;
// Returns the request URL
std::string GetRequestURL() const;
// Gets/Sets a request referer URL (sent as "Referer:" request header).
- void SetReferer(char const* referer);
+ void SetReferer(const char* referer);
std::string GetReferer() const;
// Gets/Sets a user agent string (sent as "User-Agent:" request header).
- void SetUserAgent(char const* user_agent);
+ void SetUserAgent(const char* user_agent);
std::string GetUserAgent() const;
// Sends the request to the server and returns the response object.
@@ -305,7 +305,7 @@
std::string GetDataAsString() const;
// Returns a value of a given response HTTP header.
- std::string GetHeader(char const* header_name) const;
+ std::string GetHeader(const char* header_name) const;
private:
std::shared_ptr<TransportInterface> transport_;
diff --git a/buffet/http_transport_curl.cc b/buffet/http_transport_curl.cc
index 6cb9c16..2a9c228 100644
--- a/buffet/http_transport_curl.cc
+++ b/buffet/http_transport_curl.cc
@@ -52,7 +52,7 @@
}
#endif
-Transport::Transport(std::string const& url, char const* method) :
+Transport::Transport(const std::string& url, const char* method) :
request_url_(url),
method_(method ? method : request_type::kGet) {
stage_ = Stage::initialized;
@@ -106,15 +106,15 @@
return headers;
}
-void Transport::AddHeader(char const* header, char const* value) {
+void Transport::AddHeader(const char* header, const char* value) {
headers_[header] = value;
}
-void Transport::RemoveHeader(char const* header) {
+void Transport::RemoveHeader(const char* header) {
AddHeader(header, "");
}
-bool Transport::AddRequestBody(void const* data, size_t size) {
+bool Transport::AddRequestBody(const void* data, size_t size) {
if (size == 0)
return true;
@@ -123,7 +123,7 @@
return false;
}
- unsigned char const* data_ptr = reinterpret_cast<unsigned char const*>(data);
+ const unsigned char* data_ptr = reinterpret_cast<const unsigned char*>(data);
request_data_.insert(request_data_.end(), data_ptr, data_ptr + size);
return true;
}
@@ -187,8 +187,8 @@
VLOG_IF(2, !request_data_.empty()) << "Request data ("
<< request_data_.size() << "): "
- << std::string(reinterpret_cast<char const*>(request_data_.data()),
- request_data_.size());
+ << std::string(reinterpret_cast<const char*>(request_data_.data()),
+ request_data_.size());
// Setup HTTP response data.
if (method_ != request_type::kHead) {
@@ -234,7 +234,7 @@
LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
<< GetResponseStatusText() << ")";
VLOG(2) << "Response data (" << response_data_.size() << "): "
- << std::string(reinterpret_cast<char const*>(response_data_.data()),
+ << std::string(reinterpret_cast<const char*>(response_data_.data()),
response_data_.size());
}
return (ret == CURLE_OK);
@@ -248,12 +248,12 @@
return status_code;
}
-std::string Transport::GetResponseHeader(char const* headerName) const {
+std::string Transport::GetResponseHeader(const char* headerName) const {
auto p = headers_.find(headerName);
return p != headers_.end() ? p->second : std::string();
}
-std::vector<unsigned char> const& Transport::GetResponseData() const {
+const std::vector<unsigned char>& Transport::GetResponseData() const {
return response_data_;
}
diff --git a/buffet/http_transport_curl.h b/buffet/http_transport_curl.h
index 5ef533e..9778b94 100644
--- a/buffet/http_transport_curl.h
+++ b/buffet/http_transport_curl.h
@@ -26,7 +26,7 @@
// schema, host address, resource path as well as optional query parameters
// and/or user name/password. |method| is one of HTTP request verbs such as
// "GET", "POST", etc. If nullptr is specified, "GET" is assumed.
- Transport(std::string const& url, char const* method);
+ Transport(const std::string& url, const char* method);
~Transport();
// Returns the current request/response stage.
@@ -37,7 +37,7 @@
virtual void AddRange(uint64_t from_byte, uint64_t to_byte) override;
// Implementation of Request::SetAccept/Request::GetAccept.
- virtual void SetAccept(char const* acceptMimeTypes) override {
+ virtual void SetAccept(const char* acceptMimeTypes) override {
accept_ = acceptMimeTypes;
}
virtual std::string GetAccept() const override;
@@ -46,30 +46,30 @@
virtual std::string GetRequestURL() const override { return request_url_; }
// Implementation of Request::SetContentType/Request::GetContentType.
- virtual void SetContentType(char const* content_type) override {
+ virtual void SetContentType(const char* content_type) override {
content_type_ = content_type;
}
virtual std::string GetContentType() const override { return content_type_; }
// Implementation of Request::AddHeader.
- virtual void AddHeader(char const* header, char const* value) override;
+ virtual void AddHeader(const char* header, const char* value) override;
// Implementation of Request::RemoveHeader.
- virtual void RemoveHeader(char const* header) override;
+ virtual void RemoveHeader(const char* header) override;
// Implementation of Request::AddRequestBody.
- virtual bool AddRequestBody(void const* data, size_t size) override;
+ virtual bool AddRequestBody(const void* data, size_t size) override;
// Implementation of Request::SetMethod/Request::GetMethod.
- virtual void SetMethod(char const* method) override { method_ = method; }
+ virtual void SetMethod(const char* method) override { method_ = method; }
virtual std::string GetMethod() const override { return method_; }
// Implementation of Request::SetReferer/Request::GetReferer.
- virtual void SetReferer(char const* referer) override { referer_ = referer; }
+ virtual void SetReferer(const char* referer) override { referer_ = referer; }
virtual std::string GetReferer() const override { return referer_; }
// Implementation of Request::SetUserAgent/Request::GetUserAgent.
- virtual void SetUserAgent(char const* user_agent) override {
+ virtual void SetUserAgent(const char* user_agent) override {
user_agent_ = user_agent;
}
virtual std::string GetUserAgent() const override { return user_agent_; }
@@ -86,10 +86,10 @@
}
// Implementation of Response::GetHeader.
- virtual std::string GetResponseHeader(char const* header_name) const override;
+ virtual std::string GetResponseHeader(const char* header_name) const override;
// Implementation of Response::GetData.
- virtual std::vector<unsigned char> const& GetResponseData() const override;
+ virtual const std::vector<unsigned char>& GetResponseData() const override;
// Implementation of Response::GetErrorMessage.
virtual std::string GetErrorMessage() const override { return error_; }
diff --git a/buffet/http_utils.cc b/buffet/http_utils.cc
index 9db6b1c..7529796 100644
--- a/buffet/http_utils.cc
+++ b/buffet/http_utils.cc
@@ -16,25 +16,25 @@
namespace chromeos {
namespace http {
-std::unique_ptr<Response> Get(std::string const& url) {
+std::unique_ptr<Response> Get(const std::string& url) {
Request request(url);
return request.GetResponse();
}
-std::string GetAsString(std::string const& url) {
+std::string GetAsString(const std::string& url) {
auto resp = Get(url);
return resp ? resp->GetDataAsString() : std::string();
}
-std::unique_ptr<Response> Head(std::string const& url) {
+std::unique_ptr<Response> Head(const std::string& url) {
Request request(url, request_type::kHead);
return request.GetResponse();
}
-std::unique_ptr<Response> PostText(std::string const& url,
- char const* data,
- char const* mime_type,
- HeaderList const& headers) {
+std::unique_ptr<Response> PostText(const std::string& url,
+ const char* data,
+ const char* mime_type,
+ const HeaderList& headers) {
if (mime_type == nullptr) {
mime_type = chromeos::mime::application::kWwwFormUrlEncoded;
}
@@ -42,12 +42,12 @@
return PostBinary(url, data, strlen(data), mime_type, headers);
}
-std::unique_ptr<Response> SendRequest(char const* method,
- std::string const& url,
- void const* data,
+std::unique_ptr<Response> SendRequest(const char * method,
+ const std::string& url,
+ const void* data,
size_t data_size,
- char const* mime_type,
- HeaderList const& headers) {
+ const char* mime_type,
+ const HeaderList& headers) {
Request request(url, method);
request.AddHeaders(headers);
if (data_size > 0) {
@@ -60,25 +60,25 @@
return request.GetResponse();
}
-std::unique_ptr<Response> PostBinary(std::string const& url, void const* data,
- size_t data_size, char const* mime_type,
- HeaderList const& headers) {
+std::unique_ptr<Response> PostBinary(const std::string & url, const void* data,
+ size_t data_size, const char* mime_type,
+ const HeaderList& headers) {
return SendRequest(request_type::kPost, url,
data, data_size, mime_type, headers);
}
-std::unique_ptr<Response> PostFormData(std::string const& url,
- FormFieldList const& data,
- HeaderList const& headers) {
+std::unique_ptr<Response> PostFormData(const std::string& url,
+ const FormFieldList& data,
+ const HeaderList& headers) {
std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
chromeos::mime::application::kWwwFormUrlEncoded, headers);
}
-std::unique_ptr<Response> PostJson(std::string const& url,
- base::Value const* json,
- HeaderList const& headers) {
+std::unique_ptr<Response> PostJson(const std::string& url,
+ const base::Value* json,
+ const HeaderList& headers) {
std::string data;
if (json)
base::JSONWriter::Write(json, &data);
@@ -86,9 +86,9 @@
mime::application::kJson, headers);
}
-std::unique_ptr<Response> PatchJson(std::string const& url,
- base::Value const* json,
- HeaderList const& headers) {
+std::unique_ptr<Response> PatchJson(const std::string& url,
+ const base::Value* json,
+ const HeaderList& headers) {
std::string data;
if (json)
base::JSONWriter::Write(json, &data);
@@ -97,7 +97,7 @@
}
std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
- Response const* response, int* status_code, std::string* error_message) {
+ const Response* response, int* status_code, std::string* error_message) {
std::unique_ptr<base::DictionaryValue> dict;
if (response) {
if (status_code)
diff --git a/buffet/http_utils.h b/buffet/http_utils.h
index 724f118..91e12b5 100644
--- a/buffet/http_utils.h
+++ b/buffet/http_utils.h
@@ -29,45 +29,45 @@
// returned data and additional information (such as returned HTTP headers)
// can be obtained from the returned Response object.
// If data MIME type is not specified, "application/octet-stream" is assumed.
-std::unique_ptr<Response> SendRequest(char const* method,
- std::string const& url,
- void const* data,
+std::unique_ptr<Response> SendRequest(const char* method,
+ const std::string& url,
+ const void* data,
size_t data_size,
- char const* mime_type,
- HeaderList const& headers);
+ const char* mime_type,
+ const HeaderList& headers);
// Performs a simple GET request and returns the data as a string.
-std::string GetAsString(std::string const& url);
+std::string GetAsString(const std::string& url);
// Performs a GET request. Success status, returned data and additional
// information (such as returned HTTP headers) can be obtained from
// the returned Response object.
-std::unique_ptr<Response> Get(std::string const& url);
+std::unique_ptr<Response> Get(const std::string& url);
// Performs a HEAD request. Success status and additional
// information (such as returned HTTP headers) can be obtained from
// the returned Response object.
-std::unique_ptr<Response> Head(std::string const& url);
+std::unique_ptr<Response> Head(const std::string& url);
// Performs a POST request with binary data. Success status, returned data
// and additional information (such as returned HTTP headers) can be obtained
// from the returned Response object.
// If data MIME type is not specified, "application/octet-stream" is assumed
-std::unique_ptr<Response> PostBinary(std::string const& url,
- void const* data,
+std::unique_ptr<Response> PostBinary(const std::string& url,
+ const void* data,
size_t data_size,
- char const* mime_type,
- HeaderList const& headers);
+ const char* mime_type,
+ const HeaderList& headers);
-inline std::unique_ptr<Response> PostBinary(std::string const& url,
- void const* data,
+inline std::unique_ptr<Response> PostBinary(const std::string& url,
+ const void* data,
size_t data_size,
- char const* mime_type) {
+ const char* mime_type) {
return PostBinary(url, data, data_size, mime_type, HeaderList());
}
-inline std::unique_ptr<Response> PostBinary(std::string const& url,
- void const* data,
+inline std::unique_ptr<Response> PostBinary(const std::string& url,
+ const void* data,
size_t data_size) {
return PostBinary(url, data, data_size, nullptr);
}
@@ -77,19 +77,19 @@
// from the returned Response object.
// If data MIME type is not specified, "application/x-www-form-urlencoded"
// is assumed.
-std::unique_ptr<Response> PostText(std::string const& url,
- char const* data,
- char const* mime_type,
- HeaderList const& headers);
+std::unique_ptr<Response> PostText(const std::string& url,
+ const char* data,
+ const char* mime_type,
+ const HeaderList& headers);
-inline std::unique_ptr<Response> PostText(std::string const& url,
- char const* data,
- char const* mime_type) {
+inline std::unique_ptr<Response> PostText(const std::string& url,
+ const char* data,
+ const char* mime_type) {
return PostText(url, data, mime_type, HeaderList());
}
-inline std::unique_ptr<Response> PostText(std::string const& url,
- char const* data) {
+inline std::unique_ptr<Response> PostText(const std::string& url,
+ const char* data) {
return PostText(url, data, nullptr);
}
@@ -97,12 +97,12 @@
// and additional information (such as returned HTTP headers) can be obtained
// from the returned Response object. The form data is a list of key/value
// pairs. The data is posed as "application/x-www-form-urlencoded".
-std::unique_ptr<Response> PostFormData(std::string const& url,
- FormFieldList const& data,
- HeaderList const& headers);
+std::unique_ptr<Response> PostFormData(const std::string& url,
+ const FormFieldList& data,
+ const HeaderList& headers);
-inline std::unique_ptr<Response> PostFormData(std::string const& url,
- FormFieldList const& data) {
+inline std::unique_ptr<Response> PostFormData(const std::string& url,
+ const FormFieldList& data) {
return PostFormData(url, data, HeaderList());
}
@@ -110,12 +110,12 @@
// and additional information (such as returned HTTP headers) can be obtained
// from the returned Response object. If a JSON response is expected,
// use ParseJsonResponse() method on the returned Response object.
-std::unique_ptr<Response> PostJson(std::string const& url,
- base::Value const* json,
- HeaderList const& headers);
+std::unique_ptr<Response> PostJson(const std::string& url,
+ const base::Value* json,
+ const HeaderList& headers);
-inline std::unique_ptr<Response> PostJson(std::string const& url,
- base::Value const* json) {
+inline std::unique_ptr<Response> PostJson(const std::string& url,
+ const base::Value* json) {
return PostJson(url, json, HeaderList());
}
@@ -123,12 +123,12 @@
// and additional information (such as returned HTTP headers) can be obtained
// from the returned Response object. If a JSON response is expected,
// use ParseJsonResponse() method on the returned Response object.
-std::unique_ptr<Response> PatchJson(std::string const& url,
- base::Value const* json,
- HeaderList const& headers);
+std::unique_ptr<Response> PatchJson(const std::string& url,
+ const base::Value* json,
+ const HeaderList& headers);
-inline std::unique_ptr<Response> PatchJson(std::string const& url,
- base::Value const* json) {
+inline std::unique_ptr<Response> PatchJson(const std::string& url,
+ const base::Value* json) {
return PatchJson(url, json, HeaderList());
}
@@ -136,7 +136,7 @@
// Returns null if failed. Optional |error_message| can be passed in to
// get the extended error information as to why the parse failed.
std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
- Response const* response, int* status_code, std::string* error_message);
+ const Response* response, int* status_code, std::string* error_message);
} // namespace http
} // namespace chromeos
diff --git a/buffet/map_utils.h b/buffet/map_utils.h
index 676c558..c67fa3e 100644
--- a/buffet/map_utils.h
+++ b/buffet/map_utils.h
@@ -12,7 +12,7 @@
// Given an STL map returns a vector containing all keys from the map
template<typename T>
-std::vector<typename T::key_type> GetMapKeys(T const& map) {
+std::vector<typename T::key_type> GetMapKeys(const T& map) {
std::vector<typename T::key_type> keys;
keys.reserve(map.size());
for (auto&& pair : map)
@@ -22,7 +22,7 @@
// Given an STL map returns a vector containing all values from the map
template<typename T>
-std::vector<typename T::mapped_type> GetMapValues(T const& map) {
+std::vector<typename T::mapped_type> GetMapValues(const T& map) {
std::vector<typename T::mapped_type> values;
values.reserve(map.size());
for (auto&& pair : map)
@@ -33,7 +33,7 @@
// Given an STL map returns a vector of key-value pairs from the map
template<typename T>
std::vector<std::pair<typename T::key_type,
- typename T::mapped_type>> MapToVector(T const& map) {
+ typename T::mapped_type>> MapToVector(const T& map) {
std::vector<std::pair<typename T::key_type, typename T::mapped_type>> vector;
vector.reserve(map.size());
for (auto&& pair : map)
diff --git a/buffet/mime_utils.cc b/buffet/mime_utils.cc
index a4f29ca..c35d3c0 100644
--- a/buffet/mime_utils.cc
+++ b/buffet/mime_utils.cc
@@ -42,7 +42,7 @@
//***************************************************************************
//**************************** Utility Functions ****************************
//***************************************************************************
-static std::string EncodeParam(std::string const& param) {
+static std::string EncodeParam(const std::string& param) {
// If the string contains one of "tspecials" characters as
// specified in RFC 1521, enclose it in quotes.
if (param.find_first_of("()<>@,;:\\\"/[]?=") != std::string::npos) {
@@ -51,7 +51,7 @@
return param;
}
-static std::string DecodeParam(std::string const& param) {
+static std::string DecodeParam(const std::string& param) {
if (param.size() > 1 && param.front() == '"' && param.back() == '"') {
return param.substr(1, param.size() - 2);
}
@@ -62,7 +62,7 @@
//******************** Main MIME manipulation functions *********************
//***************************************************************************
-bool mime::Split(std::string const& mime_string,
+bool mime::Split(const std::string& mime_string,
std::string* type, std::string* subtype,
mime::Parameters* parameters) {
std::vector<std::string> parts = string_utils::Split(mime_string, ';');
@@ -84,7 +84,7 @@
return true;
}
-bool mime::Split(std::string const& mime_string,
+bool mime::Split(const std::string& mime_string,
std::string* type, std::string* subtype) {
std::string mime = mime::RemoveParameters(mime_string);
auto types = string_utils::SplitAtFirst(mime, '/');
@@ -98,28 +98,28 @@
return !types.first.empty() && !types.second.empty();
}
-std::string mime::Combine(std::string const& type, std::string const& subtype,
- mime::Parameters const& parameters) {
+std::string mime::Combine(const std::string& type, const std::string& subtype,
+ const mime::Parameters& parameters) {
std::vector<std::string> parts;
parts.push_back(string_utils::Join('/', type, subtype));
- for (std::pair<std::string, std::string> const& pair : parameters) {
+ for (auto&& pair : parameters) {
parts.push_back(string_utils::Join('=', pair.first,
EncodeParam(pair.second)));
}
return string_utils::Join("; ", parts);
}
-std::string mime::GetType(std::string const& mime_string) {
+std::string mime::GetType(const std::string& mime_string) {
std::string mime = mime::RemoveParameters(mime_string);
return string_utils::SplitAtFirst(mime, '/').first;
}
-std::string mime::GetSubtype(std::string const& mime_string) {
+std::string mime::GetSubtype(const std::string& mime_string) {
std::string mime = mime::RemoveParameters(mime_string);
return string_utils::SplitAtFirst(mime, '/').second;
}
-mime::Parameters mime::GetParameters(std::string const& mime_string) {
+mime::Parameters mime::GetParameters(const std::string& mime_string) {
std::string type;
std::string subtype;
mime::Parameters parameters;
@@ -130,23 +130,23 @@
return mime::Parameters();
}
-std::string mime::RemoveParameters(std::string const& mime_string) {
+std::string mime::RemoveParameters(const std::string& mime_string) {
return string_utils::SplitAtFirst(mime_string, ';').first;
}
-std::string mime::AppendParameter(std::string const& mime_string,
- std::string const& paramName,
- std::string const& paramValue) {
+std::string mime::AppendParameter(const std::string& mime_string,
+ const std::string& paramName,
+ const std::string& paramValue) {
std::string mime(mime_string);
mime += "; ";
mime += string_utils::Join('=', paramName, EncodeParam(paramValue));
return mime;
}
-std::string mime::GetParameterValue(std::string const& mime_string,
- std::string const& paramName) {
+std::string mime::GetParameterValue(const std::string& mime_string,
+ const std::string& paramName) {
mime::Parameters params = mime::GetParameters(mime_string);
- for(auto const& pair : params) {
+ for(auto&& pair : params) {
if (base::strcasecmp(pair.first.c_str(), paramName.c_str()) == 0)
return pair.second;
}
diff --git a/buffet/mime_utils.h b/buffet/mime_utils.h
index e1dc7da..31a7687 100644
--- a/buffet/mime_utils.h
+++ b/buffet/mime_utils.h
@@ -56,45 +56,45 @@
// Combine a MIME type, subtype and parameters into a MIME string.
// e.g. Combine("text", "plain", {{"charset", "utf-8"}}) will give:
// "text/plain; charset=utf-8"
-std::string Combine(std::string const& type, std::string const& subtype,
- Parameters const& parameters = Parameters());
+std::string Combine(const std::string& type, const std::string& subtype,
+ const Parameters& parameters = {});
// Splits a MIME string into type and subtype.
// "text/plain;charset=utf-8" => ("text", "plain")
-bool Split(std::string const& mime_string,
+bool Split(const std::string& mime_string,
std::string* type, std::string* subtype);
// Splits a MIME string into type, subtype, and parameters.
// "text/plain;charset=utf-8" => ("text", "plain", {{"charset","utf-8"}})
-bool Split(std::string const& mime_string,
+bool Split(const std::string& mime_string,
std::string* type, std::string* subtype, Parameters* parameters);
// Returns the MIME type from MIME string.
// "text/plain;charset=utf-8" => "text"
-std::string GetType(std::string const& mime_string);
+std::string GetType(const std::string& mime_string);
// Returns the MIME sub-type from MIME string.
// "text/plain;charset=utf-8" => "plain"
-std::string GetSubtype(std::string const& mime_string);
+std::string GetSubtype(const std::string& mime_string);
// Returns the MIME parameters from MIME string.
// "text/plain;charset=utf-8" => {{"charset","utf-8"}}
-Parameters GetParameters(std::string const& mime_string);
+Parameters GetParameters(const std::string& mime_string);
// Removes parameters from a MIME string
// "text/plain;charset=utf-8" => "text/plain"
-std::string RemoveParameters(std::string const& mime_string);
+std::string RemoveParameters(const std::string& mime_string);
// Appends a parameter to a MIME string.
// "text/plain" => "text/plain; charset=utf-8"
-std::string AppendParameter(std::string const& mime_string,
- std::string const& paramName,
- std::string const& paramValue);
+std::string AppendParameter(const std::string& mime_string,
+ const std::string& paramName,
+ const std::string& paramValue);
// Returns the value of a parameter on a MIME string (empty string if missing).
// ("text/plain;charset=utf-8","charset") => "utf-8"
-std::string GetParameterValue(std::string const& mime_string,
- std::string const& paramName);
+std::string GetParameterValue(const std::string& mime_string,
+ const std::string& paramName);
} // namespace mime
} // namespace chromeos
diff --git a/buffet/string_utils.cc b/buffet/string_utils.cc
index 49a7d84..c5d06eb 100644
--- a/buffet/string_utils.cc
+++ b/buffet/string_utils.cc
@@ -11,7 +11,7 @@
namespace chromeos {
namespace string_utils {
-std::vector<std::string> Split(std::string const& str,
+std::vector<std::string> Split(const std::string& str,
char delimiter,
bool trim_whitespaces,
bool purge_empty_strings) {
@@ -19,9 +19,9 @@
if (delimiter == 0)
return tokens;
- char const* sz = str.c_str();
+ const char* sz = str.c_str();
if (sz) {
- char const* szNext = strchr(sz, delimiter);
+ const char* szNext = strchr(sz, delimiter);
while (szNext) {
if (szNext != sz || !purge_empty_strings)
tokens.emplace_back(sz, szNext - sz);
@@ -40,15 +40,15 @@
return tokens;
}
-std::pair<std::string, std::string> SplitAtFirst(std::string const& str,
+std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
char delimiter,
bool trim_whitespaces) {
std::pair<std::string, std::string> pair;
if (delimiter == 0)
return pair;
- char const* sz = str.c_str();
- char const* szNext = strchr(sz, delimiter);
+ const char* sz = str.c_str();
+ const char* szNext = strchr(sz, delimiter);
if (szNext) {
pair.first = std::string(sz, szNext);
pair.second = std::string(szNext + 1);
@@ -64,22 +64,22 @@
return pair;
}
-std::string Join(char delimiter, std::vector<std::string> const& strings) {
+std::string Join(char delimiter, const std::vector<std::string>& strings) {
return JoinString(strings, delimiter);
}
-std::string Join(std::string const& delimiter,
- std::vector<std::string> const& strings) {
+std::string Join(const std::string& delimiter,
+ const std::vector<std::string>& strings) {
return JoinString(strings, delimiter);
}
std::string Join(char delimiter,
- std::string const& str1, std::string const& str2) {
+ const std::string& str1, const std::string& str2) {
return str1 + delimiter + str2;
}
-std::string Join(std::string const& delimiter,
- std::string const& str1, std::string const& str2) {
+std::string Join(const std::string& delimiter,
+ const std::string& str1, const std::string& str2) {
return str1 + delimiter + str2;
}
diff --git a/buffet/string_utils.h b/buffet/string_utils.h
index bad62f3..3fad204 100644
--- a/buffet/string_utils.h
+++ b/buffet/string_utils.h
@@ -15,25 +15,25 @@
// of original elements of the list.
// By default, empty elements from the original string are omitted and
// each element has all whitespaces trimmed off.
-std::vector<std::string> Split(std::string const& str,
+std::vector<std::string> Split(const std::string& str,
char delimiter,
bool trim_whitespaces = true,
bool purge_empty_strings = true);
// Splits the string into two pieces at the first position of the specified
// delimiter. By default, each part has all whitespaces trimmed off.
-std::pair<std::string, std::string> SplitAtFirst(std::string const& str,
+std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
char delimiter,
bool trim_whitespaces = true);
// Joins an array of strings into a single string separated by |delimiter|.
-std::string Join(char delimiter, std::vector<std::string> const& strings);
-std::string Join(std::string const& delimiter,
- std::vector<std::string> const& strings);
+std::string Join(char delimiter, const std::vector<std::string>& strings);
+std::string Join(const std::string& delimiter,
+ const std::vector<std::string>& strings);
std::string Join(char delimiter,
- std::string const& str1, std::string const& str2);
-std::string Join(std::string const& delimiter,
- std::string const& str1, std::string const& str2);
+ const std::string& str1, const std::string& str2);
+std::string Join(const std::string& delimiter,
+ const std::string& str1, const std::string& str2);
} // namespace string_utils
} // namespace chromeos
diff --git a/buffet/transport_interface.h b/buffet/transport_interface.h
index 0f9363b..e833239 100644
--- a/buffet/transport_interface.h
+++ b/buffet/transport_interface.h
@@ -37,26 +37,26 @@
virtual void AddRange(int64_t bytes) = 0;
virtual void AddRange(uint64_t from_byte, uint64_t to_byte) = 0;
- virtual void SetAccept(char const* accept_mime_types) = 0;
+ virtual void SetAccept(const char* accept_mime_types) = 0;
virtual std::string GetAccept() const = 0;
virtual std::string GetRequestURL() const = 0;
- virtual void SetContentType(char const* content_type) = 0;
+ virtual void SetContentType(const char* content_type) = 0;
virtual std::string GetContentType() const = 0;
- virtual void AddHeader(char const* header, char const* value) = 0;
- virtual void RemoveHeader(char const* header) = 0;
+ virtual void AddHeader(const char* header, const char* value) = 0;
+ virtual void RemoveHeader(const char* header) = 0;
- virtual bool AddRequestBody(void const* data, size_t size) = 0;
+ virtual bool AddRequestBody(const void* data, size_t size) = 0;
- virtual void SetMethod(char const* method) = 0;
+ virtual void SetMethod(const char* method) = 0;
virtual std::string GetMethod() const = 0;
- virtual void SetReferer(char const* referer) = 0;
+ virtual void SetReferer(const char* referer) = 0;
virtual std::string GetReferer() const = 0;
- virtual void SetUserAgent(char const* user_agent) = 0;
+ virtual void SetUserAgent(const char* user_agent) = 0;
virtual std::string GetUserAgent() const = 0;
virtual bool Perform() = 0;
@@ -64,8 +64,8 @@
virtual int GetResponseStatusCode() const = 0;
virtual std::string GetResponseStatusText() const = 0;
- virtual std::string GetResponseHeader(char const* header_name) const = 0;
- virtual std::vector<unsigned char> const& GetResponseData() const = 0;
+ virtual std::string GetResponseHeader(const char* header_name) const = 0;
+ virtual const std::vector<unsigned char>& GetResponseData() const = 0;
virtual std::string GetErrorMessage() const = 0;
virtual void Close() = 0;
