You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by da...@apache.org on 2016/01/15 21:00:06 UTC
[1/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Repository: incubator-kudu
Updated Branches:
refs/heads/master 3eafca50f -> 9daafa5e7
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tablet_service.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_service.cc b/src/kudu/tserver/tablet_service.cc
index 5241d2b..4bcd25a 100644
--- a/src/kudu/tserver/tablet_service.cc
+++ b/src/kudu/tserver/tablet_service.cc
@@ -1071,7 +1071,7 @@ void TabletServiceImpl::ListTablets(const ListTabletsRequestPB* req,
vector<scoped_refptr<TabletPeer> > peers;
server_->tablet_manager()->GetTabletPeers(&peers);
RepeatedPtrField<StatusAndSchemaPB>* peer_status = resp->mutable_status_and_schema();
- BOOST_FOREACH(const scoped_refptr<TabletPeer>& peer, peers) {
+ for (const scoped_refptr<TabletPeer>& peer : peers) {
StatusAndSchemaPB* status = peer_status->Add();
peer->GetTabletStatusPB(status->mutable_tablet_status());
CHECK_OK(SchemaToPB(peer->status_listener()->schema(),
@@ -1238,7 +1238,7 @@ static Status SetupScanSpec(const NewScanRequestPB& scan_pb,
unordered_set<string> missing_col_names;
// First the column range predicates.
- BOOST_FOREACH(const ColumnRangePredicatePB& pred_pb, scan_pb.range_predicates()) {
+ for (const ColumnRangePredicatePB& pred_pb : scan_pb.range_predicates()) {
if (!pred_pb.has_lower_bound() && !pred_pb.has_upper_bound()) {
return Status::InvalidArgument(
string("Invalid predicate ") + pred_pb.ShortDebugString() +
@@ -1369,10 +1369,10 @@ Status TabletServiceImpl::HandleNewScanRequest(TabletPeer* tablet_peer,
// sure to set whether the column is a key column appropriately.
SchemaBuilder projection_builder;
vector<ColumnSchema> projection_columns = projection.columns();
- BOOST_FOREACH(const ColumnSchema& col, missing_cols) {
+ for (const ColumnSchema& col : missing_cols) {
projection_columns.push_back(col);
}
- BOOST_FOREACH(const ColumnSchema& col, projection_columns) {
+ for (const ColumnSchema& col : projection_columns) {
CHECK_OK(projection_builder.AddColumn(col, tablet_schema.is_key_column(col.name())));
}
projection = projection_builder.BuildWithoutIds();
@@ -1575,7 +1575,7 @@ Status TabletServiceImpl::HandleContinueScanRequest(const ScanRequestPB* req,
vector<IteratorStats> stats_by_col;
scanner->GetIteratorStats(&stats_by_col);
IteratorStats total_stats;
- BOOST_FOREACH(const IteratorStats& stats, stats_by_col) {
+ for (const IteratorStats& stats : stats_by_col) {
total_stats.AddStats(stats);
}
IteratorStats delta_stats = total_stats;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/ts_tablet_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/ts_tablet_manager-test.cc b/src/kudu/tserver/ts_tablet_manager-test.cc
index c99f3aa..ea1876f 100644
--- a/src/kudu/tserver/ts_tablet_manager-test.cc
+++ b/src/kudu/tserver/ts_tablet_manager-test.cc
@@ -129,7 +129,7 @@ static void AssertReportHasUpdatedTablet(const TabletReportPB& report,
const string& tablet_id) {
ASSERT_GE(report.updated_tablets_size(), 0);
bool found_tablet = false;
- BOOST_FOREACH(ReportedTabletPB reported_tablet, report.updated_tablets()) {
+ for (ReportedTabletPB reported_tablet : report.updated_tablets()) {
if (reported_tablet.tablet_id() == tablet_id) {
found_tablet = true;
ASSERT_TRUE(reported_tablet.has_committed_consensus_state());
@@ -212,7 +212,7 @@ TEST_F(TsTabletManagerTest, TestTabletReports) {
tablet_manager_->GenerateIncrementalTabletReport(&report);
ASSERT_TRUE(report.is_incremental()) << report.ShortDebugString();
ASSERT_MONOTONIC_REPORT_SEQNO(&seqno, report) << report.ShortDebugString();
- BOOST_FOREACH(const ReportedTabletPB& reported_tablet, report.updated_tablets()) {
+ for (const ReportedTabletPB& reported_tablet : report.updated_tablets()) {
if (reported_tablet.tablet_id() == "tablet-2") {
found_tablet_2 = true;
break;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/ts_tablet_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/ts_tablet_manager.cc b/src/kudu/tserver/ts_tablet_manager.cc
index 409d8af..e4f5ce9 100644
--- a/src/kudu/tserver/ts_tablet_manager.cc
+++ b/src/kudu/tserver/ts_tablet_manager.cc
@@ -190,7 +190,7 @@ Status TSTabletManager::Init() {
// First, load all of the tablet metadata. We do this before we start
// submitting the actual OpenTablet() tasks so that we don't have to compete
// for disk resources, etc, with bootstrap processes and running tablets.
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
scoped_refptr<TabletMetadata> meta;
RETURN_NOT_OK_PREPEND(OpenTabletMeta(tablet_id, &meta),
"Failed to open tablet metadata for tablet: " + tablet_id);
@@ -202,7 +202,7 @@ Status TSTabletManager::Init() {
}
// Now submit the "Open" task for each.
- BOOST_FOREACH(const scoped_refptr<TabletMetadata>& meta, metas) {
+ for (const scoped_refptr<TabletMetadata>& meta : metas) {
scoped_refptr<TransitionInProgressDeleter> deleter;
{
boost::lock_guard<rw_spinlock> lock(lock_);
@@ -230,7 +230,7 @@ Status TSTabletManager::WaitForAllBootstrapsToFinish() {
Status s = Status::OK();
boost::shared_lock<rw_spinlock> shared_lock(lock_);
- BOOST_FOREACH(const TabletMap::value_type& entry, tablet_map_) {
+ for (const TabletMap::value_type& entry : tablet_map_) {
if (entry.second->state() == tablet::FAILED) {
if (s.ok()) {
s = entry.second->error();
@@ -704,7 +704,7 @@ void TSTabletManager::Shutdown() {
vector<scoped_refptr<TabletPeer> > peers_to_shutdown;
GetTabletPeers(&peers_to_shutdown);
- BOOST_FOREACH(const scoped_refptr<TabletPeer>& peer, peers_to_shutdown) {
+ for (const scoped_refptr<TabletPeer>& peer : peers_to_shutdown) {
peer->Shutdown();
}
@@ -837,7 +837,7 @@ void TSTabletManager::GenerateIncrementalTabletReport(TabletReportPB* report) {
report->Clear();
report->set_sequence_number(next_report_seq_++);
report->set_is_incremental(true);
- BOOST_FOREACH(const DirtyMap::value_type& dirty_entry, dirty_tablets_) {
+ for (const DirtyMap::value_type& dirty_entry : dirty_tablets_) {
const string& tablet_id = dirty_entry.first;
scoped_refptr<tablet::TabletPeer>* tablet_peer = FindOrNull(tablet_map_, tablet_id);
if (tablet_peer) {
@@ -855,7 +855,7 @@ void TSTabletManager::GenerateFullTabletReport(TabletReportPB* report) {
report->Clear();
report->set_is_incremental(false);
report->set_sequence_number(next_report_seq_++);
- BOOST_FOREACH(const TabletMap::value_type& entry, tablet_map_) {
+ for (const TabletMap::value_type& entry : tablet_map_) {
CreateReportedTabletPB(entry.first, entry.second, report->add_updated_tablets());
}
dirty_tablets_.clear();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tserver-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tserver-path-handlers.cc b/src/kudu/tserver/tserver-path-handlers.cc
index a66d0e7..d5df150 100644
--- a/src/kudu/tserver/tserver-path-handlers.cc
+++ b/src/kudu/tserver/tserver-path-handlers.cc
@@ -123,7 +123,7 @@ void TabletServerPathHandlers::HandleTransactionsPage(const Webserver::WebReques
"Total time in-flight</th><th>Description</th></tr>\n";
}
- BOOST_FOREACH(const scoped_refptr<TabletPeer>& peer, peers) {
+ for (const scoped_refptr<TabletPeer>& peer : peers) {
vector<TransactionStatusPB> inflight;
if (peer->tablet() == NULL) {
@@ -131,7 +131,7 @@ void TabletServerPathHandlers::HandleTransactionsPage(const Webserver::WebReques
}
peer->GetInFlightTransactions(trace_type, &inflight);
- BOOST_FOREACH(const TransactionStatusPB& inflight_tx, inflight) {
+ for (const TransactionStatusPB& inflight_tx : inflight) {
string total_time_str = Substitute("$0 us.", inflight_tx.running_for_micros());
string description;
if (trace_type == Transaction::TRACE_TXNS) {
@@ -190,7 +190,7 @@ void TabletServerPathHandlers::HandleTabletsPage(const Webserver::WebRequest& re
*output << " <tr><th>Table name</th><th>Tablet ID</th>"
"<th>Partition</th>"
"<th>State</th><th>On-disk size</th><th>RaftConfig</th><th>Last status</th></tr>\n";
- BOOST_FOREACH(const scoped_refptr<TabletPeer>& peer, peers) {
+ for (const scoped_refptr<TabletPeer>& peer : peers) {
TabletStatusPB status;
peer->GetTabletStatusPB(&status);
string id = status.tablet_id();
@@ -245,7 +245,7 @@ string TabletServerPathHandlers::ConsensusStatePBToHtml(const ConsensusStatePB&
std::vector<RaftPeerPB> sorted_peers;
sorted_peers.assign(cstate.config().peers().begin(), cstate.config().peers().end());
std::sort(sorted_peers.begin(), sorted_peers.end(), &CompareByMemberType);
- BOOST_FOREACH(const RaftPeerPB& peer, sorted_peers) {
+ for (const RaftPeerPB& peer : sorted_peers) {
string peer_addr_or_uuid =
peer.has_last_known_addr() ? peer.last_known_addr().host() : peer.permanent_uuid();
peer_addr_or_uuid = EscapeForHtmlToString(peer_addr_or_uuid);
@@ -401,7 +401,7 @@ void TabletServerPathHandlers::HandleScansPage(const Webserver::WebRequest& req,
vector<SharedScanner> scanners;
tserver_->scanner_manager()->ListScanners(&scanners);
- BOOST_FOREACH(const SharedScanner& scanner, scanners) {
+ for (const SharedScanner& scanner : scanners) {
*output << ScannerToHtml(*scanner);
}
*output << "</table>";
@@ -444,7 +444,7 @@ string TabletServerPathHandlers::ScannerToHtml(const Scanner& scanner) const {
range_pred_str = EncodedKey::RangeToString(spec.lower_bound_key(),
spec.exclusive_upper_bound_key());
}
- BOOST_FOREACH(const ColumnRangePredicate& pred, scanner.spec().predicates()) {
+ for (const ColumnRangePredicate& pred : scanner.spec().predicates()) {
other_preds.push_back(pred.ToString());
}
string other_pred_str = JoinStrings(other_preds, "\n");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/twitter-demo/insert_consumer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/twitter-demo/insert_consumer.cc b/src/kudu/twitter-demo/insert_consumer.cc
index 7f001c3..370b8cc 100644
--- a/src/kudu/twitter-demo/insert_consumer.cc
+++ b/src/kudu/twitter-demo/insert_consumer.cc
@@ -17,7 +17,6 @@
#include "kudu/twitter-demo/insert_consumer.h"
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <glog/logging.h>
#include <string>
@@ -104,7 +103,7 @@ void InsertConsumer::BatchFinished(const Status& s) {
vector<client::KuduError*> errors;
ElementDeleter d(&errors);
session_->GetPendingErrors(&errors, &overflow);
- BOOST_FOREACH(const client::KuduError* error, errors) {
+ for (const client::KuduError* error : errors) {
LOG(WARNING) << "Failed to insert row " << error->failed_op().ToString()
<< ": " << error->status().ToString();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/twitter-demo/oauth.cc
----------------------------------------------------------------------
diff --git a/src/kudu/twitter-demo/oauth.cc b/src/kudu/twitter-demo/oauth.cc
index 3ff2879..efffcb4 100644
--- a/src/kudu/twitter-demo/oauth.cc
+++ b/src/kudu/twitter-demo/oauth.cc
@@ -20,7 +20,6 @@
#include <algorithm>
#include <vector>
#include <boost/lexical_cast.hpp>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
extern "C" {
#include <oauth.h>
@@ -85,7 +84,7 @@ string OAuthRequest::SignatureBaseString() const {
string kvpairs;
bool first = true;
- BOOST_FOREACH(const StringPair& p, sorted_pairs) {
+ for (const StringPair& p : sorted_pairs) {
if (!first) {
kvpairs.append("&");
}
@@ -114,7 +113,7 @@ string OAuthRequest::AuthHeader(const string& consumer_secret,
string sig = Signature(consumer_secret, token_secret);
string ret = "Authorization: OAuth realm=\"\"";
- BOOST_FOREACH(const StringPair& p, kv_pairs_) {
+ for (const StringPair& p : kv_pairs_) {
if (!HasPrefixString(p.first, "oauth_")) continue;
ret.append(", ");
ret.append(p.first).append("=\"").append(EscapeUrl(p.second)).append("\"");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/twitter-demo/parser-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/twitter-demo/parser-test.cc b/src/kudu/twitter-demo/parser-test.cc
index 0b56daf..1085450 100644
--- a/src/kudu/twitter-demo/parser-test.cc
+++ b/src/kudu/twitter-demo/parser-test.cc
@@ -17,7 +17,6 @@
#include "kudu/twitter-demo/parser.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -57,7 +56,7 @@ static void EnsureFileParses(const char* file, TwitterEventType expected_type) {
CHECK_OK(LoadFile(file, &jsons));
int line_number = 1;
- BOOST_FOREACH(const string& json, jsons) {
+ for (const string& json : jsons) {
if (json.empty()) continue;
SCOPED_TRACE(json);
SCOPED_TRACE(line_number);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/atomic-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/atomic-test.cc b/src/kudu/util/atomic-test.cc
index fe5fbbf..ad754f3 100644
--- a/src/kudu/util/atomic-test.cc
+++ b/src/kudu/util/atomic-test.cc
@@ -17,7 +17,6 @@
#include "kudu/util/atomic.h"
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <limits>
#include <vector>
@@ -54,7 +53,7 @@ typedef ::testing::Types<int32_t, int64_t, uint32_t, uint64_t> IntTypes;
TYPED_TEST_CASE(AtomicIntTest, IntTypes);
TYPED_TEST(AtomicIntTest, LoadStore) {
- BOOST_FOREACH(const MemoryOrder mem_order, this->acquire_release_) {
+ for (const MemoryOrder mem_order : this->acquire_release_) {
AtomicInt<TypeParam> i(0);
EXPECT_EQ(0, i.Load(mem_order));
i.Store(42, mem_order);
@@ -67,7 +66,7 @@ TYPED_TEST(AtomicIntTest, LoadStore) {
}
TYPED_TEST(AtomicIntTest, SetSwapExchange) {
- BOOST_FOREACH(const MemoryOrder mem_order, this->acquire_release_) {
+ for (const MemoryOrder mem_order : this->acquire_release_) {
AtomicInt<TypeParam> i(0);
EXPECT_TRUE(i.CompareAndSet(0, 5, mem_order));
EXPECT_EQ(5, i.Load(mem_order));
@@ -83,7 +82,7 @@ TYPED_TEST(AtomicIntTest, SetSwapExchange) {
}
TYPED_TEST(AtomicIntTest, MinMax) {
- BOOST_FOREACH(const MemoryOrder mem_order, this->acquire_release_) {
+ for (const MemoryOrder mem_order : this->acquire_release_) {
AtomicInt<TypeParam> i(0);
i.StoreMax(100, mem_order);
@@ -104,7 +103,7 @@ TYPED_TEST(AtomicIntTest, MinMax) {
}
TYPED_TEST(AtomicIntTest, Increment) {
- BOOST_FOREACH(const MemoryOrder mem_order, this->barrier_) {
+ for (const MemoryOrder mem_order : this->barrier_) {
AtomicInt<TypeParam> i(0);
EXPECT_EQ(1, i.Increment(mem_order));
EXPECT_EQ(3, i.IncrementBy(2, mem_order));
@@ -114,7 +113,7 @@ TYPED_TEST(AtomicIntTest, Increment) {
TEST(Atomic, AtomicBool) {
vector<MemoryOrder> memory_orders = { kMemOrderNoBarrier, kMemOrderRelease, kMemOrderAcquire };
- BOOST_FOREACH(const MemoryOrder mem_order, memory_orders) {
+ for (const MemoryOrder mem_order : memory_orders) {
AtomicBool b(false);
EXPECT_FALSE(b.Load(mem_order));
b.Store(true, mem_order);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/blocking_queue.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/blocking_queue.h b/src/kudu/util/blocking_queue.h
index a9d4459..f20f787 100644
--- a/src/kudu/util/blocking_queue.h
+++ b/src/kudu/util/blocking_queue.h
@@ -17,7 +17,6 @@
#ifndef KUDU_UTIL_BLOCKING_QUEUE_H
#define KUDU_UTIL_BLOCKING_QUEUE_H
-#include <boost/foreach.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <list>
#include <string>
@@ -108,7 +107,7 @@ class BlockingQueue {
while (true) {
if (!list_.empty()) {
out->reserve(list_.size());
- BOOST_FOREACH(const T& elt, list_) {
+ for (const T& elt : list_) {
out->push_back(elt);
decrement_size_unlocked(elt);
}
@@ -208,7 +207,7 @@ class BlockingQueue {
std::string ret;
MutexLock l(lock_);
- BOOST_FOREACH(const T& t, list_) {
+ for (const T& t : list_) {
ret.append(t->ToString());
ret.append("\n");
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/cache.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/cache.cc b/src/kudu/util/cache.cc
index a86fb8a..2dc12b1 100644
--- a/src/kudu/util/cache.cc
+++ b/src/kudu/util/cache.cc
@@ -19,7 +19,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <memory>
#include <stdlib.h>
@@ -450,7 +449,7 @@ class ShardedLRUCache : public Cache {
virtual void SetMetrics(const scoped_refptr<MetricEntity>& entity) OVERRIDE {
metrics_.reset(new CacheMetrics(entity));
- BOOST_FOREACH(LRUCache* cache, shards_) {
+ for (LRUCache* cache : shards_) {
cache->SetMetrics(metrics_.get());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/debug-util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/debug-util-test.cc b/src/kudu/util/debug-util-test.cc
index 2f184e5..f6bfd33 100644
--- a/src/kudu/util/debug-util-test.cc
+++ b/src/kudu/util/debug-util-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/stl_logging.h>
#include <signal.h>
#include <string>
@@ -141,7 +140,7 @@ TEST_F(DebugUtilTest, TestSignalStackTrace) {
TEST_F(DebugUtilTest, TestDumpAllThreads) {
vector<pid_t> tids;
ASSERT_OK(ListThreads(&tids));
- BOOST_FOREACH(pid_t tid, tids) {
+ for (pid_t tid : tids) {
LOG(INFO) << DumpThreadStack(tid);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/debug/trace_event_impl.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/debug/trace_event_impl.cc b/src/kudu/util/debug/trace_event_impl.cc
index 412650d..22cbe62 100644
--- a/src/kudu/util/debug/trace_event_impl.cc
+++ b/src/kudu/util/debug/trace_event_impl.cc
@@ -6,7 +6,6 @@
#include "kudu/util/debug/trace_event_impl.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <list>
#include <vector>
@@ -1559,7 +1558,7 @@ void TraceLog::Flush(const TraceLog::OutputCallback& cb) {
// Holding the active threads lock ensures that no thread will exit and
// delete its own PerThreadInfo object.
MutexLock l(active_threads_lock_);
- BOOST_FOREACH(const ActiveThreadMap::value_type& entry, active_threads_) {
+ for (const ActiveThreadMap::value_type& entry : active_threads_) {
int64_t tid = entry.first;
PerThreadInfo* thr_info = entry.second;
@@ -2223,7 +2222,7 @@ bool CategoryFilter::DoesCategoryGroupContainCategory(
const char* category) const {
DCHECK(category);
vector<string> pieces = strings::Split(category_group, ",");
- BOOST_FOREACH(const string& category_group_token, pieces) {
+ for (const string& category_group_token : pieces) {
// Don't allow empty tokens, nor tokens with leading or trailing space.
DCHECK(!CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
category_group_token))
@@ -2267,7 +2266,7 @@ void CategoryFilter::Initialize(const std::string& filter_string) {
// Tokenize list of categories, delimited by ','.
vector<string> tokens = strings::Split(filter_string, ",");
// Add each token to the appropriate list (included_,excluded_).
- BOOST_FOREACH(string category, tokens) {
+ for (string category : tokens) {
// Ignore empty categories.
if (category.empty())
continue;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/env-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/env-test.cc b/src/kudu/util/env-test.cc
index 6c56193..d9ca45d 100644
--- a/src/kudu/util/env-test.cc
+++ b/src/kudu/util/env-test.cc
@@ -22,7 +22,6 @@
#include <glog/logging.h>
#include <gtest/gtest.h>
-#include <boost/foreach.hpp>
#include "kudu/gutil/bind.h"
#include "kudu/gutil/strings/substitute.h"
@@ -168,7 +167,7 @@ class TestEnv : public KuduTest {
if (fast || random() % 2) {
ASSERT_OK(file->AppendVector(input[i]));
} else {
- BOOST_FOREACH(const Slice& slice, input[i]) {
+ for (const Slice& slice : input[i]) {
ASSERT_OK(file->Append(slice));
}
}
@@ -667,7 +666,7 @@ TEST_F(TestEnv, TestRWFile) {
TEST_F(TestEnv, TestCanonicalize) {
vector<string> synonyms = { GetTestPath("."), GetTestPath("./."), GetTestPath(".//./") };
- BOOST_FOREACH(const string& synonym, synonyms) {
+ for (const string& synonym : synonyms) {
string result;
ASSERT_OK(env_->Canonicalize(synonym, &result));
ASSERT_EQ(GetTestDataDirectory(), result);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/env_posix.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/env_posix.cc b/src/kudu/util/env_posix.cc
index 38d276d..1570c18 100644
--- a/src/kudu/util/env_posix.cc
+++ b/src/kudu/util/env_posix.cc
@@ -2,7 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include <boost/foreach.hpp>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/failure_detector.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/failure_detector.cc b/src/kudu/util/failure_detector.cc
index a6dc022..76f2611 100644
--- a/src/kudu/util/failure_detector.cc
+++ b/src/kudu/util/failure_detector.cc
@@ -17,7 +17,6 @@
#include "kudu/util/failure_detector.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <unordered_map>
@@ -103,14 +102,14 @@ void TimedFailureDetector::CheckForFailures(const MonoTime& now) {
CallbackMap callbacks;
{
lock_guard<simple_spinlock> lock(&lock_);
- BOOST_FOREACH(const NodeMap::value_type& entry, nodes_) {
+ for (const NodeMap::value_type& entry : nodes_) {
if (GetNodeStatusUnlocked(entry.first, now) == DEAD) {
InsertOrDie(&callbacks, entry.first, entry.second->callback);
}
}
}
// Invoke failure callbacks outside of lock.
- BOOST_FOREACH(const CallbackMap::value_type& entry, callbacks) {
+ for (const CallbackMap::value_type& entry : callbacks) {
const string& node_name = entry.first;
const FailureDetectedCallback& callback = entry.second;
callback.Run(node_name, Status::RemoteError(Substitute("Node '$0' failed", node_name)));
@@ -206,7 +205,7 @@ void RandomizedFailureMonitor::RunThread() {
}
MonoTime now = MonoTime::Now(MonoTime::FINE);
- BOOST_FOREACH(const FDMap::value_type& entry, fds_copy) {
+ for (const FDMap::value_type& entry : fds_copy) {
entry.second->CheckForFailures(now);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/flags.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/flags.cc b/src/kudu/util/flags.cc
index dbaec62..17e6ee5 100644
--- a/src/kudu/util/flags.cc
+++ b/src/kudu/util/flags.cc
@@ -22,7 +22,6 @@
#include <unordered_set>
#include <vector>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <gperftools/heap-profiler.h>
@@ -243,7 +242,7 @@ void DumpFlagsXML() {
"<usage>$0</usage>",
EscapeForHtmlToString(google::ProgramUsage())) << endl;
- BOOST_FOREACH(const CommandLineFlagInfo& flag, flags) {
+ for (const CommandLineFlagInfo& flag : flags) {
cout << DescribeOneFlagInXML(flag) << std::endl;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/interval_tree-inl.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/interval_tree-inl.h b/src/kudu/util/interval_tree-inl.h
index 21a92e8..043c05e 100644
--- a/src/kudu/util/interval_tree-inl.h
+++ b/src/kudu/util/interval_tree-inl.h
@@ -86,7 +86,7 @@ void IntervalTree<Traits>::Partition(const IntervalVector &in,
// Pick a split point which is the median of all of the interval boundaries.
std::vector<point_type> endpoints;
endpoints.reserve(in.size() * 2);
- BOOST_FOREACH(const interval_type &interval, in) {
+ for (const interval_type &interval : in) {
endpoints.push_back(Traits::get_left(interval));
endpoints.push_back(Traits::get_right(interval));
}
@@ -94,7 +94,7 @@ void IntervalTree<Traits>::Partition(const IntervalVector &in,
*split_point = endpoints[endpoints.size() / 2];
// Partition into the groups based on the determined split point.
- BOOST_FOREACH(const interval_type &interval, in) {
+ for (const interval_type &interval : in) {
if (Traits::compare(Traits::get_right(interval), *split_point) < 0) {
// | split point
// |------------| |
@@ -226,7 +226,7 @@ void ITNode<Traits>::FindContainingPoint(const point_type &query,
// Any intervals which start before the query point and overlap the split point
// must therefore contain the query point.
- BOOST_FOREACH(const interval_type &interval, overlapping_by_asc_left_) {
+ for (const interval_type &interval : overlapping_by_asc_left_) {
if (Traits::compare(Traits::get_left(interval), query) <= 0) {
results->push_back(interval);
} else {
@@ -241,7 +241,7 @@ void ITNode<Traits>::FindContainingPoint(const point_type &query,
// Any intervals which end after the query point and overlap the split point
// must therefore contain the query point.
- BOOST_FOREACH(const interval_type &interval, overlapping_by_desc_right_) {
+ for (const interval_type &interval : overlapping_by_desc_right_) {
if (Traits::compare(Traits::get_right(interval), query) >= 0) {
results->push_back(interval);
} else {
@@ -269,7 +269,7 @@ void ITNode<Traits>::FindIntersectingInterval(const interval_type &query,
// Any intervals whose left edge is <= the query interval's right edge
// intersect the query interval.
- BOOST_FOREACH(const interval_type &interval, overlapping_by_asc_left_) {
+ for (const interval_type &interval : overlapping_by_asc_left_) {
if (Traits::compare(Traits::get_left(interval),Traits::get_right(query)) <= 0) {
results->push_back(interval);
} else {
@@ -285,7 +285,7 @@ void ITNode<Traits>::FindIntersectingInterval(const interval_type &query,
// Any intervals whose right edge is >= the query interval's left edge
// intersect the query interval.
- BOOST_FOREACH(const interval_type &interval, overlapping_by_desc_right_) {
+ for (const interval_type &interval : overlapping_by_desc_right_) {
if (Traits::compare(Traits::get_right(interval), Traits::get_left(query)) >= 0) {
results->push_back(interval);
} else {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/interval_tree-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/interval_tree-test.cc b/src/kudu/util/interval_tree-test.cc
index 89fbe96..09c3015 100644
--- a/src/kudu/util/interval_tree-test.cc
+++ b/src/kudu/util/interval_tree-test.cc
@@ -80,7 +80,7 @@ static bool CompareIntervals(const IntInterval &a, const IntInterval &b) {
static string Stringify(const vector<IntInterval> &intervals) {
string ret;
bool first = true;
- BOOST_FOREACH(const IntInterval &interval, intervals) {
+ for (const IntInterval &interval : intervals) {
if (!first) {
ret.append(",");
}
@@ -93,7 +93,7 @@ static string Stringify(const vector<IntInterval> &intervals) {
static void FindContainingBruteForce(const vector<IntInterval> &intervals,
int query_point,
vector<IntInterval> *results) {
- BOOST_FOREACH(const IntInterval &i, intervals) {
+ for (const IntInterval &i : intervals) {
if (query_point >= i.left && query_point <= i.right) {
results->push_back(i);
}
@@ -105,7 +105,7 @@ static void FindContainingBruteForce(const vector<IntInterval> &intervals,
static void FindIntersectingBruteForce(const vector<IntInterval> &intervals,
IntInterval query_interval,
vector<IntInterval> *results) {
- BOOST_FOREACH(const IntInterval &i, intervals) {
+ for (const IntInterval &i : intervals) {
if (query_interval.Intersects(i)) {
results->push_back(i);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/interval_tree.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/interval_tree.h b/src/kudu/util/interval_tree.h
index d98d929..8a625d1 100644
--- a/src/kudu/util/interval_tree.h
+++ b/src/kudu/util/interval_tree.h
@@ -23,7 +23,6 @@
#ifndef KUDU_UTIL_INTERVAL_TREE_H
#define KUDU_UTIL_INTERVAL_TREE_H
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <vector>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/jsonreader-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/jsonreader-test.cc b/src/kudu/util/jsonreader-test.cc
index e38981e..eeae025 100644
--- a/src/kudu/util/jsonreader-test.cc
+++ b/src/kudu/util/jsonreader-test.cc
@@ -18,7 +18,6 @@
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/gutil/integral_types.h"
@@ -154,7 +153,7 @@ TEST(JsonReaderTest, NestedArray) {
ASSERT_OK(r.ExtractObjectArray(r.root(), "foo", &foo));
ASSERT_EQ(3, foo.size());
int i = 0;
- BOOST_FOREACH(const Value* v, foo) {
+ for (const Value* v : foo) {
int32_t number;
ASSERT_OK(r.ExtractInt32(v, "val", &number));
ASSERT_EQ(i, number);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/jsonwriter.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/jsonwriter.cc b/src/kudu/util/jsonwriter.cc
index 1d8e4d8..bc11264 100644
--- a/src/kudu/util/jsonwriter.cc
+++ b/src/kudu/util/jsonwriter.cc
@@ -19,7 +19,6 @@
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/message.h>
@@ -169,7 +168,7 @@ void JsonWriter::Protobuf(const Message& pb) {
reflection->ListFields(pb, &fields);
StartObject();
- BOOST_FOREACH(const FieldDescriptor* field, fields) {
+ for (const FieldDescriptor* field : fields) {
String(field->name());
if (field->is_repeated()) {
StartArray();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/kernel_stack_watchdog.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/kernel_stack_watchdog.cc b/src/kudu/util/kernel_stack_watchdog.cc
index 21817a4..5ec871b 100644
--- a/src/kudu/util/kernel_stack_watchdog.cc
+++ b/src/kudu/util/kernel_stack_watchdog.cc
@@ -18,7 +18,6 @@
#include "kudu/util/kernel_stack_watchdog.h"
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gflags/gflags.h>
#include <string>
@@ -101,7 +100,7 @@ void KernelStackWatchdog::RunThread() {
MutexLock l(lock_);
MicrosecondsInt64 now = GetMonoTimeMicros();
- BOOST_FOREACH(const TLSMap::value_type& map_entry, tls_by_tid_) {
+ for (const TLSMap::value_type& map_entry : tls_by_tid_) {
pid_t p = map_entry.first;
const TLS::Data* tls = &map_entry.second->data_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/knapsack_solver-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/knapsack_solver-test.cc b/src/kudu/util/knapsack_solver-test.cc
index 0d066ef..703255f 100644
--- a/src/kudu/util/knapsack_solver-test.cc
+++ b/src/kudu/util/knapsack_solver-test.cc
@@ -134,7 +134,7 @@ TEST_F(TestKnapsack, Randomized) {
// Verify that the max_val is equal to the sum of the chosen items' values.
double sum_val = 0;
int sum_weight = 0;
- BOOST_FOREACH(int i, out) {
+ for (int i : out) {
sum_val += in[i].value;
sum_weight += in[i].weight;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/knapsack_solver.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/knapsack_solver.h b/src/kudu/util/knapsack_solver.h
index 565b0de..2c37065 100644
--- a/src/kudu/util/knapsack_solver.h
+++ b/src/kudu/util/knapsack_solver.h
@@ -17,7 +17,6 @@
#ifndef KUDU_UTIL_KNAPSACK_SOLVER_H
#define KUDU_UTIL_KNAPSACK_SOLVER_H
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <algorithm>
#include <utility>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/mem_tracker-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/mem_tracker-test.cc b/src/kudu/util/mem_tracker-test.cc
index f961feb..51529e1 100644
--- a/src/kudu/util/mem_tracker-test.cc
+++ b/src/kudu/util/mem_tracker-test.cc
@@ -23,7 +23,6 @@
#include <vector>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <gperftools/malloc_extension.h>
#include "kudu/util/test_util.h"
@@ -227,7 +226,7 @@ TEST(MemTrackerTest, FindFunctionsTakeOwnership) {
shared_ptr<MemTracker> m = MemTracker::CreateTracker(-1, "test");
MemTracker::ListTrackers(&refs);
}
- BOOST_FOREACH(const shared_ptr<MemTracker>& r, refs) {
+ for (const shared_ptr<MemTracker>& r : refs) {
LOG(INFO) << r->ToString();
}
refs.clear();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/mem_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/mem_tracker.cc b/src/kudu/util/mem_tracker.cc
index e892a72..84a057a 100644
--- a/src/kudu/util/mem_tracker.cc
+++ b/src/kudu/util/mem_tracker.cc
@@ -18,7 +18,6 @@
#include "kudu/util/mem_tracker.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <deque>
#include <gperftools/malloc_extension.h>
#include <limits>
@@ -226,7 +225,7 @@ bool MemTracker::FindTrackerUnlocked(const string& id,
const shared_ptr<MemTracker>& parent) {
DCHECK(parent != NULL);
parent->child_trackers_lock_.AssertAcquired();
- BOOST_FOREACH(MemTracker* child, parent->child_trackers_) {
+ for (MemTracker* child : parent->child_trackers_) {
if (child->id() == id) {
*tracker = child->shared_from_this();
return true;
@@ -258,7 +257,7 @@ void MemTracker::ListTrackers(vector<shared_ptr<MemTracker>>* trackers) {
trackers->push_back(t);
{
MutexLock l(t->child_trackers_lock_);
- BOOST_FOREACH(MemTracker* child, t->child_trackers_) {
+ for (MemTracker* child : t->child_trackers_) {
to_process.push_back(child->shared_from_this());
}
}
@@ -439,7 +438,7 @@ bool MemTracker::SoftLimitExceeded(double* current_capacity_pct) {
}
bool MemTracker::AnySoftLimitExceeded(double* current_capacity_pct) {
- BOOST_FOREACH(MemTracker* t, limit_trackers_) {
+ for (MemTracker* t : limit_trackers_) {
if (t->SoftLimitExceeded(current_capacity_pct)) {
return true;
}
@@ -572,7 +571,7 @@ void MemTracker::LogUpdate(bool is_consume, int64_t bytes) const {
string MemTracker::LogUsage(const string& prefix,
const list<MemTracker*>& trackers) {
vector<string> usage_strings;
- BOOST_FOREACH(const MemTracker* child, trackers) {
+ for (const MemTracker* child : trackers) {
usage_strings.push_back(child->LogUsage(prefix));
}
return JoinStrings(usage_strings, "\n");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/mem_tracker.h
----------------------------------------------------------------------
diff --git a/src/kudu/util/mem_tracker.h b/src/kudu/util/mem_tracker.h
index ed85c05..5a2dde7 100644
--- a/src/kudu/util/mem_tracker.h
+++ b/src/kudu/util/mem_tracker.h
@@ -73,7 +73,7 @@ class MemTracker;
//
// NOTE: this class has been partially ported over from Impala with
// several changes, and as a result the style differs somewhat from
-// the Kudu style (e.g., BOOST_FOREACH is not used).
+// the Kudu style.
//
// Changes from Impala:
// 1) Id a string vs. a TUniqueId
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/memcmpable_varint-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/memcmpable_varint-test.cc b/src/kudu/util/memcmpable_varint-test.cc
index 8c9d581..3e5b5e0 100644
--- a/src/kudu/util/memcmpable_varint-test.cc
+++ b/src/kudu/util/memcmpable_varint-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -129,15 +128,15 @@ TEST_F(TestMemcmpableVarint, TestInterestingCompositeKeys) {
faststring buf1;
faststring buf2;
- BOOST_FOREACH(uint64_t v1, interesting_values) {
- BOOST_FOREACH(uint64_t v2, interesting_values) {
+ for (uint64_t v1 : interesting_values) {
+ for (uint64_t v2 : interesting_values) {
buf1.clear();
pair<uint64_t, uint64_t> p1 = make_pair(v1, v2);
PutMemcmpableVarint64(&buf1, p1.first);
PutMemcmpableVarint64(&buf1, p1.second);
- BOOST_FOREACH(uint64_t v3, interesting_values) {
- BOOST_FOREACH(uint64_t v4, interesting_values) {
+ for (uint64_t v3 : interesting_values) {
+ for (uint64_t v4 : interesting_values) {
buf2.clear();
pair<uint64_t, uint64_t> p2 = make_pair(v3, v4);
PutMemcmpableVarint64(&buf2, p2.first);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/memenv/memenv-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/memenv/memenv-test.cc b/src/kudu/util/memenv/memenv-test.cc
index 9ba145e..28f34d5 100644
--- a/src/kudu/util/memenv/memenv-test.cc
+++ b/src/kudu/util/memenv/memenv-test.cc
@@ -5,7 +5,6 @@
// Modified for kudu:
// - use gtest
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <string>
#include <memory>
@@ -275,7 +274,7 @@ TEST_F(MemEnvTest, TempFile) {
}
// Delete the files we created.
- BOOST_FOREACH(const string& p, paths) {
+ for (const string& p : paths) {
ASSERT_OK(env_->DeleteFile(p));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/memenv/memenv.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/memenv/memenv.cc b/src/kudu/util/memenv/memenv.cc
index 20227b9..a80bac5 100644
--- a/src/kudu/util/memenv/memenv.cc
+++ b/src/kudu/util/memenv/memenv.cc
@@ -6,7 +6,6 @@
// - use boost mutexes instead of port mutexes
#include <string.h>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <map>
#include <string>
@@ -132,7 +131,7 @@ class FileState : public RefCountedThreadSafe<FileState> {
size_t memory_footprint() const {
size_t size = kudu_malloc_usable_size(this);
size += kudu_malloc_usable_size(blocks_.data());
- BOOST_FOREACH(uint8_t* block, blocks_) {
+ for (uint8_t* block : blocks_) {
size += kudu_malloc_usable_size(block);
}
size += filename_.capacity();
@@ -146,7 +145,7 @@ class FileState : public RefCountedThreadSafe<FileState> {
// Private since only Release() should be used to delete it.
~FileState() {
- BOOST_FOREACH(uint8_t* block, blocks_) {
+ for (uint8_t* block : blocks_) {
delete[] block;
}
}
@@ -254,7 +253,7 @@ class WritableFileImpl : public WritableFile {
// This is a dummy implementation that simply serially appends all
// slices using regular I/O.
virtual Status AppendVector(const vector<Slice>& data_vector) OVERRIDE {
- BOOST_FOREACH(const Slice& data, data_vector) {
+ for (const Slice& data : data_vector) {
RETURN_NOT_OK(file_->Append(data));
}
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/memory/arena-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/memory/arena-test.cc b/src/kudu/util/memory/arena-test.cc
index 667a667..a14e1f2 100644
--- a/src/kudu/util/memory/arena-test.cc
+++ b/src/kudu/util/memory/arena-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/thread/thread.hpp>
#include <gflags/gflags.h>
@@ -52,7 +51,7 @@ static void AllocateThread(ArenaType *arena, uint8_t thread_index) {
ptrs.push_back(alloced);
}
- BOOST_FOREACH(void *p, ptrs) {
+ for (void *p : ptrs) {
if (memcmp(buf, p, FLAGS_alloc_size) != 0) {
FAIL() << StringPrintf("overwritten pointer at %p", p);
}
@@ -84,7 +83,7 @@ TEST(TestArena, TestMultiThreaded) {
threads.push_back(new boost::thread(AllocateThreadTSArena, &arena, (uint8_t)i));
}
- BOOST_FOREACH(boost::thread &thr, threads) {
+ for (boost::thread &thr : threads) {
thr.join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/metrics.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/metrics.cc b/src/kudu/util/metrics.cc
index 1547682..08e5786 100644
--- a/src/kudu/util/metrics.cc
+++ b/src/kudu/util/metrics.cc
@@ -20,7 +20,6 @@
#include <map>
#include <set>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include "kudu/gutil/atomicops.h"
@@ -181,7 +180,7 @@ namespace {
bool MatchMetricInList(const string& metric_name,
const vector<string>& match_params) {
- BOOST_FOREACH(const string& param, match_params) {
+ for (const string& param : match_params) {
// Handle wildcard.
if (param == "*") return true;
// The parameter is a substring match of the metric name.
@@ -208,7 +207,7 @@ Status MetricEntity::WriteAsJson(JsonWriter* writer,
// Snapshot the metrics in this registry (not guaranteed to be a consistent snapshot)
lock_guard<simple_spinlock> l(&lock_);
attrs = attributes_;
- BOOST_FOREACH(const MetricMap::value_type& val, metric_map_) {
+ for (const MetricMap::value_type& val : metric_map_) {
const MetricPrototype* prototype = val.first;
const scoped_refptr<Metric>& metric = val.second;
@@ -234,7 +233,7 @@ Status MetricEntity::WriteAsJson(JsonWriter* writer,
writer->String("attributes");
writer->StartObject();
- BOOST_FOREACH(const AttributeMap::value_type& val, attrs) {
+ for (const AttributeMap::value_type& val : attrs) {
writer->String(val.first);
writer->String(val.second);
}
@@ -242,7 +241,7 @@ Status MetricEntity::WriteAsJson(JsonWriter* writer,
writer->String("metrics");
writer->StartArray();
- BOOST_FOREACH(OrderedMetricMap::value_type& val, metrics) {
+ for (OrderedMetricMap::value_type& val : metrics) {
WARN_NOT_OK(val.second->WriteAsJson(writer, opts),
strings::Substitute("Failed to write $0 as JSON", val.first));
@@ -336,7 +335,7 @@ Status MetricRegistry::WriteAsJson(JsonWriter* writer,
}
writer->StartArray();
- BOOST_FOREACH(const EntityMap::value_type e, entities) {
+ for (const EntityMap::value_type e : entities) {
WARN_NOT_OK(e.second->WriteAsJson(writer, requested_metrics, opts),
Substitute("Failed to write entity $0 as JSON", e.second->id()));
}
@@ -396,7 +395,7 @@ void MetricPrototypeRegistry::WriteAsJson(JsonWriter* writer) const {
// Dump metric prototypes.
writer->String("metrics");
writer->StartArray();
- BOOST_FOREACH(const MetricPrototype* p, metrics_) {
+ for (const MetricPrototype* p : metrics_) {
writer->StartObject();
p->WriteFields(writer, opts);
writer->String("entity_type");
@@ -408,7 +407,7 @@ void MetricPrototypeRegistry::WriteAsJson(JsonWriter* writer) const {
// Dump entity prototypes.
writer->String("entities");
writer->StartArray();
- BOOST_FOREACH(const MetricEntityPrototype* p, entities_) {
+ for (const MetricEntityPrototype* p : entities_) {
writer->StartObject();
writer->String("name");
writer->String(p->name());
@@ -462,7 +461,7 @@ FunctionGaugeDetacher::FunctionGaugeDetacher() {
}
FunctionGaugeDetacher::~FunctionGaugeDetacher() {
- BOOST_FOREACH(const Closure& c, callbacks_) {
+ for (const Closure& c : callbacks_) {
c.Run();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/mt-metrics-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/mt-metrics-test.cc b/src/kudu/util/mt-metrics-test.cc
index 62f3fa5..524bd90 100644
--- a/src/kudu/util/mt-metrics-test.cc
+++ b/src/kudu/util/mt-metrics-test.cc
@@ -18,7 +18,6 @@
#include <vector>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/mt-threadlocal-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/mt-threadlocal-test.cc b/src/kudu/util/mt-threadlocal-test.cc
index a5059b7..c3479ff 100644
--- a/src/kudu/util/mt-threadlocal-test.cc
+++ b/src/kudu/util/mt-threadlocal-test.cc
@@ -14,7 +14,7 @@
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
+
#include <boost/thread/locks.hpp>
#include <glog/logging.h>
#include <unordered_set>
@@ -158,7 +158,7 @@ static uint64_t Iterate(CounterRegistry* registry, int expected_counters) {
uint64_t sum = 0;
int seen_counters = 0;
boost::lock_guard<RegistryLockType> l(*registry->get_lock());
- BOOST_FOREACH(Counter* counter, *registry->GetCountersUnlocked()) {
+ for (Counter* counter : *registry->GetCountersUnlocked()) {
uint64_t value;
{
boost::lock_guard<CounterLockType> l(*counter->get_lock());
@@ -211,7 +211,7 @@ static void TestThreadLocalCounters(CounterRegistry* registry, const int num_thr
reader_done.CountDown();
LOG(INFO) << "Joining & deleting threads...";
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thread, threads) {
+ for (scoped_refptr<kudu::Thread> thread : threads) {
CHECK_OK(ThreadJoiner(thread.get()).Join());
}
LOG(INFO) << "Done.";
@@ -313,7 +313,7 @@ TEST_F(ThreadLocalTest, TestTLSMember) {
}
LOG(INFO) << "Joining & deleting threads...";
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thread, threads) {
+ for (scoped_refptr<kudu::Thread> thread : threads) {
CHECK_OK(ThreadJoiner(thread.get()).Join());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/net/dns_resolver-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/net/dns_resolver-test.cc b/src/kudu/util/net/dns_resolver-test.cc
index 26f3c3b..55be284 100644
--- a/src/kudu/util/net/dns_resolver-test.cc
+++ b/src/kudu/util/net/dns_resolver-test.cc
@@ -18,7 +18,6 @@
#include "kudu/util/net/dns_resolver.h"
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <vector>
@@ -46,7 +45,7 @@ TEST_F(DnsResolverTest, TestResolution) {
}
ASSERT_OK(s.Wait());
ASSERT_TRUE(!addrs.empty());
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
LOG(INFO) << "Address: " << addr.ToString();
EXPECT_TRUE(HasPrefixString(addr.ToString(), "127."));
EXPECT_TRUE(HasSuffixString(addr.ToString(), ":12345"));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/net/net_util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/net/net_util-test.cc b/src/kudu/util/net/net_util-test.cc
index ac7de16..ea499f8 100644
--- a/src/kudu/util/net/net_util-test.cc
+++ b/src/kudu/util/net/net_util-test.cc
@@ -17,7 +17,6 @@
#include <gtest/gtest.h>
-#include <boost/foreach.hpp>
#include <algorithm>
#include <string>
#include <vector>
@@ -40,7 +39,7 @@ class NetUtilTest : public KuduTest {
std::sort(addrs.begin(), addrs.end());
vector<string> addr_strs;
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
addr_strs.push_back(addr.ToString());
}
*result = JoinStrings(addr_strs, ",");
@@ -83,7 +82,7 @@ TEST_F(NetUtilTest, TestResolveAddresses) {
vector<Sockaddr> addrs;
ASSERT_OK(hp.ResolveAddresses(&addrs));
ASSERT_TRUE(!addrs.empty());
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
LOG(INFO) << "Address: " << addr.ToString();
EXPECT_TRUE(HasPrefixString(addr.ToString(), "127."));
EXPECT_TRUE(HasSuffixString(addr.ToString(), ":12345"));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/net/net_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/net/net_util.cc b/src/kudu/util/net/net_util.cc
index 0f86741..94f4f33 100644
--- a/src/kudu/util/net/net_util.cc
+++ b/src/kudu/util/net/net_util.cc
@@ -21,7 +21,6 @@
#include <netdb.h>
#include <algorithm>
-#include <boost/foreach.hpp>
#include <unordered_set>
#include <utility>
#include <vector>
@@ -131,7 +130,7 @@ Status HostPort::ParseStrings(const string& comma_sep_addrs,
uint16_t default_port,
vector<HostPort>* res) {
vector<string> addr_strings = strings::Split(comma_sep_addrs, ",", strings::SkipEmpty());
- BOOST_FOREACH(const string& addr_string, addr_strings) {
+ for (const string& addr_string : addr_strings) {
HostPort host_port;
RETURN_NOT_OK(host_port.ParseString(addr_string, default_port));
res->push_back(host_port);
@@ -145,7 +144,7 @@ string HostPort::ToString() const {
string HostPort::ToCommaSeparatedString(const vector<HostPort>& hostports) {
vector<string> hostport_strs;
- BOOST_FOREACH(const HostPort& hostport, hostports) {
+ for (const HostPort& hostport : hostports) {
hostport_strs.push_back(hostport.ToString());
}
return JoinStrings(hostport_strs, ",");
@@ -162,13 +161,13 @@ Status ParseAddressList(const std::string& addr_list,
RETURN_NOT_OK(HostPort::ParseStrings(addr_list, default_port, &host_ports));
unordered_set<Sockaddr> uniqued;
- BOOST_FOREACH(const HostPort& host_port, host_ports) {
+ for (const HostPort& host_port : host_ports) {
vector<Sockaddr> this_addresses;
RETURN_NOT_OK(host_port.ResolveAddresses(&this_addresses));
// Only add the unique ones -- the user may have specified
// some IP addresses in multiple ways
- BOOST_FOREACH(const Sockaddr& addr, this_addresses) {
+ for (const Sockaddr& addr : this_addresses) {
if (InsertIfNotPresent(&uniqued, addr)) {
addresses->push_back(addr);
} else {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/nvm_cache.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/nvm_cache.cc b/src/kudu/util/nvm_cache.cc
index bd27b8f..cce82b9 100644
--- a/src/kudu/util/nvm_cache.cc
+++ b/src/kudu/util/nvm_cache.cc
@@ -35,7 +35,6 @@
#include "kudu/util/nvm_cache.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <iostream>
@@ -546,7 +545,7 @@ class ShardedLRUCache : public Cache {
}
virtual void SetMetrics(const scoped_refptr<MetricEntity>& entity) OVERRIDE {
metrics_.reset(new CacheMetrics(entity));
- BOOST_FOREACH(NvmLRUCache* cache, shards_) {
+ for (NvmLRUCache* cache : shards_) {
cache->SetMetrics(metrics_.get());
}
}
@@ -554,7 +553,7 @@ class ShardedLRUCache : public Cache {
// Try allocating from each of the shards -- if vmem is tight,
// this can cause eviction, so we might have better luck in different
// shards.
- BOOST_FOREACH(NvmLRUCache* cache, shards_) {
+ for (NvmLRUCache* cache : shards_) {
uint8_t* ptr = reinterpret_cast<uint8_t*>(cache->AllocateAndRetry(size));
if (ptr) return ptr;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/once-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/once-test.cc b/src/kudu/util/once-test.cc
index aca92c8..8ccd8b6 100644
--- a/src/kudu/util/once-test.cc
+++ b/src/kudu/util/once-test.cc
@@ -17,7 +17,6 @@
#include <vector>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/gutil/bind.h"
@@ -103,7 +102,7 @@ TEST(TestOnce, KuduOnceDynamicThreadSafeTest) {
threads.push_back(t);
}
- BOOST_FOREACH(const scoped_refptr<Thread>& t, threads) {
+ for (const scoped_refptr<Thread>& t : threads) {
t->Join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/pb_util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/pb_util-test.cc b/src/kudu/util/pb_util-test.cc
index 04e6988..d97872c 100644
--- a/src/kudu/util/pb_util-test.cc
+++ b/src/kudu/util/pb_util-test.cc
@@ -23,7 +23,6 @@
#include <vector>
#include <boost/assign.hpp>
-#include <boost/foreach.hpp>
#include <google/protobuf/descriptor.pb.h>
#include <gtest/gtest.h>
@@ -162,7 +161,7 @@ TEST_F(TestPBUtil, TestPBContainerSimple) {
// Exercise both the SYNC and NO_SYNC codepaths, despite the fact that we
// aren't able to observe a difference in the test.
vector<SyncMode> modes = { SYNC, NO_SYNC };
- BOOST_FOREACH(SyncMode mode, modes) {
+ for (SyncMode mode : modes) {
// Write the file.
ASSERT_OK(CreateKnownGoodContainerFile(NO_OVERWRITE, mode));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/pb_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/pb_util.cc b/src/kudu/util/pb_util.cc
index 8aaa725..f304582 100644
--- a/src/kudu/util/pb_util.cc
+++ b/src/kudu/util/pb_util.cc
@@ -29,7 +29,6 @@
#include <unordered_set>
#include <vector>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/descriptor.pb.h>
@@ -228,7 +227,7 @@ void TruncateFields(Message* message, int max_len) {
const Reflection* reflection = message->GetReflection();
vector<const FieldDescriptor*> fields;
reflection->ListFields(*message, &fields);
- BOOST_FOREACH(const FieldDescriptor* field, fields) {
+ for (const FieldDescriptor* field : fields) {
if (field->is_repeated()) {
for (int i = 0; i < reflection->FieldSize(*message, field); i++) {
switch (field->cpp_type()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/rolling_log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/rolling_log-test.cc b/src/kudu/util/rolling_log-test.cc
index ef320fe..6f18fa0 100644
--- a/src/kudu/util/rolling_log-test.cc
+++ b/src/kudu/util/rolling_log-test.cc
@@ -17,7 +17,6 @@
#include "kudu/util/rolling_log.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <glog/stl_logging.h>
#include <string>
@@ -52,7 +51,7 @@ class RollingLogTest : public KuduTest {
ASSERT_OK(env_->GetChildren(log_dir_, &dir_entries));
children->clear();
- BOOST_FOREACH(const string& child, dir_entries) {
+ for (const string& child : dir_entries) {
if (child == "." || child == "..") continue;
children->push_back(child);
ASSERT_TRUE(HasPrefixString(child, "rolling_log-test."));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/rw_semaphore-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/rw_semaphore-test.cc b/src/kudu/util/rw_semaphore-test.cc
index 166d58e..16a08e3 100644
--- a/src/kudu/util/rw_semaphore-test.cc
+++ b/src/kudu/util/rw_semaphore-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include <gtest/gtest.h>
-#include <boost/foreach.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/locks.hpp>
#include <vector>
@@ -82,7 +81,7 @@ TEST(RWSemaphoreTest, TestBasicOperation) {
s.done = true;
}
- BOOST_FOREACH(thread* t, threads) {
+ for (thread* t : threads) {
t->join();
delete t;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/rwc_lock-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/rwc_lock-test.cc b/src/kudu/util/rwc_lock-test.cc
index 0029579..af825d8 100644
--- a/src/kudu/util/rwc_lock-test.cc
+++ b/src/kudu/util/rwc_lock-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include <boost/thread/thread.hpp>
-#include <boost/foreach.hpp>
#include <string>
#include <vector>
@@ -134,7 +133,7 @@ TEST_F(RWCLockTest, TestCorrectBehavior) {
Release_Store(&state.stop, 1);
- BOOST_FOREACH(boost::thread* t, threads) {
+ for (boost::thread* t : threads) {
t->join();
delete t;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/slice-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/slice-test.cc b/src/kudu/util/slice-test.cc
index 39dbc47..d4868ac 100644
--- a/src/kudu/util/slice-test.cc
+++ b/src/kudu/util/slice-test.cc
@@ -17,7 +17,6 @@
#include "kudu/util/slice.h"
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/gutil/map-util.h"
@@ -40,7 +39,7 @@ TEST(SliceTest, TestSliceMap) {
InsertOrDie(&my_map, b, 2);
int expectedValue = 0;
- BOOST_FOREACH(const MySliceMap::value_type& pair, my_map) {
+ for (const MySliceMap::value_type& pair : my_map) {
int data = 'a' + expectedValue++;
ASSERT_EQ(Slice(reinterpret_cast<uint8_t*>(&data), 1), pair.first);
ASSERT_EQ(expectedValue, pair.second);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/striped64-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/striped64-test.cc b/src/kudu/util/striped64-test.cc
index 5909c9c..d211a0a 100644
--- a/src/kudu/util/striped64-test.cc
+++ b/src/kudu/util/striped64-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <memory>
@@ -78,7 +77,7 @@ class MultiThreadTest {
num_operations_, &ref);
threads_.push_back(ref);
}
- BOOST_FOREACH(const scoped_refptr<Thread> &t, threads_) {
+ for (const scoped_refptr<Thread> &t : threads_) {
t->Join();
}
ASSERT_EQ(num_threads_*num_operations_, adder_.Value());
@@ -91,7 +90,7 @@ class MultiThreadTest {
num_operations_, &ref);
threads_.push_back(ref);
}
- BOOST_FOREACH(const scoped_refptr<Thread> &t, threads_) {
+ for (const scoped_refptr<Thread> &t : threads_) {
t->Join();
}
ASSERT_EQ(0, adder_.Value());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/subprocess.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/subprocess.cc b/src/kudu/util/subprocess.cc
index 65ef63b..bc801c6 100644
--- a/src/kudu/util/subprocess.cc
+++ b/src/kudu/util/subprocess.cc
@@ -17,7 +17,6 @@
#include "kudu/util/subprocess.h"
-#include <boost/foreach.hpp>
#include <dirent.h>
#include <fcntl.h>
#include <glog/logging.h>
@@ -241,7 +240,7 @@ Status Subprocess::Start() {
}
vector<char*> argv_ptrs;
- BOOST_FOREACH(const string& arg, argv_) {
+ for (const string& arg : argv_) {
argv_ptrs.push_back(const_cast<char*>(arg.c_str()));
}
argv_ptrs.push_back(NULL);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/sync_point.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/sync_point.cc b/src/kudu/util/sync_point.cc
index f79bb78..ded2ff4 100644
--- a/src/kudu/util/sync_point.cc
+++ b/src/kudu/util/sync_point.cc
@@ -22,8 +22,6 @@
#include "kudu/util/sync_point.h"
-#include <boost/foreach.hpp>
-
using std::string;
using std::vector;
@@ -49,14 +47,14 @@ void SyncPoint::LoadDependency(const vector<Dependency>& dependencies) {
successors_.clear();
predecessors_.clear();
cleared_points_.clear();
- BOOST_FOREACH(const Dependency& dependency, dependencies) {
+ for (const Dependency& dependency : dependencies) {
successors_[dependency.predecessor_].push_back(dependency.successor_);
predecessors_[dependency.successor_].push_back(dependency.predecessor_);
}
}
bool SyncPoint::PredecessorsAllCleared(const string& point) {
- BOOST_FOREACH(const string& pred, predecessors_[point]) {
+ for (const string& pred : predecessors_[point]) {
if (cleared_points_.count(pred) == 0) {
return false;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/test_graph.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/test_graph.cc b/src/kudu/util/test_graph.cc
index 74f9c4e..c3dc9e1 100644
--- a/src/kudu/util/test_graph.cc
+++ b/src/kudu/util/test_graph.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include "kudu/gutil/ref_counted.h"
@@ -105,7 +104,7 @@ void TimeSeriesCollector::BuildMetricsString(
dst_buf->append(StringPrintf("{ \"scope\": \"%s\", \"time\": %.3f",
scope_.c_str(), time_since_start));
- BOOST_FOREACH(SeriesMap::const_reference entry, series_map_) {
+ for (SeriesMap::const_reference entry : series_map_) {
dst_buf->append(StringPrintf(", \"%s\": %.3f",
entry.first.c_str(), entry.second->value()));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/thread.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/thread.cc b/src/kudu/util/thread.cc
index 086c940..6ecca47 100644
--- a/src/kudu/util/thread.cc
+++ b/src/kudu/util/thread.cc
@@ -20,7 +20,6 @@
#include "kudu/util/thread.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <map>
#include <memory>
#include <set>
@@ -326,7 +325,7 @@ void ThreadMgr::RemoveThread(const pthread_t& pthread_id, const string& category
void ThreadMgr::PrintThreadCategoryRows(const ThreadCategory& category,
stringstream* output) {
- BOOST_FOREACH(const ThreadCategory::value_type& thread, category) {
+ for (const ThreadCategory::value_type& thread : category) {
ThreadStats stats;
Status status = GetThreadStats(thread.second.thread_id(), &stats);
if (!status.ok()) {
@@ -358,7 +357,7 @@ void ThreadMgr::ThreadPathHandler(const WebCallbackRegistry::WebRequest& req,
(*output) << "<h3>" << category->first << " : " << category->second.size()
<< "</h3>";
} else {
- BOOST_FOREACH(const ThreadCategoryMap::value_type& category, thread_categories_) {
+ for (const ThreadCategoryMap::value_type& category : thread_categories_) {
categories_to_print.push_back(&category.second);
}
(*output) << "<h3>All Threads : </h3>";
@@ -369,7 +368,7 @@ void ThreadMgr::ThreadPathHandler(const WebCallbackRegistry::WebRequest& req,
<< "<th>Cumulative Kernel CPU(s)</th>"
<< "<th>Cumulative IO-wait(s)</th></tr>";
- BOOST_FOREACH(const ThreadCategory* category, categories_to_print) {
+ for (const ThreadCategory* category : categories_to_print) {
PrintThreadCategoryRows(*category, output);
}
(*output) << "</table>";
@@ -380,7 +379,7 @@ void ThreadMgr::ThreadPathHandler(const WebCallbackRegistry::WebRequest& req,
}
(*output) << "<a href='/threadz?group=all'><h3>All Threads</h3>";
- BOOST_FOREACH(const ThreadCategoryMap::value_type& category, thread_categories_) {
+ for (const ThreadCategoryMap::value_type& category : thread_categories_) {
string category_arg;
UrlEncode(category.first, &category_arg);
(*output) << "<a href='/threadz?group=" << category_arg << "'><h3>"
@@ -586,7 +585,7 @@ void* Thread::SuperviseThread(void* arg) {
void Thread::FinishThread(void* arg) {
Thread* t = static_cast<Thread*>(arg);
- BOOST_FOREACH(Closure& c, t->exit_callbacks_) {
+ for (Closure& c : t->exit_callbacks_) {
c.Run();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/threadpool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/threadpool.cc b/src/kudu/util/threadpool.cc
index ca7e061..3f2dfe3 100644
--- a/src/kudu/util/threadpool.cc
+++ b/src/kudu/util/threadpool.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -134,7 +133,7 @@ Status ThreadPool::Init() {
}
void ThreadPool::ClearQueue() {
- BOOST_FOREACH(QueueEntry& e, queue_) {
+ for (QueueEntry& e : queue_) {
if (e.trace) {
e.trace->Release();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/trace-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/trace-test.cc b/src/kudu/util/trace-test.cc
index 12a5bac..049ed90 100644
--- a/src/kudu/util/trace-test.cc
+++ b/src/kudu/util/trace-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <string>
#include <rapidjson/document.h>
@@ -45,7 +44,7 @@ class TraceTest : public KuduTest {
static string XOutDigits(const string& s) {
string ret;
ret.reserve(s.size());
- BOOST_FOREACH(char c, s) {
+ for (char c : s) {
if (isdigit(c)) {
ret.push_back('X');
} else {
@@ -102,7 +101,7 @@ TEST_F(TraceTest, TestChildTrace) {
EXPECT_EQ(XOutDigits(traceA->DumpToString(false)),
"XXXX XX:XX:XX.XXXXXX trace-test.cc:XX] hello from traceA\n"
"Related trace:\n"
- "XXXX XX:XX:XX.XXXXXX trace-test.cc:XXX] hello from traceB\n");
+ "XXXX XX:XX:XX.XXXXXX trace-test.cc:XX] hello from traceB\n");
}
static void GenerateTraceEvents(int thread_id,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/trace.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/trace.cc b/src/kudu/util/trace.cc
index 29e7a8c..af12ad5 100644
--- a/src/kudu/util/trace.cc
+++ b/src/kudu/util/trace.cc
@@ -17,7 +17,6 @@
#include "kudu/util/trace.h"
-#include <boost/foreach.hpp>
#include <iomanip>
#include <ios>
#include <iostream>
@@ -138,7 +137,7 @@ void Trace::Dump(std::ostream* out, bool include_time_deltas) const {
std::ios::fmtflags save_flags(out->flags());
int64_t prev_usecs = 0;
- BOOST_FOREACH(TraceEntry* e, entries) {
+ for (TraceEntry* e : entries) {
// Log format borrowed from glog/logging.cc
time_t secs_since_epoch = e->timestamp_micros / 1000000;
int usecs = e->timestamp_micros % 1000000;
@@ -172,7 +171,7 @@ void Trace::Dump(std::ostream* out, bool include_time_deltas) const {
*out << std::endl;
}
- BOOST_FOREACH(scoped_refptr<Trace> child_trace, child_traces) {
+ for (scoped_refptr<Trace> child_trace : child_traces) {
*out << "Related trace:" << std::endl;
*out << child_trace->DumpToString(include_time_deltas);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/util/url-coding.cc
----------------------------------------------------------------------
diff --git a/src/kudu/util/url-coding.cc b/src/kudu/util/url-coding.cc
index 1dd577d..13052cb 100644
--- a/src/kudu/util/url-coding.cc
+++ b/src/kudu/util/url-coding.cc
@@ -34,7 +34,6 @@
#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/binary_from_base64.hpp>
#include <boost/archive/iterators/transform_width.hpp>
-#include <boost/foreach.hpp>
#include <exception>
#include <sstream>
@@ -193,7 +192,7 @@ bool Base64Decode(const string& in, string* out) {
void EscapeForHtml(const string& in, std::stringstream* out) {
DCHECK(out != NULL);
- BOOST_FOREACH(const char& c, in) {
+ for (const char& c : in) {
switch (c) {
case '<': (*out) << "<";
break;
[5/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Posted by da...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/schema.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema.cc b/src/kudu/common/schema.cc
index 5364172..e722d20 100644
--- a/src/kudu/common/schema.cc
+++ b/src/kudu/common/schema.cc
@@ -103,7 +103,7 @@ void Schema::CopyFrom(const Schema& other) {
// reference the other Schema's ColumnSchema objects.
name_to_index_.clear();
int i = 0;
- BOOST_FOREACH(const ColumnSchema &col, cols_) {
+ for (const ColumnSchema &col : cols_) {
// The map uses the 'name' string from within the ColumnSchema object.
name_to_index_[col.name()] = i++;
}
@@ -156,7 +156,7 @@ Status Schema::Reset(const vector<ColumnSchema>& cols,
size_t off = 0;
size_t i = 0;
name_to_index_.clear();
- BOOST_FOREACH(const ColumnSchema &col, cols_) {
+ for (const ColumnSchema &col : cols_) {
// The map uses the 'name' string from within the ColumnSchema object.
if (!InsertIfNotPresent(&name_to_index_, col.name(), i++)) {
return Status::InvalidArgument("Duplicate column name", col.name());
@@ -183,7 +183,7 @@ Status Schema::Reset(const vector<ColumnSchema>& cols,
// Determine whether any column is nullable
has_nullables_ = false;
- BOOST_FOREACH(const ColumnSchema& col, cols_) {
+ for (const ColumnSchema& col : cols_) {
if (col.is_nullable()) {
has_nullables_ = true;
break;
@@ -197,7 +197,7 @@ Status Schema::CreateProjectionByNames(const std::vector<StringPiece>& col_names
Schema* out) const {
vector<ColumnId> ids;
vector<ColumnSchema> cols;
- BOOST_FOREACH(const StringPiece& name, col_names) {
+ for (const StringPiece& name : col_names) {
int idx = find_column(name);
if (idx == -1) {
return Status::NotFound("column not found", name);
@@ -214,7 +214,7 @@ Status Schema::CreateProjectionByIdsIgnoreMissing(const std::vector<ColumnId>& c
Schema* out) const {
vector<ColumnSchema> cols;
vector<ColumnId> filtered_col_ids;
- BOOST_FOREACH(ColumnId id, col_ids) {
+ for (ColumnId id : col_ids) {
int idx = find_column_by_id(id);
if (idx == -1) {
continue;
@@ -247,7 +247,7 @@ Status Schema::VerifyProjectionCompatibility(const Schema& projection) const {
}
vector<string> missing_columns;
- BOOST_FOREACH(const ColumnSchema& pcol, projection.columns()) {
+ for (const ColumnSchema& pcol : projection.columns()) {
int index = find_column(pcol.name());
if (index < 0) {
missing_columns.push_back(pcol.name());
@@ -283,7 +283,7 @@ Status Schema::GetMappedReadProjection(const Schema& projection,
mapped_cols.reserve(projection.num_columns());
mapped_ids.reserve(projection.num_columns());
- BOOST_FOREACH(const ColumnSchema& col, projection.columns()) {
+ for (const ColumnSchema& col : projection.columns()) {
int index = find_column(col.name());
DCHECK_GE(index, 0) << col.name();
mapped_cols.push_back(cols_[index]);
@@ -301,7 +301,7 @@ string Schema::ToString() const {
col_strs.push_back(strings::Substitute("$0:$1", col_ids_[i], cols_[i].ToString()));
}
} else {
- BOOST_FOREACH(const ColumnSchema &col, cols_) {
+ for (const ColumnSchema &col : cols_) {
col_strs.push_back(col.ToString());
}
}
@@ -350,7 +350,7 @@ string Schema::DebugEncodedRowKey(Slice encoded_key, StartOrEnd start_or_end) co
size_t Schema::memory_footprint_excluding_this() const {
size_t size = kudu_malloc_usable_size(cols_.data());
- BOOST_FOREACH(const ColumnSchema& col, cols_) {
+ for (const ColumnSchema& col : cols_) {
size += col.memory_footprint_excluding_this();
}
@@ -447,7 +447,7 @@ Status SchemaBuilder::RenameColumn(const string& old_name, const string& new_nam
col_names_.erase(it_names); // TODO: Should this one stay and marked as alias?
col_names_.insert(new_name);
- BOOST_FOREACH(ColumnSchema& col_schema, cols_) {
+ for (ColumnSchema& col_schema : cols_) {
if (old_name == col_schema.name()) {
col_schema.set_name(new_name);
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/schema.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema.h b/src/kudu/common/schema.h
index ab45ef3..3788072 100644
--- a/src/kudu/common/schema.h
+++ b/src/kudu/common/schema.h
@@ -17,7 +17,6 @@
#ifndef KUDU_COMMON_SCHEMA_H
#define KUDU_COMMON_SCHEMA_H
-#include <boost/foreach.hpp>
#include <functional>
#include <glog/logging.h>
#include <memory>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/wire_protocol.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/wire_protocol.cc b/src/kudu/common/wire_protocol.cc
index a10ac7d..774afb7 100644
--- a/src/kudu/common/wire_protocol.cc
+++ b/src/kudu/common/wire_protocol.cc
@@ -164,7 +164,7 @@ Status HostPortFromPB(const HostPortPB& host_port_pb, HostPort* host_port) {
Status AddHostPortPBs(const vector<Sockaddr>& addrs,
RepeatedPtrField<HostPortPB>* pbs) {
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
HostPortPB* pb = pbs->Add();
if (addr.IsWildcard()) {
RETURN_NOT_OK(GetFQDN(pb->mutable_host()));
@@ -266,7 +266,7 @@ Status ColumnPBsToSchema(const RepeatedPtrField<ColumnSchemaPB>& column_pbs,
columns.reserve(column_pbs.size());
int num_key_columns = 0;
bool is_handling_key = true;
- BOOST_FOREACH(const ColumnSchemaPB& pb, column_pbs) {
+ for (const ColumnSchemaPB& pb : column_pbs) {
columns.push_back(ColumnSchemaFromPB(pb));
if (pb.is_key()) {
if (!is_handling_key) {
@@ -295,7 +295,7 @@ Status SchemaToColumnPBs(const Schema& schema,
int flags) {
cols->Clear();
int idx = 0;
- BOOST_FOREACH(const ColumnSchema& col, schema.columns()) {
+ for (const ColumnSchema& col : schema.columns()) {
ColumnSchemaPB* col_pb = cols->Add();
ColumnSchemaToPB(col, col_pb);
col_pb->set_is_key(idx < schema.num_key_columns());
@@ -403,7 +403,7 @@ Status ExtractRowsFromRowBlockPB(const Schema& schema,
Status FindLeaderHostPort(const RepeatedPtrField<ServerEntryPB>& entries,
HostPort* leader_hostport) {
- BOOST_FOREACH(const ServerEntryPB& entry, entries) {
+ for (const ServerEntryPB& entry : entries) {
if (entry.has_error()) {
LOG(WARNING) << "Error encountered for server entry " << entry.ShortDebugString()
<< ": " << StatusFromPB(entry.error()).ToString();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/consensus-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus-test-util.h b/src/kudu/consensus/consensus-test-util.h
index a2c5596..8398230 100644
--- a/src/kudu/consensus/consensus-test-util.h
+++ b/src/kudu/consensus/consensus-test-util.h
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <gmock/gmock.h>
#include <map>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus.cc b/src/kudu/consensus/consensus.cc
index 84dab04..b8b30ed 100644
--- a/src/kudu/consensus/consensus.cc
+++ b/src/kudu/consensus/consensus.cc
@@ -17,7 +17,6 @@
#include "kudu/consensus/consensus.h"
-#include <boost/foreach.hpp>
#include <set>
#include "kudu/consensus/log_util.h"
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/consensus_meta-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_meta-test.cc b/src/kudu/consensus/consensus_meta-test.cc
index be6d568..7eb9c2d 100644
--- a/src/kudu/consensus/consensus_meta-test.cc
+++ b/src/kudu/consensus/consensus_meta-test.cc
@@ -18,7 +18,6 @@
#include <vector>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/common/wire_protocol.h"
@@ -136,7 +135,7 @@ TEST_F(ConsensusMetadataTest, TestFlush) {
RaftConfigPB BuildConfig(const vector<string>& uuids) {
RaftConfigPB config;
config.set_local(false);
- BOOST_FOREACH(const string& uuid, uuids) {
+ for (const string& uuid : uuids) {
RaftPeerPB* peer = config.add_peers();
peer->set_permanent_uuid(uuid);
peer->set_member_type(RaftPeerPB::VOTER);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/consensus_queue.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.cc b/src/kudu/consensus/consensus_queue.cc
index 019911f..a4e3b4b 100644
--- a/src/kudu/consensus/consensus_queue.cc
+++ b/src/kudu/consensus/consensus_queue.cc
@@ -17,7 +17,6 @@
#include "kudu/consensus/consensus_queue.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <gflags/gflags.h>
#include <iostream>
@@ -150,7 +149,7 @@ void PeerMessageQueue::SetLeaderMode(const OpId& committed_index,
// Reset last communication time with all peers to reset the clock on the
// failure timeout.
MonoTime now(MonoTime::Now(MonoTime::FINE));
- BOOST_FOREACH(const PeersMap::value_type& entry, peers_map_) {
+ for (const PeersMap::value_type& entry : peers_map_) {
entry.second->last_successful_communication_time = now;
}
}
@@ -203,10 +202,10 @@ void PeerMessageQueue::UntrackPeer(const string& uuid) {
void PeerMessageQueue::CheckPeersInActiveConfigIfLeaderUnlocked() const {
if (queue_state_.mode != LEADER) return;
unordered_set<string> config_peer_uuids;
- BOOST_FOREACH(const RaftPeerPB& peer_pb, queue_state_.active_config->peers()) {
+ for (const RaftPeerPB& peer_pb : queue_state_.active_config->peers()) {
InsertOrDie(&config_peer_uuids, peer_pb.permanent_uuid());
}
- BOOST_FOREACH(const PeersMap::value_type& entry, peers_map_) {
+ for (const PeersMap::value_type& entry : peers_map_) {
if (!ContainsKey(config_peer_uuids, entry.first)) {
LOG_WITH_PREFIX_UNLOCKED(FATAL) << Substitute("Peer $0 is not in the active config. "
"Queue state: $1",
@@ -362,7 +361,7 @@ Status PeerMessageQueue::RequestForPeer(const string& uuid,
// "all replicated" point. At some point we may want to allow partially loading
// (and not pinning) earlier messages. At that point we'll need to do something
// smarter here, like copy or ref-count.
- BOOST_FOREACH(const ReplicateRefPtr& msg, messages) {
+ for (const ReplicateRefPtr& msg : messages) {
request->mutable_ops()->AddAllocated(msg->get());
}
msg_refs->swap(messages);
@@ -435,7 +434,7 @@ void PeerMessageQueue::AdvanceQueueWatermark(const char* type,
// - Find the vector.size() - 'num_peers_required' position, this
// will be the new 'watermark'.
vector<const OpId*> watermarks;
- BOOST_FOREACH(const PeersMap::value_type& peer, peers_map_) {
+ for (const PeersMap::value_type& peer : peers_map_) {
if (peer.second->is_last_exchange_successful) {
watermarks.push_back(&peer.second->last_received);
}
@@ -456,11 +455,11 @@ void PeerMessageQueue::AdvanceQueueWatermark(const char* type,
<< "from " << old_watermark << " to " << new_watermark;
if (VLOG_IS_ON(3)) {
VLOG_WITH_PREFIX_UNLOCKED(3) << "Peers: ";
- BOOST_FOREACH(const PeersMap::value_type& peer, peers_map_) {
+ for (const PeersMap::value_type& peer : peers_map_) {
VLOG_WITH_PREFIX_UNLOCKED(3) << "Peer: " << peer.second->ToString();
}
VLOG_WITH_PREFIX_UNLOCKED(3) << "Sorted watermarks:";
- BOOST_FOREACH(const OpId* watermark, watermarks) {
+ for (const OpId* watermark : watermarks) {
VLOG_WITH_PREFIX_UNLOCKED(3) << "Watermark: " << watermark->ShortDebugString();
}
}
@@ -686,7 +685,7 @@ void PeerMessageQueue::DumpToStrings(vector<string>* lines) const {
void PeerMessageQueue::DumpToStringsUnlocked(vector<string>* lines) const {
lines->push_back("Watermarks:");
- BOOST_FOREACH(const PeersMap::value_type& entry, peers_map_) {
+ for (const PeersMap::value_type& entry : peers_map_) {
lines->push_back(
Substitute("Peer: $0 Watermark: $1", entry.first, entry.second->ToString()));
}
@@ -701,7 +700,7 @@ void PeerMessageQueue::DumpToHtml(std::ostream& out) const {
out << "<h3>Watermarks</h3>" << endl;
out << "<table>" << endl;;
out << " <tr><th>Peer</th><th>Watermark</th></tr>" << endl;
- BOOST_FOREACH(const PeersMap::value_type& entry, peers_map_) {
+ for (const PeersMap::value_type& entry : peers_map_) {
out << Substitute(" <tr><td>$0</td><td>$1</td></tr>",
EscapeForHtmlToString(entry.first),
EscapeForHtmlToString(entry.second->ToString())) << endl;
@@ -800,7 +799,7 @@ void PeerMessageQueue::NotifyObserversOfMajorityReplOpChangeTask(
// TODO move commit index advancement here so that the queue is not dependent on
// consensus at all, but that requires a bit more work.
OpId new_committed_index;
- BOOST_FOREACH(PeerMessageQueueObserver* observer, copy) {
+ for (PeerMessageQueueObserver* observer : copy) {
observer->UpdateMajorityReplicated(new_majority_replicated_op, &new_committed_index);
}
@@ -821,7 +820,7 @@ void PeerMessageQueue::NotifyObserversOfTermChangeTask(int64_t term) {
copy = observers_;
}
OpId new_committed_index;
- BOOST_FOREACH(PeerMessageQueueObserver* observer, copy) {
+ for (PeerMessageQueueObserver* observer : copy) {
observer->NotifyTermChange(term);
}
}
@@ -845,7 +844,7 @@ void PeerMessageQueue::NotifyObserversOfFailedFollowerTask(const string& uuid,
observers_copy = observers_;
}
OpId new_committed_index;
- BOOST_FOREACH(PeerMessageQueueObserver* observer, observers_copy) {
+ for (PeerMessageQueueObserver* observer : observers_copy) {
observer->NotifyFailedFollower(uuid, term, reason);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/leader_election-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election-test.cc b/src/kudu/consensus/leader_election-test.cc
index e1a1a18..58b7014 100644
--- a/src/kudu/consensus/leader_election-test.cc
+++ b/src/kudu/consensus/leader_election-test.cc
@@ -17,7 +17,6 @@
#include "kudu/consensus/leader_election.h"
-#include <boost/foreach.hpp>
#include <string>
#include <vector>
@@ -135,7 +134,7 @@ void LeaderElectionTest::InitUUIDs(int num_voters) {
void LeaderElectionTest::InitNoOpPeerProxies() {
config_.Clear();
- BOOST_FOREACH(const string& uuid, voter_uuids_) {
+ for (const string& uuid : voter_uuids_) {
RaftPeerPB* peer_pb = config_.add_peers();
peer_pb->set_permanent_uuid(uuid);
PeerProxy* proxy = new NoOpTestPeerProxy(pool_.get(), *peer_pb);
@@ -145,7 +144,7 @@ void LeaderElectionTest::InitNoOpPeerProxies() {
void LeaderElectionTest::InitDelayableMockedProxies(bool enable_delay) {
config_.Clear();
- BOOST_FOREACH(const string& uuid, voter_uuids_) {
+ for (const string& uuid : voter_uuids_) {
RaftPeerPB* peer_pb = config_.add_peers();
peer_pb->set_permanent_uuid(uuid);
DelayablePeerProxy<MockedPeerProxy>* proxy =
@@ -265,7 +264,7 @@ scoped_refptr<LeaderElection> LeaderElectionTest::SetUpElectionWithGrantDenyErro
TEST_F(LeaderElectionTest, TestPerfectElection) {
// Try configuration sizes of 1, 3, 5.
vector<int> config_sizes = { 1, 3, 5 };
- BOOST_FOREACH(int num_voters, config_sizes) {
+ for (int num_voters : config_sizes) {
LOG(INFO) << "Testing election with config size of " << num_voters;
int majority_size = (num_voters / 2) + 1;
ConsensusTerm election_term = 10 + num_voters; // Just to be able to differentiate.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/leader_election.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election.cc b/src/kudu/consensus/leader_election.cc
index 6d7131e..20fea08 100644
--- a/src/kudu/consensus/leader_election.cc
+++ b/src/kudu/consensus/leader_election.cc
@@ -18,7 +18,6 @@
#include "kudu/consensus/leader_election.h"
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include "kudu/consensus/consensus_peers.h"
#include "kudu/consensus/metadata.pb.h"
@@ -163,7 +162,7 @@ LeaderElection::LeaderElection(const RaftConfigPB& config,
timeout_(timeout),
decision_callback_(decision_callback) {
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (request.candidate_uuid() == peer.permanent_uuid()) continue;
follower_uuids_.push_back(peer.permanent_uuid());
@@ -197,7 +196,7 @@ void LeaderElection::Run() {
CheckForDecision();
// The rest of the code below is for a typical multi-node configuration.
- BOOST_FOREACH(const std::string& voter_uuid, follower_uuids_) {
+ for (const std::string& voter_uuid : follower_uuids_) {
VoterState* state = NULL;
{
lock_guard<Lock> guard(&lock_);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/local_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/local_consensus.cc b/src/kudu/consensus/local_consensus.cc
index 892a507..b378bf3 100644
--- a/src/kudu/consensus/local_consensus.cc
+++ b/src/kudu/consensus/local_consensus.cc
@@ -83,7 +83,7 @@ Status LocalConsensus::Start(const ConsensusBootstrapInfo& info) {
}
Status LocalConsensus::ResubmitOrphanedReplicates(const std::vector<ReplicateMsg*> replicates) {
- BOOST_FOREACH(ReplicateMsg* msg, replicates) {
+ for (ReplicateMsg* msg : replicates) {
DCHECK_LT(msg->id().index(), next_op_id_index_)
<< "Orphaned replicate " << OpIdToString(msg->id())
<< " is newer than next op index " << next_op_id_index_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log-dump.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-dump.cc b/src/kudu/consensus/log-dump.cc
index 05209c1..8448ba8 100644
--- a/src/kudu/consensus/log-dump.cc
+++ b/src/kudu/consensus/log-dump.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <iostream>
@@ -120,7 +119,7 @@ Status PrintDecodedWriteRequestPB(const string& indent,
}
int i = 0;
- BOOST_FOREACH(const DecodedRowOperation& op, ops) {
+ for (const DecodedRowOperation& op : ops) {
// TODO (KUDU-515): Handle the case when a tablet's schema changes
// mid-segment.
cout << indent << "op " << (i++) << ": " << op.ToString(tablet_schema) << endl;
@@ -163,7 +162,7 @@ Status PrintSegment(const scoped_refptr<ReadableLogSegment>& segment) {
Schema tablet_schema;
RETURN_NOT_OK(SchemaFromPB(segment->header().schema(), &tablet_schema));
- BOOST_FOREACH(LogEntryPB* entry, entries) {
+ for (LogEntryPB* entry : entries) {
if (print_type == PRINT_PB) {
if (FLAGS_truncate_data > 0) {
@@ -200,7 +199,7 @@ Status DumpLog(const string& tablet_id) {
SegmentSequence segments;
RETURN_NOT_OK(reader->GetSegmentsSnapshot(&segments));
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments) {
RETURN_NOT_OK(PrintSegment(segment));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-test-base.h b/src/kudu/consensus/log-test-base.h
index 067e843..080811d 100644
--- a/src/kudu/consensus/log-test-base.h
+++ b/src/kudu/consensus/log-test-base.h
@@ -19,7 +19,6 @@
#include "kudu/consensus/log.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -172,7 +171,7 @@ class LogTestBase : public KuduTest {
kTestTablet),
&files));
int count = 0;
- BOOST_FOREACH(const string& s, files) {
+ for (const string& s : files) {
if (HasPrefixString(s, FsManager::kWalFileNamePrefix)) {
count++;
}
@@ -181,7 +180,7 @@ class LogTestBase : public KuduTest {
}
void EntriesToIdList(vector<uint32_t>* ids) {
- BOOST_FOREACH(const LogEntryPB* entry, entries_) {
+ for (const LogEntryPB* entry : entries_) {
VLOG(2) << "Entry contents: " << entry->DebugString();
if (entry->type() == REPLICATE) {
ids->push_back(entry->replicate().id().index());
@@ -314,7 +313,7 @@ class LogTestBase : public KuduTest {
string DumpSegmentsToString(const SegmentSequence& segments) {
string dump;
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments) {
dump.append("------------\n");
strings::SubstituteAndAppend(&dump, "Segment: $0, Path: $1\n",
segment->header().sequence_number(), segment->path());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-test.cc b/src/kudu/consensus/log-test.cc
index 703e5fa..157d70b 100644
--- a/src/kudu/consensus/log-test.cc
+++ b/src/kudu/consensus/log-test.cc
@@ -17,7 +17,6 @@
#include <algorithm>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <glog/stl_logging.h>
#include <vector>
@@ -364,7 +363,7 @@ TEST_F(LogTest, TestSegmentRollover) {
ASSERT_OK(log_->GetLogReader()->GetSegmentsSnapshot(&segments));
ASSERT_TRUE(segments.back()->HasFooter());
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& entry, segments) {
+ for (const scoped_refptr<ReadableLogSegment>& entry : segments) {
Status s = entry->ReadEntries(&entries_);
if (!s.ok()) {
FAIL() << "Failed to read entries in segment: " << entry->path()
@@ -693,7 +692,7 @@ TEST_F(LogTest, TestWriteManyBatches) {
vector<scoped_refptr<ReadableLogSegment> > segments;
ASSERT_OK(log_->GetLogReader()->GetSegmentsSnapshot(&segments));
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment> entry, segments) {
+ for (const scoped_refptr<ReadableLogSegment> entry : segments) {
STLDeleteElements(&entries_);
ASSERT_OK(entry->ReadEntries(&entries_));
num_entries += entries_.size();
@@ -865,7 +864,7 @@ void LogTest::GenerateTestSequence(Random* rng, int seq_len,
}
void LogTest::AppendTestSequence(const vector<TestLogSequenceElem>& seq) {
- BOOST_FOREACH(const TestLogSequenceElem& e, seq) {
+ for (const TestLogSequenceElem& e : seq) {
VLOG(1) << "Appending: " << e;
switch (e.type) {
case TestLogSequenceElem::REPLICATE:
@@ -941,7 +940,7 @@ TEST_F(LogTest, TestReadLogWithReplacedReplicates) {
start_index, end_index, LogReader::kNoSizeLimit, &repls));
ASSERT_EQ(end_index - start_index + 1, repls.size());
int expected_index = start_index;
- BOOST_FOREACH(const ReplicateMsg* repl, repls) {
+ for (const ReplicateMsg* repl : repls) {
ASSERT_EQ(expected_index, repl->id().index());
ASSERT_EQ(terms_by_index[expected_index], repl->id().term());
expected_index++;
@@ -966,7 +965,7 @@ TEST_F(LogTest, TestReadLogWithReplacedReplicates) {
ASSERT_LE(repls.size(), end_index - start_index + 1);
int total_size = 0;
int expected_index = start_index;
- BOOST_FOREACH(const ReplicateMsg* repl, repls) {
+ for (const ReplicateMsg* repl : repls) {
ASSERT_EQ(expected_index, repl->id().index());
ASSERT_EQ(terms_by_index[expected_index], repl->id().term());
expected_index++;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log.cc b/src/kudu/consensus/log.cc
index fac45d9..89630d6 100644
--- a/src/kudu/consensus/log.cc
+++ b/src/kudu/consensus/log.cc
@@ -178,7 +178,7 @@ void Log::AppendThread::RunThread() {
SCOPED_LATENCY_METRIC(log_->metrics_, group_commit_latency);
bool is_all_commits = true;
- BOOST_FOREACH(LogEntryBatch* entry_batch, entry_batches) {
+ for (LogEntryBatch* entry_batch : entry_batches) {
entry_batch->WaitForReady();
TRACE_EVENT_FLOW_END0("log", "Batch", entry_batch);
Status s = log_->DoAppend(entry_batch);
@@ -206,7 +206,7 @@ void Log::AppendThread::RunThread() {
if (PREDICT_FALSE(!s.ok())) {
LOG(ERROR) << "Error syncing log" << s.ToString();
DLOG(FATAL) << "Aborting: " << s.ToString();
- BOOST_FOREACH(LogEntryBatch* entry_batch, entry_batches) {
+ for (LogEntryBatch* entry_batch : entry_batches) {
if (!entry_batch->callback().is_null()) {
entry_batch->callback().Run(s);
}
@@ -215,7 +215,7 @@ void Log::AppendThread::RunThread() {
TRACE_EVENT0("log", "Callbacks");
VLOG(2) << "Synchronized " << entry_batches.size() << " entry batches";
SCOPED_WATCH_STACK(100);
- BOOST_FOREACH(LogEntryBatch* entry_batch, entry_batches) {
+ for (LogEntryBatch* entry_batch : entry_batches) {
if (PREDICT_TRUE(!entry_batch->failed_to_append()
&& !entry_batch->callback().is_null())) {
entry_batch->callback().Run(Status::OK());
@@ -400,7 +400,7 @@ Status Log::Reserve(LogEntryTypePB type,
// In DEBUG builds, verify that all of the entries in the batch match the specified type.
// In non-debug builds the foreach loop gets optimized out.
#ifndef NDEBUG
- BOOST_FOREACH(const LogEntryPB& entry, entry_batch->entry()) {
+ for (const LogEntryPB& entry : entry_batch->entry()) {
DCHECK_EQ(entry.type(), type) << "Bad batch: " << entry_batch->DebugString();
}
#endif
@@ -553,7 +553,7 @@ Status Log::UpdateIndexForBatch(const LogEntryBatch& batch,
return Status::OK();
}
- BOOST_FOREACH(const LogEntryPB& entry_pb, batch.entry_batch_pb_->entry()) {
+ for (const LogEntryPB& entry_pb : batch.entry_batch_pb_->entry()) {
LogIndexEntry index_entry;
index_entry.op_id = entry_pb.replicate().id();
@@ -574,7 +574,7 @@ void Log::UpdateFooterForBatch(LogEntryBatch* batch) {
// immediately.
if (batch->type_ == REPLICATE) {
// Update the index bounds for the current segment.
- BOOST_FOREACH(const LogEntryPB& entry_pb, batch->entry_batch_pb_->entry()) {
+ for (const LogEntryPB& entry_pb : batch->entry_batch_pb_->entry()) {
int64_t index = entry_pb.replicate().id().index();
if (!footer_builder_.has_min_replicate_index() ||
index < footer_builder_.min_replicate_index()) {
@@ -735,7 +735,7 @@ Status Log::GC(int64_t min_op_idx, int32_t* num_gced) {
// Now that they are no longer referenced by the Log, delete the files.
*num_gced = 0;
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments_to_delete) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments_to_delete) {
LOG(INFO) << "Deleting log segment in path: " << segment->path()
<< " (GCed ops < " << min_op_idx << ")";
RETURN_NOT_OK(fs_manager_->env()->DeleteFile(segment->path()));
@@ -765,7 +765,7 @@ void Log::GetGCableDataSize(int64_t min_op_idx, int64_t* total_size) const {
return;
}
}
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments_to_delete) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments_to_delete) {
*total_size += segment->file_size();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log_anchor_registry.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_anchor_registry.cc b/src/kudu/consensus/log_anchor_registry.cc
index 7d58f5d..6e6c399 100644
--- a/src/kudu/consensus/log_anchor_registry.cc
+++ b/src/kudu/consensus/log_anchor_registry.cc
@@ -18,7 +18,6 @@
#include "kudu/consensus/log_anchor_registry.h"
#include "kudu/consensus/opid_util.h"
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <string>
@@ -89,7 +88,7 @@ std::string LogAnchorRegistry::DumpAnchorInfo() const {
string buf;
boost::lock_guard<simple_spinlock> l(lock_);
MonoTime now = MonoTime::Now(MonoTime::FINE);
- BOOST_FOREACH(const AnchorMultiMap::value_type& entry, anchors_) {
+ for (const AnchorMultiMap::value_type& entry : anchors_) {
const LogAnchor* anchor = entry.second;
DCHECK(anchor->is_registered);
if (!buf.empty()) buf += ", ";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log_cache.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_cache.cc b/src/kudu/consensus/log_cache.cc
index 08177df..8f92ab4 100644
--- a/src/kudu/consensus/log_cache.cc
+++ b/src/kudu/consensus/log_cache.cc
@@ -18,7 +18,6 @@
#include "kudu/consensus/log_cache.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/wire_format_lite_inl.h>
@@ -307,7 +306,7 @@ Status LogCache::ReadOps(int64_t after_op_index,
LOG_WITH_PREFIX_UNLOCKED(INFO) << "Successfully read " << raw_replicate_ptrs.size() << " ops "
<< "from disk.";
- BOOST_FOREACH(ReplicateMsg* msg, raw_replicate_ptrs) {
+ for (ReplicateMsg* msg : raw_replicate_ptrs) {
CHECK_EQ(next_index, msg->id().index());
remaining_space -= TotalByteSizeForMessage(*msg);
@@ -431,7 +430,7 @@ std::string LogCache::LogPrefixUnlocked() const {
void LogCache::DumpToLog() const {
vector<string> strings;
DumpToStrings(&strings);
- BOOST_FOREACH(const string& s, strings) {
+ for (const string& s : strings) {
LOG_WITH_PREFIX_UNLOCKED(INFO) << s;
}
}
@@ -441,7 +440,7 @@ void LogCache::DumpToStrings(vector<string>* lines) const {
int counter = 0;
lines->push_back(ToStringUnlocked());
lines->push_back("Messages:");
- BOOST_FOREACH(const MessageCache::value_type& entry, cache_) {
+ for (const MessageCache::value_type& entry : cache_) {
const ReplicateMsg* msg = entry.second->get();
lines->push_back(
Substitute("Message[$0] $1.$2 : REPLICATE. Type: $3, Size: $4",
@@ -460,7 +459,7 @@ void LogCache::DumpToHtml(std::ostream& out) const {
out << "<tr><th>Entry</th><th>OpId</th><th>Type</th><th>Size</th><th>Status</th></tr>" << endl;
int counter = 0;
- BOOST_FOREACH(const MessageCache::value_type& entry, cache_) {
+ for (const MessageCache::value_type& entry : cache_) {
const ReplicateMsg* msg = entry.second->get();
out << Substitute("<tr><th>$0</th><th>$1.$2</th><td>REPLICATE $3</td>"
"<td>$4</td><td>$5</td></tr>",
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log_index.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_index.cc b/src/kudu/consensus/log_index.cc
index 6d25f3a..1b99b2b 100644
--- a/src/kudu/consensus/log_index.cc
+++ b/src/kudu/consensus/log_index.cc
@@ -28,7 +28,6 @@
#include "kudu/consensus/log_index.h"
-#include <boost/foreach.hpp>
#include <fcntl.h>
#include <string>
#include <sys/mman.h>
@@ -256,7 +255,7 @@ void LogIndex::GC(int64_t min_index_to_retain) {
}
// Outside of the lock, try to delete them (avoid holding the lock during IO).
- BOOST_FOREACH(int64_t chunk_idx, chunks_to_delete) {
+ for (int64_t chunk_idx : chunks_to_delete) {
string path = GetChunkPath(chunk_idx);
int rc = unlink(path.c_str());
if (rc != 0) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log_reader.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_reader.cc b/src/kudu/consensus/log_reader.cc
index c56cd6b..131d91a 100644
--- a/src/kudu/consensus/log_reader.cc
+++ b/src/kudu/consensus/log_reader.cc
@@ -17,7 +17,6 @@
#include "kudu/consensus/log_reader.h"
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <algorithm>
@@ -139,7 +138,7 @@ Status LogReader::Init(const string& tablet_wal_path) {
SegmentSequence read_segments;
// build a log segment from each file
- BOOST_FOREACH(const string &log_file, log_files) {
+ for (const string &log_file : log_files) {
if (HasPrefixString(log_file, FsManager::kWalFileNamePrefix)) {
string fqp = JoinPathSegments(tablet_wal_path, log_file);
scoped_refptr<ReadableLogSegment> segment;
@@ -167,7 +166,7 @@ Status LogReader::Init(const string& tablet_wal_path) {
string previous_seg_path;
int64_t previous_seg_seqno = -1;
- BOOST_FOREACH(const SegmentSequence::value_type& entry, read_segments) {
+ for (const SegmentSequence::value_type& entry : read_segments) {
VLOG(1) << " Log Reader Indexed: " << entry->footer().ShortDebugString();
// Check that the log segments are in sequence.
if (previous_seg_seqno != -1 && entry->header().sequence_number() != previous_seg_seqno + 1) {
@@ -203,7 +202,7 @@ Status LogReader::GetSegmentPrefixNotIncluding(int64_t index,
boost::lock_guard<simple_spinlock> lock(lock_);
CHECK_EQ(state_, kLogReaderReading);
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments_) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments_) {
// The last segment doesn't have a footer. Never include that one.
if (!segment->HasFooter()) {
break;
@@ -222,7 +221,7 @@ int64_t LogReader::GetMinReplicateIndex() const {
boost::lock_guard<simple_spinlock> lock(lock_);
int64_t min_remaining_op_idx = -1;
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments_) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments_) {
if (!segment->HasFooter()) continue;
if (!segment->footer().has_min_replicate_index()) continue;
if (min_remaining_op_idx == -1 ||
@@ -239,7 +238,7 @@ void LogReader::GetMaxIndexesToSegmentSizeMap(int64_t min_op_idx, int32_t segmen
max_idx_to_segment_size) const {
boost::lock_guard<simple_spinlock> lock(lock_);
DCHECK_GE(segments_count, 0);
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments_) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments_) {
if (max_idx_to_segment_size->size() == segments_count) {
break;
}
@@ -486,7 +485,7 @@ const int LogReader::num_segments() const {
string LogReader::ToString() const {
boost::lock_guard<simple_spinlock> lock(lock_);
string ret = "Reader's SegmentSequence: \n";
- BOOST_FOREACH(const SegmentSequence::value_type& entry, segments_) {
+ for (const SegmentSequence::value_type& entry : segments_) {
ret.append(Substitute("Segment: $0 Footer: $1\n",
entry->header().sequence_number(),
!entry->HasFooter() ? "NONE" : entry->footer().ShortDebugString()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/log_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_util.cc b/src/kudu/consensus/log_util.cc
index 815a080..c29d628 100644
--- a/src/kudu/consensus/log_util.cc
+++ b/src/kudu/consensus/log_util.cc
@@ -22,7 +22,6 @@
#include <limits>
#include <utility>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -198,7 +197,7 @@ Status ReadableLogSegment::RebuildFooterByScanning() {
footer_.set_num_entries(entries.size());
// Rebuild the min/max replicate index (by scanning)
- BOOST_FOREACH(const LogEntryPB* entry, entries) {
+ for (const LogEntryPB* entry : entries) {
if (entry->has_replicate()) {
int64_t index = entry->replicate().id().index();
// TODO: common code with Log::UpdateFooterForBatch
@@ -568,7 +567,7 @@ Status ReadableLogSegment::MakeCorruptionStatus(int batch_number, int64_t batch_
batch_number, batch_offset, path_);
err.append("Prior batch offsets:");
std::sort(recent_offsets->begin(), recent_offsets->end());
- BOOST_FOREACH(int64_t offset, *recent_offsets) {
+ for (int64_t offset : *recent_offsets) {
if (offset >= 0) {
SubstituteAndAppend(&err, " $0", offset);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/mt-log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/mt-log-test.cc b/src/kudu/consensus/mt-log-test.cc
index bf8f6f1..18d57d5 100644
--- a/src/kudu/consensus/mt-log-test.cc
+++ b/src/kudu/consensus/mt-log-test.cc
@@ -125,7 +125,7 @@ class MultiThreadedLogTest : public LogTestBase {
thread_id, FLAGS_num_batches_per_thread)) {
latch.Wait();
}
- BOOST_FOREACH(const Status& status, errors) {
+ for (const Status& status : errors) {
WARN_NOT_OK(status, "Unexpected failure during AsyncAppend");
}
ASSERT_EQ(0, errors.size());
@@ -138,7 +138,7 @@ class MultiThreadedLogTest : public LogTestBase {
&MultiThreadedLogTest::LogWriterThread, this, i, &new_thread));
threads_.push_back(new_thread);
}
- BOOST_FOREACH(scoped_refptr<kudu::Thread>& thread, threads_) {
+ for (scoped_refptr<kudu::Thread>& thread : threads_) {
ASSERT_OK(ThreadJoiner(thread.get()).Join());
}
}
@@ -161,7 +161,7 @@ TEST_F(MultiThreadedLogTest, TestAppends) {
SegmentSequence segments;
ASSERT_OK(log_->GetLogReader()->GetSegmentsSnapshot(&segments));
- BOOST_FOREACH(const SegmentSequence::value_type& entry, segments) {
+ for (const SegmentSequence::value_type& entry : segments) {
ASSERT_OK(entry->ReadEntries(&entries_));
}
vector<uint32_t> ids;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/peer_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/peer_manager.cc b/src/kudu/consensus/peer_manager.cc
index d342ce0..b00a7ad 100644
--- a/src/kudu/consensus/peer_manager.cc
+++ b/src/kudu/consensus/peer_manager.cc
@@ -55,7 +55,7 @@ Status PeerManager::UpdateRaftConfig(const RaftConfigPB& config) {
boost::lock_guard<simple_spinlock> lock(lock_);
// Create new peers
- BOOST_FOREACH(const RaftPeerPB& peer_pb, config.peers()) {
+ for (const RaftPeerPB& peer_pb : config.peers()) {
new_peers.insert(peer_pb.permanent_uuid());
Peer* peer = FindPtrOrNull(peers_, peer_pb.permanent_uuid());
if (peer != NULL) {
@@ -100,7 +100,7 @@ void PeerManager::SignalRequest(bool force_if_queue_empty) {
void PeerManager::Close() {
{
boost::lock_guard<simple_spinlock> lock(lock_);
- BOOST_FOREACH(const PeersMap::value_type& entry, peers_) {
+ for (const PeersMap::value_type& entry : peers_) {
entry.second->Close();
}
STLDeleteValues(&peers_);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/quorum_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/quorum_util.cc b/src/kudu/consensus/quorum_util.cc
index efa9848..ef93934 100644
--- a/src/kudu/consensus/quorum_util.cc
+++ b/src/kudu/consensus/quorum_util.cc
@@ -16,7 +16,6 @@
// under the License.
#include "kudu/consensus/quorum_util.h"
-#include <boost/foreach.hpp>
#include <set>
#include <string>
@@ -32,7 +31,7 @@ using std::string;
using strings::Substitute;
bool IsRaftConfigMember(const std::string& uuid, const RaftConfigPB& config) {
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (peer.permanent_uuid() == uuid) {
return true;
}
@@ -41,7 +40,7 @@ bool IsRaftConfigMember(const std::string& uuid, const RaftConfigPB& config) {
}
bool IsRaftConfigVoter(const std::string& uuid, const RaftConfigPB& config) {
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (peer.permanent_uuid() == uuid) {
return peer.member_type() == RaftPeerPB::VOTER;
}
@@ -52,7 +51,7 @@ bool IsRaftConfigVoter(const std::string& uuid, const RaftConfigPB& config) {
Status GetRaftConfigMember(const RaftConfigPB& config,
const std::string& uuid,
RaftPeerPB* peer_pb) {
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (peer.permanent_uuid() == uuid) {
*peer_pb = peer;
return Status::OK();
@@ -71,7 +70,7 @@ Status GetRaftConfigLeader(const ConsensusStatePB& cstate, RaftPeerPB* peer_pb)
bool RemoveFromRaftConfig(RaftConfigPB* config, const string& uuid) {
RepeatedPtrField<RaftPeerPB> modified_peers;
bool removed = false;
- BOOST_FOREACH(const RaftPeerPB& peer, config->peers()) {
+ for (const RaftPeerPB& peer : config->peers()) {
if (peer.permanent_uuid() == uuid) {
removed = true;
continue;
@@ -85,7 +84,7 @@ bool RemoveFromRaftConfig(RaftConfigPB* config, const string& uuid) {
int CountVoters(const RaftConfigPB& config) {
int voters = 0;
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (peer.member_type() == RaftPeerPB::VOTER) {
voters++;
}
@@ -107,7 +106,7 @@ RaftPeerPB::Role GetConsensusRole(const std::string& permanent_uuid,
return RaftPeerPB::NON_PARTICIPANT;
}
- BOOST_FOREACH(const RaftPeerPB& peer, cstate.config().peers()) {
+ for (const RaftPeerPB& peer : cstate.config().peers()) {
if (peer.permanent_uuid() == permanent_uuid) {
switch (peer.member_type()) {
case RaftPeerPB::VOTER:
@@ -167,7 +166,7 @@ Status VerifyRaftConfig(const RaftConfigPB& config, RaftConfigState type) {
return Status::OK();
}
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
if (!peer.has_permanent_uuid() || peer.permanent_uuid() == "") {
return Status::IllegalState(Substitute("One peer didn't have an uuid or had the empty"
" string. RaftConfig: $0", config.ShortDebugString()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/raft_consensus-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus-test.cc b/src/kudu/consensus/raft_consensus-test.cc
index 0df4d50..1876bcf 100644
--- a/src/kudu/consensus/raft_consensus-test.cc
+++ b/src/kudu/consensus/raft_consensus-test.cc
@@ -285,7 +285,7 @@ class RaftConsensusTest : public KuduTest {
void DumpRounds() {
LOG(INFO) << "Dumping rounds...";
- BOOST_FOREACH(const scoped_refptr<ConsensusRound>& round, rounds_) {
+ for (const scoped_refptr<ConsensusRound>& round : rounds_) {
LOG(INFO) << "Round: OpId " << round->id() << ", ReplicateMsg: "
<< round->replicate_msg()->ShortDebugString();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/raft_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 06952d1..7607630 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -269,7 +269,7 @@ Status RaftConsensus::Start(const ConsensusBootstrapInfo& info) {
<< info.orphaned_replicates.size()
<< " pending transactions. Active config: "
<< state_->GetActiveConfigUnlocked().ShortDebugString();
- BOOST_FOREACH(ReplicateMsg* replicate, info.orphaned_replicates) {
+ for (ReplicateMsg* replicate : info.orphaned_replicates) {
ReplicateRefPtr replicate_ptr = make_scoped_refptr_replicate(new ReplicateMsg(*replicate));
RETURN_NOT_OK(StartReplicaTransactionUnlocked(replicate_ptr));
}
@@ -859,7 +859,7 @@ Status RaftConsensus::CheckLeaderRequestUnlocked(const ConsensusRequestPB* reque
// we initialize raft_consensus-state is preventing us from doing so.
Status s;
const OpId* prev = deduped_req->preceding_opid;
- BOOST_FOREACH(const ReplicateRefPtr& message, deduped_req->messages) {
+ for (const ReplicateRefPtr& message : deduped_req->messages) {
s = ReplicaState::CheckOpInSequence(*prev, message->get()->id());
if (PREDICT_FALSE(!s.ok())) {
LOG(ERROR) << "Leader request contained out-of-sequence messages. Status: "
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/raft_consensus_quorum-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc
index a835ee4..1b3ecba 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/common/schema.h"
@@ -196,7 +195,7 @@ class RaftConsensusQuorumTest : public KuduTest {
ConsensusBootstrapInfo boot_info;
TestPeerMap all_peers = peers_->GetPeerMapCopy();
- BOOST_FOREACH(const TestPeerMap::value_type& entry, all_peers) {
+ for (const TestPeerMap::value_type& entry : all_peers) {
RETURN_NOT_OK(entry.second->Start(boot_info));
}
return Status::OK();
@@ -226,7 +225,7 @@ class RaftConsensusQuorumTest : public KuduTest {
CHECK_OK(peers_->GetPeerByIdx(peer_idx, &follower));
scoped_refptr<RaftConsensus> leader;
CHECK_OK(peers_->GetPeerByIdx(leader_idx, &leader));
- BOOST_FOREACH(LocalTestPeerProxy* proxy, down_cast<LocalTestPeerProxyFactory*>(
+ for (LocalTestPeerProxy* proxy : down_cast<LocalTestPeerProxyFactory*>(
leader->peer_proxy_factory_.get())->GetProxies()) {
if (proxy->GetTarget() == follower->peer_uuid()) {
return proxy;
@@ -339,7 +338,7 @@ class RaftConsensusQuorumTest : public KuduTest {
vector<string> lines;
scoped_refptr<RaftConsensus> leader;
CHECK_OK(peers_->GetPeerByIdx(leader_idx, &leader));
- BOOST_FOREACH(const string& line, lines) {
+ for (const string& line : lines) {
LOG(ERROR) << line;
}
@@ -398,7 +397,7 @@ class RaftConsensusQuorumTest : public KuduTest {
TestPeerMap all_peers = peers_->GetPeerMapCopy();
int i = 0;
- BOOST_FOREACH(const TestPeerMap::value_type& entry, all_peers) {
+ for (const TestPeerMap::value_type& entry : all_peers) {
if (entry.second->peer_uuid() != leader->peer_uuid()) {
WaitForReplicateIfNotAlreadyPresent(*last_op_id, i);
}
@@ -421,7 +420,7 @@ class RaftConsensusQuorumTest : public KuduTest {
log::SegmentSequence segments;
ASSERT_OK(log_reader->GetSegmentsSnapshot(&segments));
- BOOST_FOREACH(const log::SegmentSequence::value_type& entry, segments) {
+ for (const log::SegmentSequence::value_type& entry : segments) {
ASSERT_OK(entry->ReadEntries(&ret));
}
@@ -434,13 +433,13 @@ class RaftConsensusQuorumTest : public KuduTest {
void VerifyLogs(int leader_idx, int first_replica_idx, int last_replica_idx) {
// Wait for in-flight transactions to be done. We're destroying the
// peers next and leader transactions won't be able to commit anymore.
- BOOST_FOREACH(TestTransactionFactory* factory, txn_factories_) {
+ for (TestTransactionFactory* factory : txn_factories_) {
factory->WaitDone();
}
// Shut down all the peers.
TestPeerMap all_peers = peers_->GetPeerMapCopy();
- BOOST_FOREACH(const TestPeerMap::value_type& entry, all_peers) {
+ for (const TestPeerMap::value_type& entry : all_peers) {
entry.second->Shutdown();
}
@@ -467,7 +466,7 @@ class RaftConsensusQuorumTest : public KuduTest {
void ExtractReplicateIds(const vector<LogEntryPB*>& entries,
vector<OpId>* ids) {
ids->reserve(entries.size() / 2);
- BOOST_FOREACH(const LogEntryPB* entry, entries) {
+ for (const LogEntryPB* entry : entries) {
if (entry->has_replicate()) {
ids->push_back(entry->replicate().id());
}
@@ -491,7 +490,7 @@ class RaftConsensusQuorumTest : public KuduTest {
OpIdHashFunctor,
OpIdEqualsFunctor> replication_ops;
- BOOST_FOREACH(const LogEntryPB* entry, entries) {
+ for (const LogEntryPB* entry : entries) {
if (entry->has_replicate()) {
ASSERT_TRUE(InsertIfNotPresent(&replication_ops, entry->replicate().id()))
<< "REPLICATE op id showed up twice: " << entry->ShortDebugString();
@@ -523,7 +522,7 @@ class RaftConsensusQuorumTest : public KuduTest {
string ret = "";
SubstituteAndAppend(&ret, "$1 log entries for replica $0:\n",
replica_id, replica_entries.size());
- BOOST_FOREACH(LogEntryPB* replica_entry, replica_entries) {
+ for (LogEntryPB* replica_entry : replica_entries) {
StrAppend(&ret, "Replica log entry: ", replica_entry->ShortDebugString(), "\n");
}
return ret;
@@ -642,7 +641,7 @@ TEST_F(RaftConsensusQuorumTest, TestFollowersReplicateAndCommitSequence) {
&commit_sync);
// Commit the operations, but wait for the replicates to finish first
- BOOST_FOREACH(const scoped_refptr<ConsensusRound>& round, rounds) {
+ for (const scoped_refptr<ConsensusRound>& round : rounds) {
ASSERT_OK(CommitDummyMessage(kLeaderIdx, round.get(), &commit_sync));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/raft_consensus_state-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_state-test.cc b/src/kudu/consensus/raft_consensus_state-test.cc
index a699861..31a3215 100644
--- a/src/kudu/consensus/raft_consensus_state-test.cc
+++ b/src/kudu/consensus/raft_consensus_state-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include "kudu/consensus/raft_consensus_state.h"
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <vector>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/consensus/raft_consensus_state.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_state.cc b/src/kudu/consensus/raft_consensus_state.cc
index 2a03187..e962da1 100644
--- a/src/kudu/consensus/raft_consensus_state.cc
+++ b/src/kudu/consensus/raft_consensus_state.cc
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include "kudu/consensus/log_util.h"
#include "kudu/consensus/quorum_util.h"
@@ -388,7 +387,7 @@ Status ReplicaState::CancelPendingTransactions() {
void ReplicaState::GetUncommittedPendingOperationsUnlocked(
vector<scoped_refptr<ConsensusRound> >* ops) {
- BOOST_FOREACH(const IndexToRoundMap::value_type& entry, pending_txns_) {
+ for (const IndexToRoundMap::value_type& entry : pending_txns_) {
if (entry.first > last_committed_index_.index()) {
ops->push_back(entry.second);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/experiments/merge-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/experiments/merge-test.cc b/src/kudu/experiments/merge-test.cc
index b7cf93a..f8b1271 100644
--- a/src/kudu/experiments/merge-test.cc
+++ b/src/kudu/experiments/merge-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -54,7 +53,7 @@ void HeapMerge(
vector<MergeTypeIter> iters;
vector<size_t> indexes;
size_t i = 0;
- BOOST_FOREACH(const vector<MergeType> &list, in_lists) {
+ for (const vector<MergeType> &list : in_lists) {
iters.push_back(list.begin());
indexes.push_back(i++);
}
@@ -82,7 +81,7 @@ void SimpleMerge(const vector<vector<MergeType> > &in_lists,
vector<MergeType> *out) {
typedef vector<MergeType>::const_iterator MergeTypeIter;
vector<MergeTypeIter> iters;
- BOOST_FOREACH(const vector<MergeType> &list, in_lists) {
+ for (const vector<MergeType> &list : in_lists) {
iters.push_back(list.begin());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/experiments/rwlock-perf.cc
----------------------------------------------------------------------
diff --git a/src/kudu/experiments/rwlock-perf.cc b/src/kudu/experiments/rwlock-perf.cc
index 456e23b..31118cc 100644
--- a/src/kudu/experiments/rwlock-perf.cc
+++ b/src/kudu/experiments/rwlock-perf.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/smart_ptr/detail/spinlock.hpp>
#include <boost/smart_ptr/detail/yield_k.hpp>
@@ -220,7 +219,7 @@ void test_shared_lock(int num_threads,
}
int64_t start = CycleClock::Now();
- BOOST_FOREACH(boost::thread &thr, threads) {
+ for (boost::thread &thr : threads) {
thr.join();
}
int64_t end = CycleClock::Now();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_id.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_id.cc b/src/kudu/fs/block_id.cc
index 2aa799a..8b82117 100644
--- a/src/kudu/fs/block_id.cc
+++ b/src/kudu/fs/block_id.cc
@@ -17,7 +17,6 @@
#include "kudu/fs/block_id.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <string>
#include <vector>
@@ -35,7 +34,7 @@ const uint64_t BlockId::kInvalidId = 0;
string BlockId::JoinStrings(const vector<BlockId>& blocks) {
vector<string> strings;
strings.reserve(blocks.size());
- BOOST_FOREACH(const BlockId& block, blocks) {
+ for (const BlockId& block : blocks) {
strings.push_back(block.ToString());
}
return ::JoinStrings(strings, ",");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_manager-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager-stress-test.cc b/src/kudu/fs/block_manager-stress-test.cc
index 1fc4b17..e1bc9dd 100644
--- a/src/kudu/fs/block_manager-stress-test.cc
+++ b/src/kudu/fs/block_manager-stress-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <cmath>
#include <memory>
#include <string>
@@ -99,7 +98,7 @@ class BlockManagerStressTest : public KuduTest {
if (!FLAGS_block_manager_paths.empty()) {
vector<string> paths = strings::Split(FLAGS_block_manager_paths, ",",
strings::SkipEmpty());
- BOOST_FOREACH(const string& path, paths) {
+ for (const string& path : paths) {
WARN_NOT_OK(env_->DeleteRecursively(path),
Substitute("Couldn't recursively delete $0", path));
}
@@ -155,7 +154,7 @@ class BlockManagerStressTest : public KuduTest {
}
void JoinThreads() {
- BOOST_FOREACH(const scoped_refptr<kudu::Thread>& thr, threads_) {
+ for (const scoped_refptr<kudu::Thread>& thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
}
@@ -255,7 +254,7 @@ void BlockManagerStressTest<T>::WriterThread() {
// Publish the now sync'ed blocks to readers and deleters.
{
lock_guard<rw_spinlock> l(&lock_);
- BOOST_FOREACH(WritableBlock* block, dirty_blocks) {
+ for (WritableBlock* block : dirty_blocks) {
written_blocks_.push_back(block->id());
}
}
@@ -352,7 +351,7 @@ void BlockManagerStressTest<T>::DeleterThread() {
}
// And delete them.
- BOOST_FOREACH(const BlockId& block_id, to_delete) {
+ for (const BlockId& block_id : to_delete) {
LOG(INFO) << "Deleting block " << block_id.ToString();
CHECK_OK(bm_->DeleteBlock(block_id));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager-test.cc b/src/kudu/fs/block_manager-test.cc
index c1a943c..8bdba82 100644
--- a/src/kudu/fs/block_manager-test.cc
+++ b/src/kudu/fs/block_manager-test.cc
@@ -17,7 +17,6 @@
#include <memory>
-#include <boost/foreach.hpp>
#include "kudu/fs/file_block_manager.h"
#include "kudu/fs/log_block_manager.h"
@@ -117,11 +116,11 @@ class BlockManagerTest : public KuduTest {
template <>
void BlockManagerTest<FileBlockManager>::RunMultipathTest(const vector<string>& paths) {
// Ensure that each path has an instance file and that it's well-formed.
- BOOST_FOREACH(const string& path, paths) {
+ for (const string& path : paths) {
vector<string> children;
ASSERT_OK(env_->GetChildren(path, &children));
ASSERT_EQ(3, children.size());
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (child == "." || child == "..") {
continue;
}
@@ -144,7 +143,7 @@ void BlockManagerTest<FileBlockManager>::RunMultipathTest(const vector<string>&
// Each path should now have some additional block subdirectories. We
// can't know for sure exactly how many (depends on the block IDs
// generated), but this ensures that at least some change were made.
- BOOST_FOREACH(const string& path, paths) {
+ for (const string& path : paths) {
vector<string> children;
ASSERT_OK(env_->GetChildren(path, &children));
ASSERT_GT(children.size(), 3);
@@ -169,7 +168,7 @@ void BlockManagerTest<LogBlockManager>::RunMultipathTest(const vector<string>& p
// Verify the results: 7 children = dot, dotdot, instance file, and two
// containers (two files per container).
- BOOST_FOREACH(const string& path, paths) {
+ for (const string& path : paths) {
vector<string> children;
ASSERT_OK(env_->GetChildren(path, &children));
ASSERT_EQ(children.size(), 7);
@@ -297,7 +296,7 @@ void BlockManagerTest<LogBlockManager>::RunLogContainerPreallocationTest() {
// Instead, we expect the size to either be 0 (preallocation isn't
// supported) or equal to the preallocation amount.
bool found = false;
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (HasSuffixString(child, ".data")) {
found = true;
uint64_t size;
@@ -604,7 +603,7 @@ TYPED_TEST(BlockManagerTest, ConcurrentCloseReadableBlockTest) {
&CloseHelper, reader.get(), &t));
threads.push_back(t);
}
- BOOST_FOREACH(const scoped_refptr<Thread>& t, threads) {
+ for (const scoped_refptr<Thread>& t : threads) {
t->Join();
}
}
@@ -725,7 +724,7 @@ TEST_F(LogBlockManagerTest, TestReuseBlockIds) {
ASSERT_EQ(4, bm_->available_containers_.size());
// Delete the original blocks.
- BOOST_FOREACH(const BlockId& b, block_ids) {
+ for (const BlockId& b : block_ids) {
ASSERT_OK(bm_->DeleteBlock(b));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager.h b/src/kudu/fs/block_manager.h
index 598e8a6..cc5c5a1 100644
--- a/src/kudu/fs/block_manager.h
+++ b/src/kudu/fs/block_manager.h
@@ -18,7 +18,6 @@
#ifndef KUDU_FS_BLOCK_MANAGER_H
#define KUDU_FS_BLOCK_MANAGER_H
-#include <boost/foreach.hpp>
#include <cstddef>
#include <memory>
#include <stdint.h>
@@ -246,7 +245,7 @@ class ScopedWritableBlockCloser {
ScopedWritableBlockCloser() {}
~ScopedWritableBlockCloser() {
- BOOST_FOREACH(WritableBlock* block, blocks_) {
+ for (WritableBlock* block : blocks_) {
WARN_NOT_OK(block->Abort(), strings::Substitute(
"Failed to abort block with id $0", block->id().ToString()));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_manager_util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager_util-test.cc b/src/kudu/fs/block_manager_util-test.cc
index a9be3ac..cc68380 100644
--- a/src/kudu/fs/block_manager_util-test.cc
+++ b/src/kudu/fs/block_manager_util-test.cc
@@ -19,7 +19,6 @@
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
#include <google/protobuf/repeated_field.h>
#include <gtest/gtest.h>
@@ -107,7 +106,7 @@ static void RunCheckIntegrityTest(Env* env,
ElementDeleter deleter(&instances);
int i = 0;
- BOOST_FOREACH(const PathSetPB& ps, path_sets) {
+ for (const PathSetPB& ps : path_sets) {
gscoped_ptr<PathInstanceMetadataFile> instance(
new PathInstanceMetadataFile(env, "asdf", Substitute("$0", i)));
gscoped_ptr<PathInstanceMetadataPB> metadata(new PathInstanceMetadataPB());
@@ -150,7 +149,7 @@ TEST_F(KuduTest, CheckIntegrity) {
{
// Test where the path sets have duplicate UUIDs.
vector<PathSetPB> path_sets_copy(path_sets);
- BOOST_FOREACH(PathSetPB& ps, path_sets_copy) {
+ for (PathSetPB& ps : path_sets_copy) {
ps.add_all_uuids("fee");
}
EXPECT_NO_FATAL_FAILURE(RunCheckIntegrityTest(
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/block_manager_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager_util.cc b/src/kudu/fs/block_manager_util.cc
index 760079d..2865e04 100644
--- a/src/kudu/fs/block_manager_util.cc
+++ b/src/kudu/fs/block_manager_util.cc
@@ -20,7 +20,6 @@
#include <unordered_map>
#include <utility>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include "kudu/fs/fs.pb.h"
@@ -70,7 +69,7 @@ Status PathInstanceMetadataFile::Create(const string& uuid, const vector<string>
PathSetPB* new_path_set = new_instance.mutable_path_set();
new_path_set->set_uuid(uuid);
new_path_set->mutable_all_uuids()->Reserve(all_uuids.size());
- BOOST_FOREACH(const string& u, all_uuids) {
+ for (const string& u : all_uuids) {
new_path_set->add_all_uuids(u);
}
@@ -129,7 +128,7 @@ Status PathInstanceMetadataFile::CheckIntegrity(
unordered_map<string, PathInstanceMetadataFile*> uuids;
pair<string, PathInstanceMetadataFile*> first_all_uuids;
- BOOST_FOREACH(PathInstanceMetadataFile* instance, instances) {
+ for (PathInstanceMetadataFile* instance : instances) {
const PathSetPB& path_set = instance->metadata()->path_set();
// Check that this instance's UUID wasn't already claimed.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/file_block_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/file_block_manager.cc b/src/kudu/fs/file_block_manager.cc
index 150878b..8de5698 100644
--- a/src/kudu/fs/file_block_manager.cc
+++ b/src/kudu/fs/file_block_manager.cc
@@ -17,7 +17,6 @@
#include "kudu/fs/file_block_manager.h"
-#include <boost/foreach.hpp>
#include <deque>
#include <string>
#include <unordered_set>
@@ -484,7 +483,7 @@ Status FileBlockManager::SyncMetadata(const internal::FileBlockLocation& locatio
vector<string> to_sync;
{
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const string& parent_dir, parent_dirs) {
+ for (const string& parent_dir : parent_dirs) {
if (dirty_dirs_.erase(parent_dir)) {
to_sync.push_back(parent_dir);
}
@@ -493,7 +492,7 @@ Status FileBlockManager::SyncMetadata(const internal::FileBlockLocation& locatio
// Sync them.
if (FLAGS_enable_data_block_fsync) {
- BOOST_FOREACH(const string& s, to_sync) {
+ for (const string& s : to_sync) {
RETURN_NOT_OK(env_->SyncDir(s));
}
}
@@ -544,14 +543,14 @@ Status FileBlockManager::Create() {
// The UUIDs and indices will be included in every instance file.
ObjectIdGenerator oid_generator;
vector<string> all_uuids(root_paths_.size());
- BOOST_FOREACH(string& u, all_uuids) {
+ for (string& u : all_uuids) {
u = oid_generator.Next();
}
int idx = 0;
// Ensure the data paths exist and create the instance files.
unordered_set<string> to_sync;
- BOOST_FOREACH(const string& root_path, root_paths_) {
+ for (const string& root_path : root_paths_) {
bool created;
RETURN_NOT_OK_PREPEND(env_util::CreateDirIfMissing(env_, root_path, &created),
Substitute("Could not create directory $0", root_path));
@@ -572,14 +571,14 @@ Status FileBlockManager::Create() {
// Ensure newly created directories are synchronized to disk.
if (FLAGS_enable_data_block_fsync) {
- BOOST_FOREACH(const string& dir, to_sync) {
+ for (const string& dir : to_sync) {
RETURN_NOT_OK_PREPEND(env_->SyncDir(dir),
Substitute("Unable to synchronize directory $0", dir));
}
}
// Success: don't delete any files.
- BOOST_FOREACH(ScopedFileDeleter* deleter, delete_on_failure) {
+ for (ScopedFileDeleter* deleter : delete_on_failure) {
deleter->Cancel();
}
return Status::OK();
@@ -590,7 +589,7 @@ Status FileBlockManager::Open() {
ElementDeleter deleter(&instances);
instances.reserve(root_paths_.size());
- BOOST_FOREACH(const string& root_path, root_paths_) {
+ for (const string& root_path : root_paths_) {
if (!env_->FileExists(root_path)) {
return Status::NotFound(Substitute(
"FileBlockManager at $0 not found", root_path));
@@ -625,7 +624,7 @@ Status FileBlockManager::Open() {
JoinStrings(root_paths_, ",")));
PathMap instances_by_idx;
- BOOST_FOREACH(PathInstanceMetadataFile* instance, instances) {
+ for (PathInstanceMetadataFile* instance : instances) {
const PathSetPB& path_set = instance->metadata()->path_set();
uint32_t idx = -1;
for (int i = 0; i < path_set.all_uuids_size(); i++) {
@@ -696,7 +695,7 @@ Status FileBlockManager::CreateBlock(const CreateBlockOptions& opts,
// directory, which may not have been created but is definitely dirty
// (because we added a file to it).
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const string& created, created_dirs) {
+ for (const string& created : created_dirs) {
dirty_dirs_.insert(created);
}
dirty_dirs_.insert(DirName(path));
@@ -754,13 +753,13 @@ Status FileBlockManager::CloseBlocks(const vector<WritableBlock*>& blocks) {
// Ask the kernel to begin writing out each block's dirty data. This is
// done up-front to give the kernel opportunities to coalesce contiguous
// dirty pages.
- BOOST_FOREACH(WritableBlock* block, blocks) {
+ for (WritableBlock* block : blocks) {
RETURN_NOT_OK(block->FlushDataAsync());
}
}
// Now close each block, waiting for each to become durable.
- BOOST_FOREACH(WritableBlock* block, blocks) {
+ for (WritableBlock* block : blocks) {
RETURN_NOT_OK(block->Close());
}
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/fs_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs_manager-test.cc b/src/kudu/fs/fs_manager-test.cc
index b79282e..922e617 100644
--- a/src/kudu/fs/fs_manager-test.cc
+++ b/src/kudu/fs/fs_manager-test.cc
@@ -91,7 +91,7 @@ TEST_F(FsManagerTestBase, TestBaseOperations) {
TEST_F(FsManagerTestBase, TestIllegalPaths) {
vector<string> illegal = { "", "asdf", "/foo\n\t" };
- BOOST_FOREACH(const string& path, illegal) {
+ for (const string& path : illegal) {
ReinitFsManager(path, { path });
ASSERT_TRUE(fs_manager()->CreateInitialFileSystemLayout().IsIOError());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/fs_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs_manager.cc b/src/kudu/fs/fs_manager.cc
index d303261..b03b003 100644
--- a/src/kudu/fs/fs_manager.cc
+++ b/src/kudu/fs/fs_manager.cc
@@ -22,7 +22,6 @@
#include <map>
#include <unordered_set>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <glog/stl_logging.h>
#include <google/protobuf/message.h>
@@ -145,7 +144,7 @@ Status FsManager::Init() {
// Deduplicate all of the roots.
set<string> all_roots;
all_roots.insert(wal_fs_root_);
- BOOST_FOREACH(const string& data_fs_root, data_fs_roots_) {
+ for (const string& data_fs_root : data_fs_roots_) {
all_roots.insert(data_fs_root);
}
@@ -153,7 +152,7 @@ Status FsManager::Init() {
// root a bit as we go.
typedef map<string, string> RootMap;
RootMap canonicalized_roots;
- BOOST_FOREACH(const string& root, all_roots) {
+ for (const string& root : all_roots) {
if (root.empty()) {
return Status::IOError("Empty string provided for filesystem root");
}
@@ -182,7 +181,7 @@ Status FsManager::Init() {
canonicalized_wal_fs_root_ = FindOrDie(canonicalized_roots, wal_fs_root_);
if (!data_fs_roots_.empty()) {
canonicalized_metadata_fs_root_ = FindOrDie(canonicalized_roots, data_fs_roots_[0]);
- BOOST_FOREACH(const string& data_fs_root, data_fs_roots_) {
+ for (const string& data_fs_root : data_fs_roots_) {
canonicalized_data_fs_roots_.insert(FindOrDie(canonicalized_roots, data_fs_root));
}
} else {
@@ -191,7 +190,7 @@ Status FsManager::Init() {
canonicalized_metadata_fs_root_ = canonicalized_wal_fs_root_;
canonicalized_data_fs_roots_.insert(canonicalized_wal_fs_root_);
}
- BOOST_FOREACH(const RootMap::value_type& e, canonicalized_roots) {
+ for (const RootMap::value_type& e : canonicalized_roots) {
canonicalized_all_fs_roots_.insert(e.second);
}
@@ -226,7 +225,7 @@ void FsManager::InitBlockManager() {
Status FsManager::Open() {
RETURN_NOT_OK(Init());
- BOOST_FOREACH(const string& root, canonicalized_all_fs_roots_) {
+ for (const string& root : canonicalized_all_fs_roots_) {
gscoped_ptr<InstanceMetadataPB> pb(new InstanceMetadataPB);
RETURN_NOT_OK(pb_util::ReadPBContainerFromPath(env_, GetInstanceMetadataPath(root),
pb.get()));
@@ -251,7 +250,7 @@ Status FsManager::CreateInitialFileSystemLayout() {
RETURN_NOT_OK(Init());
// It's OK if a root already exists as long as there's nothing in it.
- BOOST_FOREACH(const string& root, canonicalized_all_fs_roots_) {
+ for (const string& root : canonicalized_all_fs_roots_) {
if (!env_->FileExists(root)) {
// We'll create the directory below.
continue;
@@ -274,7 +273,7 @@ Status FsManager::CreateInitialFileSystemLayout() {
InstanceMetadataPB metadata;
CreateInstanceMetadata(&metadata);
unordered_set<string> to_sync;
- BOOST_FOREACH(const string& root, canonicalized_all_fs_roots_) {
+ for (const string& root : canonicalized_all_fs_roots_) {
bool created;
RETURN_NOT_OK_PREPEND(CreateDirIfMissing(root, &created),
"Unable to create FSManager root");
@@ -292,7 +291,7 @@ Status FsManager::CreateInitialFileSystemLayout() {
vector<string> ancillary_dirs = { GetWalsRootDir(),
GetTabletMetadataDir(),
GetConsensusMetadataDir() };
- BOOST_FOREACH(const string& dir, ancillary_dirs) {
+ for (const string& dir : ancillary_dirs) {
bool created;
RETURN_NOT_OK_PREPEND(CreateDirIfMissing(dir, &created),
Substitute("Unable to create directory $0", dir));
@@ -304,7 +303,7 @@ Status FsManager::CreateInitialFileSystemLayout() {
// Ensure newly created directories are synchronized to disk.
if (FLAGS_enable_data_block_fsync) {
- BOOST_FOREACH(const string& dir, to_sync) {
+ for (const string& dir : to_sync) {
RETURN_NOT_OK_PREPEND(env_->SyncDir(dir),
Substitute("Unable to synchronize directory $0", dir));
}
@@ -314,7 +313,7 @@ Status FsManager::CreateInitialFileSystemLayout() {
RETURN_NOT_OK_PREPEND(block_manager_->Create(), "Unable to create block manager");
// Success: don't delete any files.
- BOOST_FOREACH(ScopedFileDeleter* deleter, delete_on_failure) {
+ for (ScopedFileDeleter* deleter : delete_on_failure) {
deleter->Cancel();
}
return Status::OK();
@@ -351,7 +350,7 @@ Status FsManager::WriteInstanceMetadata(const InstanceMetadataPB& metadata,
Status FsManager::IsDirectoryEmpty(const string& path, bool* is_empty) {
vector<string> children;
RETURN_NOT_OK(env_->GetChildren(path, &children));
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (child == "." || child == "..") {
continue;
} else {
@@ -374,7 +373,7 @@ const string& FsManager::uuid() const {
vector<string> FsManager::GetDataRootDirs() const {
// Add the data subdirectory to each data root.
std::vector<std::string> data_paths;
- BOOST_FOREACH(const string& data_fs_root, canonicalized_data_fs_roots_) {
+ for (const string& data_fs_root : canonicalized_data_fs_roots_) {
data_paths.push_back(JoinPathSegments(data_fs_root, kDataDirName));
}
return data_paths;
@@ -414,7 +413,7 @@ Status FsManager::ListTabletIds(vector<string>* tablet_ids) {
Substitute("Couldn't list tablets in metadata directory $0", dir));
vector<string> tablets;
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (!IsValidTabletId(child)) {
continue;
}
@@ -449,7 +448,7 @@ string FsManager::GetWalSegmentFileName(const string& tablet_id,
void FsManager::DumpFileSystemTree(ostream& out) {
DCHECK(initted_);
- BOOST_FOREACH(const string& root, canonicalized_all_fs_roots_) {
+ for (const string& root : canonicalized_all_fs_roots_) {
out << "File-System Root: " << root << std::endl;
std::vector<string> objects;
@@ -465,7 +464,7 @@ void FsManager::DumpFileSystemTree(ostream& out) {
void FsManager::DumpFileSystemTree(ostream& out, const string& prefix,
const string& path, const vector<string>& objects) {
- BOOST_FOREACH(const string& name, objects) {
+ for (const string& name : objects) {
if (name == "." || name == "..") continue;
std::vector<string> sub_objects;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/fs/log_block_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/log_block_manager.cc b/src/kudu/fs/log_block_manager.cc
index 8aec59e..c5c4d97 100644
--- a/src/kudu/fs/log_block_manager.cc
+++ b/src/kudu/fs/log_block_manager.cc
@@ -17,7 +17,6 @@
#include "kudu/fs/log_block_manager.h"
-#include <boost/foreach.hpp>
#include "kudu/fs/block_manager_metrics.h"
#include "kudu/fs/block_manager_util.h"
@@ -1040,7 +1039,7 @@ LogBlockManager::~LogBlockManager() {
LOG_SLOW_EXECUTION(INFO, 1000,
Substitute("waiting on $0 log block manager thread pools",
thread_pools_by_root_path_.size())) {
- BOOST_FOREACH(const ThreadPoolMap::value_type& e,
+ for (const ThreadPoolMap::value_type& e :
thread_pools_by_root_path_) {
ThreadPool* p = e.second;
p->Wait();
@@ -1072,14 +1071,14 @@ Status LogBlockManager::Create() {
// The UUIDs and indices will be included in every instance file.
vector<string> all_uuids(root_paths_.size());
- BOOST_FOREACH(string& u, all_uuids) {
+ for (string& u : all_uuids) {
u = oid_generator()->Next();
}
int idx = 0;
// Ensure the data paths exist and create the instance files.
unordered_set<string> to_sync;
- BOOST_FOREACH(const string& root_path, root_paths_) {
+ for (const string& root_path : root_paths_) {
bool created;
RETURN_NOT_OK_PREPEND(env_util::CreateDirIfMissing(env_, root_path, &created),
Substitute("Could not create directory $0", root_path));
@@ -1103,14 +1102,14 @@ Status LogBlockManager::Create() {
// Ensure newly created directories are synchronized to disk.
if (FLAGS_enable_data_block_fsync) {
- BOOST_FOREACH(const string& dir, to_sync) {
+ for (const string& dir : to_sync) {
RETURN_NOT_OK_PREPEND(env_->SyncDir(dir),
Substitute("Unable to synchronize directory $0", dir));
}
}
// Success: don't delete any files.
- BOOST_FOREACH(ScopedFileDeleter* deleter, delete_on_failure) {
+ for (ScopedFileDeleter* deleter : delete_on_failure) {
deleter->Cancel();
}
return Status::OK();
@@ -1122,13 +1121,13 @@ Status LogBlockManager::Open() {
vector<Status> statuses(root_paths_.size());
unordered_map<string, PathInstanceMetadataFile*> metadata_files;
ValueDeleter deleter(&metadata_files);
- BOOST_FOREACH(const string& root_path, root_paths_) {
+ for (const string& root_path : root_paths_) {
InsertOrDie(&metadata_files, root_path, NULL);
}
// Submit each open to its own thread pool and wait for them to complete.
int i = 0;
- BOOST_FOREACH(const string& root_path, root_paths_) {
+ for (const string& root_path : root_paths_) {
ThreadPool* pool = FindOrDie(thread_pools_by_root_path_, root_path);
RETURN_NOT_OK_PREPEND(pool->SubmitClosure(
Bind(&LogBlockManager::OpenRootPath,
@@ -1139,13 +1138,13 @@ Status LogBlockManager::Open() {
Substitute("Could not open root path $0", root_path));
i++;
}
- BOOST_FOREACH(const ThreadPoolMap::value_type& e,
+ for (const ThreadPoolMap::value_type& e :
thread_pools_by_root_path_) {
e.second->Wait();
}
// Ensure that no tasks failed.
- BOOST_FOREACH(const Status& s, statuses) {
+ for (const Status& s : statuses) {
if (!s.ok()) {
return s;
}
@@ -1268,13 +1267,13 @@ Status LogBlockManager::CloseBlocks(const std::vector<WritableBlock*>& blocks) {
// Ask the kernel to begin writing out each block's dirty data. This is
// done up-front to give the kernel opportunities to coalesce contiguous
// dirty pages.
- BOOST_FOREACH(WritableBlock* block, blocks) {
+ for (WritableBlock* block : blocks) {
RETURN_NOT_OK(block->FlushDataAsync());
}
}
// Now close each block, waiting for each to become durable.
- BOOST_FOREACH(WritableBlock* block, blocks) {
+ for (WritableBlock* block : blocks) {
RETURN_NOT_OK(block->Close());
}
return Status::OK();
@@ -1445,7 +1444,7 @@ void LogBlockManager::OpenRootPath(const string& root_path,
"Could not list children of $0", root_path));
return;
}
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
string id;
if (!TryStripSuffixString(child, LogBlockContainer::kMetadataFileSuffix, &id)) {
continue;
@@ -1478,7 +1477,7 @@ void LogBlockManager::OpenRootPath(const string& root_path,
// the container-local map first ensures that we discount deleted blocks
// before checking for duplicate IDs.
UntrackedBlockMap blocks_in_container;
- BOOST_FOREACH(const BlockRecordPB& r, records) {
+ for (const BlockRecordPB& r : records) {
ProcessBlockRecord(r, container.get(), &blocks_in_container);
}
@@ -1486,7 +1485,7 @@ void LogBlockManager::OpenRootPath(const string& root_path,
// the container.
{
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const UntrackedBlockMap::value_type& e, blocks_in_container) {
+ for (const UntrackedBlockMap::value_type& e : blocks_in_container) {
if (!AddLogBlockUnlocked(e.second)) {
LOG(FATAL) << "Found duplicate CREATE record for block " << e.first
<< " which already is alive from another container when "
@@ -1590,7 +1589,7 @@ Status LogBlockManager::Init() {
ThreadPoolMap pools;
ValueDeleter d(&pools);
int i = 0;
- BOOST_FOREACH(const string& root, root_paths_) {
+ for (const string& root : root_paths_) {
gscoped_ptr<ThreadPool> p;
RETURN_NOT_OK_PREPEND(ThreadPoolBuilder(Substitute("lbm root $0", i++))
.set_max_threads(1)
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/all_types-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/all_types-itest.cc b/src/kudu/integration-tests/all_types-itest.cc
index 66333c2..9dae94f 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -62,7 +62,7 @@ struct SliceKeysTestSetup {
splits.push_back(StringPrintf("%08x", split));
}
vector<const KuduPartialRow*> rows;
- BOOST_FOREACH(string val, splits) {
+ for (string val : splits) {
Slice slice(val);
KuduPartialRow* row = schema.NewRow();
CHECK_OK(row->SetSliceCopy<TypeTraits<KeyTypeWrapper::type> >(0, slice));
@@ -139,7 +139,7 @@ struct IntKeysTestSetup {
splits.push_back(i * increment_);
}
vector<const KuduPartialRow*> rows;
- BOOST_FOREACH(CppType val, splits) {
+ for (CppType val : splits) {
KuduPartialRow* row = schema.NewRow();
CHECK_OK(row->Set<TypeTraits<KeyTypeWrapper::type> >(0, val));
rows.push_back(row);
@@ -221,7 +221,7 @@ class AllTypesItest : public KuduTest {
ExternalMiniClusterOptions opts;
opts.num_tablet_servers = kNumTabletServers;
- BOOST_FOREACH(const std::string& flag, ts_flags) {
+ for (const std::string& flag : ts_flags) {
opts.extra_tserver_flags.push_back(flag);
}
@@ -236,7 +236,7 @@ class AllTypesItest : public KuduTest {
vector<const KuduPartialRow*> split_rows = setup_.GenerateSplitRows(schema_);
gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
- BOOST_FOREACH(const KuduPartialRow* row, split_rows) {
+ for (const KuduPartialRow* row : split_rows) {
split_rows_.push_back(*row);
}
@@ -292,7 +292,7 @@ class AllTypesItest : public KuduTest {
void SetupProjection(vector<string>* projection) {
vector<string> keys = setup_.GetKeyColumns();
- BOOST_FOREACH(const string& key, keys) {
+ for (const string& key : keys) {
projection->push_back(key);
}
projection->push_back("int8_val");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/alter_table-randomized-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/alter_table-randomized-test.cc b/src/kudu/integration-tests/alter_table-randomized-test.cc
index 3880c79..b272b8d 100644
--- a/src/kudu/integration-tests/alter_table-randomized-test.cc
+++ b/src/kudu/integration-tests/alter_table-randomized-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <algorithm>
#include <map>
@@ -106,7 +105,7 @@ struct RowState {
string ret = "(";
typedef pair<string, int32_t> entry;
bool first = true;
- BOOST_FOREACH(const entry& e, cols) {
+ for (const entry& e : cols) {
if (!first) {
ret.append(", ");
}
@@ -180,7 +179,7 @@ struct TableState {
void AddColumnWithDefault(const string& name, int32_t def, bool nullable) {
col_names_.push_back(name);
col_nullable_.push_back(nullable);
- BOOST_FOREACH(entry& e, rows_) {
+ for (entry& e : rows_) {
e.second->cols.push_back(make_pair(name, def));
}
}
@@ -190,7 +189,7 @@ struct TableState {
int index = col_it - col_names_.begin();
col_names_.erase(col_it);
col_nullable_.erase(col_nullable_.begin() + index);
- BOOST_FOREACH(entry& e, rows_) {
+ for (entry& e : rows_) {
e.second->cols.erase(e.second->cols.begin() + index);
}
}
@@ -207,7 +206,7 @@ struct TableState {
void ToStrings(vector<string>* strs) {
strs->clear();
- BOOST_FOREACH(const entry& e, rows_) {
+ for (const entry& e : rows_) {
strs->push_back(e.second->ToString());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/alter_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc
index e0b0025..1dfeee2 100644
--- a/src/kudu/integration-tests/alter_table-test.cc
+++ b/src/kudu/integration-tests/alter_table-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include <boost/assign.hpp>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
#include <map>
@@ -447,7 +446,7 @@ void AlterTableTest::UpdateRow(int32_t row_key,
int32_t key = bswap_32(row_key); // endian swap to match 'InsertRows'
CHECK_OK(update->mutable_row()->SetInt32(0, key));
typedef map<string, int32_t>::value_type entry;
- BOOST_FOREACH(const entry& e, updates) {
+ for (const entry& e : updates) {
CHECK_OK(update->mutable_row()->SetInt32(e.first, e.second));
}
CHECK_OK(session->Apply(update.release()));
@@ -476,7 +475,7 @@ void AlterTableTest::VerifyRows(int start_row, int num_rows, VerifyPattern patte
while (scanner.HasMoreRows()) {
CHECK_OK(scanner.NextBatch(&results));
- BOOST_FOREACH(const KuduRowResult& row, results) {
+ for (const KuduRowResult& row : results) {
int32_t key = 0;
CHECK_OK(row.GetInt32(0, &key));
int32_t row_idx = bswap_32(key);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/client-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/client-stress-test.cc b/src/kudu/integration-tests/client-stress-test.cc
index fb1c52c..6401bfc 100644
--- a/src/kudu/integration-tests/client-stress-test.cc
+++ b/src/kudu/integration-tests/client-stress-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <memory>
#include <vector>
@@ -148,7 +147,7 @@ TEST_F(ClientStressTest, TestStartScans) {
go_latch.CountDown();
- BOOST_FOREACH(const scoped_refptr<kudu::Thread>& thr, threads) {
+ for (const scoped_refptr<kudu::Thread>& thr : threads) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
}
[2/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Posted by da...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/rowset_tree.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_tree.cc b/src/kudu/tablet/rowset_tree.cc
index d0c55bd..e4c0cd6 100644
--- a/src/kudu/tablet/rowset_tree.cc
+++ b/src/kudu/tablet/rowset_tree.cc
@@ -89,7 +89,7 @@ Status RowSetTree::Reset(const RowSetVector &rowsets) {
// Iterate over each of the provided RowSets, fetching their
// bounds and adding them to the local vectors.
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, rowsets) {
+ for (const shared_ptr<RowSet> &rs : rowsets) {
gscoped_ptr<RowSetWithBounds> rsit(new RowSetWithBounds());
rsit->rowset = rs.get();
Slice min_key, max_key;
@@ -139,7 +139,7 @@ void RowSetTree::FindRowSetsIntersectingInterval(const Slice &lower_bound,
DCHECK(initted_);
// All rowsets with unknown bounds need to be checked.
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, unbounded_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : unbounded_rowsets_) {
rowsets->push_back(rs.get());
}
@@ -153,7 +153,7 @@ void RowSetTree::FindRowSetsIntersectingInterval(const Slice &lower_bound,
from_tree.reserve(all_rowsets_.size());
tree_->FindIntersectingInterval(&query, &from_tree);
rowsets->reserve(rowsets->size() + from_tree.size());
- BOOST_FOREACH(RowSetWithBounds *rs, from_tree) {
+ for (RowSetWithBounds *rs : from_tree) {
rowsets->push_back(rs->rowset);
}
}
@@ -163,7 +163,7 @@ void RowSetTree::FindRowSetsWithKeyInRange(const Slice &encoded_key,
DCHECK(initted_);
// All rowsets with unknown bounds need to be checked.
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, unbounded_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : unbounded_rowsets_) {
rowsets->push_back(rs.get());
}
@@ -173,7 +173,7 @@ void RowSetTree::FindRowSetsWithKeyInRange(const Slice &encoded_key,
from_tree.reserve(all_rowsets_.size());
tree_->FindContainingPoint(encoded_key, &from_tree);
rowsets->reserve(rowsets->size() + from_tree.size());
- BOOST_FOREACH(RowSetWithBounds *rs, from_tree) {
+ for (RowSetWithBounds *rs : from_tree) {
rowsets->push_back(rs->rowset);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/svg_dump.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/svg_dump.cc b/src/kudu/tablet/svg_dump.cc
index 290c5ec..514bd03 100644
--- a/src/kudu/tablet/svg_dump.cc
+++ b/src/kudu/tablet/svg_dump.cc
@@ -17,7 +17,6 @@
#include "kudu/tablet/svg_dump.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <time.h>
@@ -66,14 +65,14 @@ void OrganizeSVGRows(const vector<RowSetInfo>& candidates,
vector<vector<const RowSetInfo*> >* rows) {
rows->push_back(vector<const RowSetInfo *>());
- BOOST_FOREACH(const RowSetInfo &candidate, candidates) {
+ for (const RowSetInfo &candidate : candidates) {
// Slot into the first row of the output which fits it
bool found_slot = false;
- BOOST_FOREACH(vector<const RowSetInfo *> &row, *rows) {
+ for (vector<const RowSetInfo *> &row : *rows) {
// If this candidate doesn't intersect any other candidates in this
// row, we can put it here.
bool fits_in_row = true;
- BOOST_FOREACH(const RowSetInfo *already_in_row, row) {
+ for (const RowSetInfo *already_in_row : row) {
if (candidate.Intersects(*already_in_row)) {
fits_in_row = false;
break;
@@ -127,7 +126,7 @@ void DumpSVG(const vector<RowSetInfo>& candidates,
const vector<const RowSetInfo *> &row = svg_rows[row_index];
int y = kRowHeight * row_index + kHeaderHeight;
- BOOST_FOREACH(const RowSetInfo *cand, row) {
+ for (const RowSetInfo *cand : row) {
bool was_picked = ContainsKey(picked, cand->rowset());
const char *color = was_picked ? kPickedColor : kDefaultColor;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet-pushdown-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet-pushdown-test.cc b/src/kudu/tablet/tablet-pushdown-test.cc
index 7a7c96b..b02e225 100644
--- a/src/kudu/tablet/tablet-pushdown-test.cc
+++ b/src/kudu/tablet/tablet-pushdown-test.cc
@@ -91,7 +91,7 @@ class TabletPushdownTest : public KuduTabletTest,
ASSERT_OK(IterateToStringList(iter.get(), &results));
}
std::sort(results.begin(), results.end());
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
LOG(INFO) << str;
}
ASSERT_EQ(11, results.size());
@@ -133,7 +133,7 @@ class TabletPushdownTest : public KuduTabletTest,
if (check_stats) {
vector<IteratorStats> stats;
iter->GetIteratorStats(&stats);
- BOOST_FOREACH(const IteratorStats& col_stats, stats) {
+ for (const IteratorStats& col_stats : stats) {
EXPECT_EQ(expected_blocks_from_disk, col_stats.data_blocks_read_from_disk);
EXPECT_EQ(expected_rows_from_disk, col_stats.cells_read_from_disk);
}
@@ -153,7 +153,7 @@ class TabletPushdownTest : public KuduTabletTest,
vector<string> results;
ASSERT_OK(IterateToStringList(iter.get(), &results));
ASSERT_EQ(11, results.size());
- BOOST_FOREACH(const string& result, results) {
+ for (const string& result : results) {
ASSERT_EQ("()", result);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet-schema-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet-schema-test.cc b/src/kudu/tablet/tablet-schema-test.cc
index 08b8bee..8fc2409 100644
--- a/src/kudu/tablet/tablet-schema-test.cc
+++ b/src/kudu/tablet/tablet-schema-test.cc
@@ -82,9 +82,9 @@ class TestTabletSchema : public KuduTabletTest {
vector<string> rows;
ASSERT_OK(DumpTablet(*tablet(), projection, &rows));
- BOOST_FOREACH(const string& row, rows) {
+ for (const string& row : rows) {
bool found = false;
- BOOST_FOREACH(const StringPair& k, keys) {
+ for (const StringPair& k : keys) {
if (row.find(k.first) != string::npos) {
ASSERT_STR_CONTAINS(row, k.second);
found = true;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet-test-util.h b/src/kudu/tablet/tablet-test-util.h
index 3fae33f..4159405 100644
--- a/src/kudu/tablet/tablet-test-util.h
+++ b/src/kudu/tablet/tablet-test-util.h
@@ -165,7 +165,7 @@ static inline void CollectRowsForSnapshots(Tablet* tablet,
const Schema& schema,
const vector<MvccSnapshot>& snaps,
vector<vector<string>* >* collected_rows) {
- BOOST_FOREACH(const MvccSnapshot& snapshot, snaps) {
+ for (const MvccSnapshot& snapshot : snaps) {
DVLOG(1) << "Snapshot: " << snapshot.ToString();
gscoped_ptr<RowwiseIterator> iter;
ASSERT_OK(tablet->NewRowIterator(schema,
@@ -190,7 +190,7 @@ static inline void VerifySnapshotsHaveSameResult(Tablet* tablet,
const vector<vector<string>* >& expected_rows) {
int idx = 0;
// Now iterate again and make sure we get the same thing.
- BOOST_FOREACH(const MvccSnapshot& snapshot, snaps) {
+ for (const MvccSnapshot& snapshot : snaps) {
DVLOG(1) << "Snapshot: " << snapshot.ToString();
gscoped_ptr<RowwiseIterator> iter;
ASSERT_OK(tablet->NewRowIterator(schema,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet.cc b/src/kudu/tablet/tablet.cc
index 82852fa..5bfee03 100644
--- a/src/kudu/tablet/tablet.cc
+++ b/src/kudu/tablet/tablet.cc
@@ -17,7 +17,6 @@
#include <algorithm>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
#include <iterator>
@@ -186,7 +185,7 @@ Status Tablet::Open() {
RowSetVector rowsets_opened;
// open the tablet row-sets
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rowset_meta, metadata_->rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& rowset_meta : metadata_->rowsets()) {
shared_ptr<DiskRowSet> rowset;
Status s = DiskRowSet::Open(rowset_meta, log_anchor_registry_.get(), &rowset, mem_tracker_);
if (!s.ok()) {
@@ -286,7 +285,7 @@ Status Tablet::DecodeWriteOperations(const Schema* client_schema,
// Create RowOp objects for each
vector<RowOp*> row_ops;
ops.reserve(ops.size());
- BOOST_FOREACH(const DecodedRowOperation& op, ops) {
+ for (const DecodedRowOperation& op : ops) {
row_ops.push_back(new RowOp(op));
}
@@ -302,7 +301,7 @@ Status Tablet::AcquireRowLocks(WriteTransactionState* tx_state) {
TRACE_EVENT1("tablet", "Tablet::AcquireRowLocks",
"num_locks", tx_state->row_ops().size());
TRACE("PREPARE: Acquiring locks for $0 operations", tx_state->row_ops().size());
- BOOST_FOREACH(RowOp* op, tx_state->row_ops()) {
+ for (RowOp* op : tx_state->row_ops()) {
RETURN_NOT_OK(AcquireLockForOp(tx_state, op));
}
TRACE("PREPARE: locks acquired");
@@ -379,7 +378,7 @@ Status Tablet::InsertUnlocked(WriteTransactionState *tx_state,
comps->rowsets->FindRowSetsWithKeyInRange(insert->key_probe->encoded_key_slice(),
&to_check);
- BOOST_FOREACH(const RowSet *rowset, to_check) {
+ for (const RowSet *rowset : to_check) {
bool present = false;
RETURN_NOT_OK(rowset->CheckRowPresent(*insert->key_probe, &present, &stats));
if (PREDICT_FALSE(present)) {
@@ -466,7 +465,7 @@ Status Tablet::MutateRowUnlocked(WriteTransactionState *tx_state,
vector<RowSet *> to_check;
comps->rowsets->FindRowSetsWithKeyInRange(mutate->key_probe->encoded_key_slice(),
&to_check);
- BOOST_FOREACH(RowSet *rs, to_check) {
+ for (RowSet *rs : to_check) {
s = rs->MutateRow(ts,
*mutate->key_probe,
mutate->decoded_op.changelist,
@@ -496,7 +495,7 @@ void Tablet::StartApplying(WriteTransactionState* tx_state) {
void Tablet::ApplyRowOperations(WriteTransactionState* tx_state) {
StartApplying(tx_state);
- BOOST_FOREACH(RowOp* row_op, tx_state->row_ops()) {
+ for (RowOp* row_op : tx_state->row_ops()) {
ApplyRowOperation(tx_state, row_op);
}
}
@@ -528,10 +527,10 @@ void Tablet::ModifyRowSetTree(const RowSetTree& old_tree,
// the rowsets that were included in the compaction
int num_removed = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, old_tree.all_rowsets()) {
+ for (const shared_ptr<RowSet> &rs : old_tree.all_rowsets()) {
// Determine if it should be removed
bool should_remove = false;
- BOOST_FOREACH(const shared_ptr<RowSet> &to_remove, rowsets_to_remove) {
+ for (const shared_ptr<RowSet> &to_remove : rowsets_to_remove) {
if (to_remove == rs) {
should_remove = true;
num_removed++;
@@ -1026,7 +1025,7 @@ Status Tablet::PickRowSetsToCompact(RowSetsInCompaction *picked,
if (flags & FORCE_COMPACT_ALL) {
// Compact all rowsets, regardless of policy.
- BOOST_FOREACH(const shared_ptr<RowSet>& rs, rowsets_copy->all_rowsets()) {
+ for (const shared_ptr<RowSet>& rs : rowsets_copy->all_rowsets()) {
if (rs->IsAvailableForCompaction()) {
picked_set.insert(rs.get());
}
@@ -1039,7 +1038,7 @@ Status Tablet::PickRowSetsToCompact(RowSetsInCompaction *picked,
}
boost::shared_lock<rw_spinlock> lock(component_lock_);
- BOOST_FOREACH(const shared_ptr<RowSet>& rs, components_->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet>& rs : components_->rowsets->all_rowsets()) {
if (picked_set.erase(rs.get()) == 0) {
// Not picked.
continue;
@@ -1064,7 +1063,7 @@ Status Tablet::PickRowSetsToCompact(RowSetsInCompaction *picked,
// them out while we were making our selection decision -- that's not possible
// since we only picked rowsets that were marked as available for compaction.
if (!picked_set.empty()) {
- BOOST_FOREACH(const RowSet* not_found, picked_set) {
+ for (const RowSet* not_found : picked_set) {
LOG(ERROR) << "Rowset selected for compaction but not available anymore: "
<< not_found->ToString();
}
@@ -1079,7 +1078,7 @@ void Tablet::GetRowSetsForTests(RowSetVector* out) {
boost::shared_lock<rw_spinlock> lock(component_lock_);
rowsets_copy = components_->rowsets;
}
- BOOST_FOREACH(const shared_ptr<RowSet>& rs, rowsets_copy->all_rowsets()) {
+ for (const shared_ptr<RowSet>& rs : rowsets_copy->all_rowsets()) {
out->push_back(rs);
}
}
@@ -1102,7 +1101,7 @@ void Tablet::RegisterMaintenanceOps(MaintenanceManager* maint_mgr) {
}
void Tablet::UnregisterMaintenanceOps() {
- BOOST_FOREACH(MaintenanceOp* op, maintenance_ops_) {
+ for (MaintenanceOp* op : maintenance_ops_) {
op->Unregister();
}
STLDeleteElements(&maintenance_ops_);
@@ -1112,7 +1111,7 @@ Status Tablet::FlushMetadata(const RowSetVector& to_remove,
const RowSetMetadataVector& to_add,
int64_t mrs_being_flushed) {
RowSetMetadataIds to_remove_meta;
- BOOST_FOREACH(const shared_ptr<RowSet>& rowset, to_remove) {
+ for (const shared_ptr<RowSet>& rowset : to_remove) {
// Skip MemRowSet & DuplicatingRowSets which don't have metadata.
if (rowset->metadata().get() == NULL) {
continue;
@@ -1183,7 +1182,7 @@ Status Tablet::DoCompactionOrFlush(const RowSetsInCompaction &input, int64_t mrs
CHECK(!new_drs_metas.empty());
{
TRACE_EVENT0("tablet", "Opening compaction results");
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, new_drs_metas) {
+ for (const shared_ptr<RowSetMetadata>& meta : new_drs_metas) {
shared_ptr<DiskRowSet> new_rowset;
Status s = DiskRowSet::Open(meta, log_anchor_registry_.get(), &new_rowset, mem_tracker_);
if (!s.ok()) {
@@ -1254,7 +1253,7 @@ Status Tablet::DoCompactionOrFlush(const RowSetsInCompaction &input, int64_t mrs
if (VLOG_IS_ON(1) && !applying_during_swap.empty()) {
VLOG(1) << "Waiting for " << applying_during_swap.size() << " mid-APPLY txns to commit "
<< "before finishing compaction...";
- BOOST_FOREACH(const Timestamp& ts, applying_during_swap) {
+ for (const Timestamp& ts : applying_during_swap) {
VLOG(1) << " " << ts.value();
}
}
@@ -1381,7 +1380,7 @@ Status Tablet::DebugDump(vector<string> *lines) {
LOG_STRING(INFO, lines) << "MRS " << components_->memrowset->ToString() << ":";
RETURN_NOT_OK(components_->memrowset->DebugDump(lines));
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, components_->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rs : components_->rowsets->all_rowsets()) {
LOG_STRING(INFO, lines) << "RowSet " << rs->ToString() << ":";
RETURN_NOT_OK(rs->DebugDump(lines));
}
@@ -1416,7 +1415,7 @@ Status Tablet::CaptureConsistentIterators(
spec->lower_bound_key()->encoded_key(),
spec->exclusive_upper_bound_key()->encoded_key(),
&interval_sets);
- BOOST_FOREACH(const RowSet *rs, interval_sets) {
+ for (const RowSet *rs : interval_sets) {
gscoped_ptr<RowwiseIterator> row_it;
RETURN_NOT_OK_PREPEND(rs->NewRowIterator(projection, snap, &row_it),
Substitute("Could not create iterator for rowset $0",
@@ -1429,7 +1428,7 @@ Status Tablet::CaptureConsistentIterators(
// If there are no encoded predicates or they represent an open-ended range, then
// fall back to grabbing all rowset iterators
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, components_->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rs : components_->rowsets->all_rowsets()) {
gscoped_ptr<RowwiseIterator> row_it;
RETURN_NOT_OK_PREPEND(rs->NewRowIterator(projection, snap, &row_it),
Substitute("Could not create iterator for rowset $0",
@@ -1449,7 +1448,7 @@ Status Tablet::CountRows(uint64_t *count) const {
// Now sum up the counts.
*count = comps->memrowset->entry_count();
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
rowid_t l_count;
RETURN_NOT_OK(rowset->CountRows(&l_count));
*count += l_count;
@@ -1490,7 +1489,7 @@ size_t Tablet::EstimateOnDiskSize() const {
if (!comps) return 0;
size_t ret = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
ret += rowset->EstimateOnDiskSize();
}
@@ -1502,7 +1501,7 @@ size_t Tablet::DeltaMemStoresSize() const {
GetComponents(&comps);
size_t ret = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
ret += rowset->DeltaMemStoreSize();
}
@@ -1513,7 +1512,7 @@ bool Tablet::DeltaMemRowSetEmpty() const {
scoped_refptr<TabletComponents> comps;
GetComponents(&comps);
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
if (!rowset->DeltaMemStoreEmpty()) {
return false;
}
@@ -1552,7 +1551,7 @@ shared_ptr<RowSet> Tablet::FindBestDMSToFlush(const MaxIdxToSegmentMap&
int64_t mem_size = 0;
int64_t retention_size = 0;
shared_ptr<RowSet> best_dms;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
if (rowset->DeltaMemStoreEmpty()) {
continue;
}
@@ -1575,7 +1574,7 @@ int64_t Tablet::GetLogRetentionSizeForIndex(int64_t min_log_index,
return 0;
}
int64_t total_size = 0;
- BOOST_FOREACH(const MaxIdxToSegmentMap::value_type& entry, max_idx_to_segment_size) {
+ for (const MaxIdxToSegmentMap::value_type& entry : max_idx_to_segment_size) {
if (min_log_index > entry.first) {
continue; // We're not in this segment, probably someone else is retaining it.
}
@@ -1591,7 +1590,7 @@ Status Tablet::FlushBiggestDMS() {
int64_t max_size = -1;
shared_ptr<RowSet> biggest_drs;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
int64_t current = rowset->DeltaMemStoreSize();
if (current > max_size) {
max_size = current;
@@ -1648,7 +1647,7 @@ double Tablet::GetPerfImprovementForBestDeltaCompactUnlocked(RowSet::DeltaCompac
GetComponents(&comps);
double worst_delta_perf = 0;
shared_ptr<RowSet> worst_rs;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, comps->rowsets->all_rowsets()) {
+ for (const shared_ptr<RowSet> &rowset : comps->rowsets->all_rowsets()) {
if (!rowset->IsAvailableForCompaction()) {
continue;
}
@@ -1701,7 +1700,7 @@ void Tablet::PrintRSLayout(ostream* o) {
*o << "<h2>Compaction policy log</h2>" << std::endl;
*o << "<pre>" << std::endl;
- BOOST_FOREACH(const string& s, log) {
+ for (const string& s : log) {
*o << EscapeForHtmlToString(s) << std::endl;
}
*o << "</pre>" << std::endl;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_bootstrap-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_bootstrap-test.cc b/src/kudu/tablet/tablet_bootstrap-test.cc
index e1507ed..d61c170 100644
--- a/src/kudu/tablet/tablet_bootstrap-test.cc
+++ b/src/kudu/tablet/tablet_bootstrap-test.cc
@@ -151,7 +151,7 @@ class BootstrapTest : public LogTestBase {
ASSERT_OK(tablet->NewRowIterator(schema_, snap, Tablet::UNORDERED, &iter));
ASSERT_OK(iter->Init(NULL));
ASSERT_OK(IterateToStringList(iter.get(), results));
- BOOST_FOREACH(const string& result, *results) {
+ for (const string& result : *results) {
VLOG(1) << result;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_bootstrap.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_bootstrap.cc b/src/kudu/tablet/tablet_bootstrap.cc
index 6598329..a1a027c 100644
--- a/src/kudu/tablet/tablet_bootstrap.cc
+++ b/src/kudu/tablet/tablet_bootstrap.cc
@@ -17,7 +17,6 @@
#include "kudu/tablet/tablet_bootstrap.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <map>
#include <string>
@@ -573,7 +572,7 @@ Status TabletBootstrap::PrepareRecoveryDir(bool* needs_recovery) {
vector<string> children;
RETURN_NOT_OK_PREPEND(fs_manager->ListDir(log_dir, &children),
"Couldn't list log segments.");
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (!log::IsLogFileName(child)) {
continue;
}
@@ -710,7 +709,7 @@ struct ReplayState {
}
void AddEntriesToStrings(const OpIndexToEntryMap& entries, vector<string>* strings) const {
- BOOST_FOREACH(const OpIndexToEntryMap::value_type& map_entry, entries) {
+ for (const OpIndexToEntryMap::value_type& map_entry : entries) {
LogEntryPB* entry = DCHECK_NOTNULL(map_entry.second);
strings->push_back(Substitute(" $0", entry->ShortDebugString()));
}
@@ -862,8 +861,8 @@ Status TabletBootstrap::HandleCommitMessage(ReplayState* state, LogEntryPB* comm
}
bool TabletBootstrap::AreAllStoresAlreadyFlushed(const CommitMsg& commit) {
- BOOST_FOREACH(const OperationResultPB& op_result, commit.result().ops()) {
- BOOST_FOREACH(const MemStoreTargetPB& mutated_store, op_result.mutated_stores()) {
+ for (const OperationResultPB& op_result : commit.result().ops()) {
+ for (const MemStoreTargetPB& mutated_store : op_result.mutated_stores()) {
if (!flushed_stores_.WasStoreAlreadyFlushed(mutated_store)) {
return false;
}
@@ -873,8 +872,8 @@ bool TabletBootstrap::AreAllStoresAlreadyFlushed(const CommitMsg& commit) {
}
bool TabletBootstrap::AreAnyStoresAlreadyFlushed(const CommitMsg& commit) {
- BOOST_FOREACH(const OperationResultPB& op_result, commit.result().ops()) {
- BOOST_FOREACH(const MemStoreTargetPB& mutated_store, op_result.mutated_stores()) {
+ for (const OperationResultPB& op_result : commit.result().ops()) {
+ for (const MemStoreTargetPB& mutated_store : op_result.mutated_stores()) {
if (flushed_stores_.WasStoreAlreadyFlushed(mutated_store)) {
return true;
}
@@ -1002,7 +1001,7 @@ void TabletBootstrap::DumpReplayStateToLog(const ReplayState& state) {
// which might be useful for debugging.
vector<string> state_dump;
state.DumpReplayStateToStrings(&state_dump);
- BOOST_FOREACH(const string& string, state_dump) {
+ for (const string& string : state_dump) {
LOG_WITH_PREFIX(INFO) << string;
}
}
@@ -1032,7 +1031,7 @@ Status TabletBootstrap::PlaySegments(ConsensusBootstrapInfo* consensus_info) {
RETURN_NOT_OK_PREPEND(OpenNewLog(), "Failed to open new log");
int segment_count = 0;
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, segments) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : segments) {
vector<LogEntryPB*> entries;
ElementDeleter deleter(&entries);
// TODO: Optimize this to not read the whole thing into memory?
@@ -1084,7 +1083,7 @@ Status TabletBootstrap::PlaySegments(ConsensusBootstrapInfo* consensus_info) {
// If we have non-applied commits they all must belong to pending operations and
// they should only pertain to unflushed stores.
if (!state.pending_commits.empty()) {
- BOOST_FOREACH(const OpIndexToEntryMap::value_type& entry, state.pending_commits) {
+ for (const OpIndexToEntryMap::value_type& entry : state.pending_commits) {
if (!ContainsKey(state.pending_replicates, entry.first)) {
DumpReplayStateToLog(state);
return Status::Corruption("Had orphaned commits at the end of replay.");
@@ -1142,7 +1141,7 @@ Status TabletBootstrap::PlaySegments(ConsensusBootstrapInfo* consensus_info) {
DumpReplayStateToLog(state);
// Set up the ConsensusBootstrapInfo structure for the caller.
- BOOST_FOREACH(OpIndexToEntryMap::value_type& e, state.pending_replicates) {
+ for (OpIndexToEntryMap::value_type& e : state.pending_replicates) {
consensus_info->orphaned_replicates.push_back(e.second->release_replicate());
}
consensus_info->last_id = state.prev_op_id;
@@ -1277,7 +1276,7 @@ Status TabletBootstrap::PlayRowOperations(WriteTransactionState* tx_state,
Status TabletBootstrap::FilterAndApplyOperations(WriteTransactionState* tx_state,
const TxResultPB& orig_result) {
int32_t op_idx = 0;
- BOOST_FOREACH(RowOp* op, tx_state->row_ops()) {
+ for (RowOp* op : tx_state->row_ops()) {
const OperationResultPB& orig_op_result = orig_result.ops(op_idx++);
// check if the operation failed in the original transaction
@@ -1385,7 +1384,7 @@ Status TabletBootstrap::FilterMutate(WriteTransactionState* tx_state,
// The mutation may have been duplicated, so we'll check whether any of the
// output targets was "unflushed".
int num_unflushed_stores = 0;
- BOOST_FOREACH(const MemStoreTargetPB& mutated_store, op_result.mutated_stores()) {
+ for (const MemStoreTargetPB& mutated_store : op_result.mutated_stores()) {
if (!flushed_stores_.WasStoreAlreadyFlushed(mutated_store)) {
num_unflushed_stores++;
} else {
@@ -1433,7 +1432,7 @@ string TabletBootstrap::LogPrefix() const {
Status FlushedStoresSnapshot::InitFrom(const TabletMetadata& meta) {
CHECK(flushed_dms_by_drs_id_.empty()) << "already initted";
last_durable_mrs_id_ = meta.last_durable_mrs_id();
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rsmd, meta.rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& rsmd : meta.rowsets()) {
if (!InsertIfNotPresent(&flushed_dms_by_drs_id_, rsmd->id(),
rsmd->last_durable_redo_dms_id())) {
return Status::Corruption(Substitute(
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_metadata.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_metadata.cc b/src/kudu/tablet/tablet_metadata.cc
index 54f33d6..dfaef6a 100644
--- a/src/kudu/tablet/tablet_metadata.cc
+++ b/src/kudu/tablet/tablet_metadata.cc
@@ -128,14 +128,14 @@ Status TabletMetadata::LoadOrCreate(FsManager* fs_manager,
void TabletMetadata::CollectBlockIdPBs(const TabletSuperBlockPB& superblock,
std::vector<BlockIdPB>* block_ids) {
- BOOST_FOREACH(const RowSetDataPB& rowset, superblock.rowsets()) {
- BOOST_FOREACH(const ColumnDataPB& column, rowset.columns()) {
+ for (const RowSetDataPB& rowset : superblock.rowsets()) {
+ for (const ColumnDataPB& column : rowset.columns()) {
block_ids->push_back(column.block());
}
- BOOST_FOREACH(const DeltaDataPB& redo, rowset.redo_deltas()) {
+ for (const DeltaDataPB& redo : rowset.redo_deltas()) {
block_ids->push_back(redo.block());
}
- BOOST_FOREACH(const DeltaDataPB& undo, rowset.undo_deltas()) {
+ for (const DeltaDataPB& undo : rowset.undo_deltas()) {
block_ids->push_back(undo.block());
}
if (rowset.has_bloom_block()) {
@@ -162,7 +162,7 @@ Status TabletMetadata::DeleteTabletData(TabletDataState delete_type,
// we have been deleted.
{
boost::lock_guard<LockType> l(data_lock_);
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rsmd, rowsets_) {
+ for (const shared_ptr<RowSetMetadata>& rsmd : rowsets_) {
AddOrphanedBlocksUnlocked(rsmd->GetAllBlocks());
}
rowsets_.clear();
@@ -315,14 +315,14 @@ Status TabletMetadata::LoadFromSuperBlock(const TabletSuperBlockPB& superblock)
tablet_data_state_ = superblock.tablet_data_state();
rowsets_.clear();
- BOOST_FOREACH(const RowSetDataPB& rowset_pb, superblock.rowsets()) {
+ for (const RowSetDataPB& rowset_pb : superblock.rowsets()) {
gscoped_ptr<RowSetMetadata> rowset_meta;
RETURN_NOT_OK(RowSetMetadata::Load(this, rowset_pb, &rowset_meta));
next_rowset_idx_ = std::max(next_rowset_idx_, rowset_meta->id() + 1);
rowsets_.push_back(shared_ptr<RowSetMetadata>(rowset_meta.release()));
}
- BOOST_FOREACH(const BlockIdPB& block_pb, superblock.orphaned_blocks()) {
+ for (const BlockIdPB& block_pb : superblock.orphaned_blocks()) {
orphaned_blocks.push_back(BlockId::FromPB(block_pb));
}
AddOrphanedBlocksUnlocked(orphaned_blocks);
@@ -372,7 +372,7 @@ void TabletMetadata::DeleteOrphanedBlocks(const vector<BlockId>& blocks) {
}
vector<BlockId> deleted;
- BOOST_FOREACH(const BlockId& b, blocks) {
+ for (const BlockId& b : blocks) {
Status s = fs_manager()->DeleteBlock(b);
// If we get NotFound, then the block was actually successfully
// deleted before. So, we can remove it from our orphaned block list
@@ -388,7 +388,7 @@ void TabletMetadata::DeleteOrphanedBlocks(const vector<BlockId>& blocks) {
// Remove the successfully-deleted blocks from the set.
{
boost::lock_guard<LockType> l(data_lock_);
- BOOST_FOREACH(const BlockId& b, deleted) {
+ for (const BlockId& b : deleted) {
orphaned_blocks_.erase(b);
}
}
@@ -475,7 +475,7 @@ Status TabletMetadata::UpdateUnlocked(
}
}
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, to_add) {
+ for (const shared_ptr<RowSetMetadata>& meta : to_add) {
new_rowsets.push_back(meta);
}
rowsets_ = new_rowsets;
@@ -535,7 +535,7 @@ Status TabletMetadata::ToSuperBlockUnlocked(TabletSuperBlockPB* super_block,
partition_schema_.ToPB(pb.mutable_partition_schema());
pb.set_table_name(table_name_);
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, rowsets) {
+ for (const shared_ptr<RowSetMetadata>& meta : rowsets) {
meta->ToProtobuf(pb.add_rowsets());
}
@@ -548,7 +548,7 @@ Status TabletMetadata::ToSuperBlockUnlocked(TabletSuperBlockPB* super_block,
*pb.mutable_tombstone_last_logged_opid() = tombstone_last_logged_opid_;
}
- BOOST_FOREACH(const BlockId& block_id, orphaned_blocks_) {
+ for (const BlockId& block_id : orphaned_blocks_) {
block_id.CopyToPB(pb.mutable_orphaned_blocks()->Add());
}
@@ -566,7 +566,7 @@ Status TabletMetadata::CreateRowSet(shared_ptr<RowSetMetadata> *rowset,
}
const RowSetMetadata *TabletMetadata::GetRowSetForTests(int64_t id) const {
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rowset_meta, rowsets_) {
+ for (const shared_ptr<RowSetMetadata>& rowset_meta : rowsets_) {
if (rowset_meta->id() == id) {
return rowset_meta.get();
}
@@ -576,7 +576,7 @@ const RowSetMetadata *TabletMetadata::GetRowSetForTests(int64_t id) const {
RowSetMetadata *TabletMetadata::GetRowSetForTests(int64_t id) {
boost::lock_guard<LockType> l(data_lock_);
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rowset_meta, rowsets_) {
+ for (const shared_ptr<RowSetMetadata>& rowset_meta : rowsets_) {
if (rowset_meta->id() == id) {
return rowset_meta.get();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_mm_ops-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_mm_ops-test.cc b/src/kudu/tablet/tablet_mm_ops-test.cc
index b547f59..421f182 100644
--- a/src/kudu/tablet/tablet_mm_ops-test.cc
+++ b/src/kudu/tablet/tablet_mm_ops-test.cc
@@ -72,7 +72,7 @@ class KuduTabletMmOpsTest : public TabletTestBase<IntKeyTestSetup<INT64>> {
scoped_refptr<Histogram>,
ScopedRefPtrHashFunctor<Histogram>,
ScopedRefPtrEqualToFunctor<Histogram> >& metrics) {
- BOOST_FOREACH(const scoped_refptr<Histogram>& c, all_possible_metrics_) {
+ for (const scoped_refptr<Histogram>& c : all_possible_metrics_) {
c->Increment(1); // value doesn't matter
if (ContainsKey(metrics, c)) {
NO_FATALS(StatsShouldChange(op));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_peer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_peer.cc b/src/kudu/tablet/tablet_peer.cc
index 0673b15..bee4465 100644
--- a/src/kudu/tablet/tablet_peer.cc
+++ b/src/kudu/tablet/tablet_peer.cc
@@ -398,7 +398,7 @@ void TabletPeer::GetInFlightTransactions(Transaction::TraceType trace_type,
vector<consensus::TransactionStatusPB>* out) const {
vector<scoped_refptr<TransactionDriver> > pending_transactions;
txn_tracker_.GetPendingTransactions(&pending_transactions);
- BOOST_FOREACH(const scoped_refptr<TransactionDriver>& driver, pending_transactions) {
+ for (const scoped_refptr<TransactionDriver>& driver : pending_transactions) {
if (driver->state() != NULL) {
consensus::TransactionStatusPB status_pb;
status_pb.mutable_op_id()->CopyFrom(driver->GetOpId());
@@ -450,7 +450,7 @@ void TabletPeer::GetEarliestNeededLogIndex(int64_t* min_index) const {
// Next, interrogate the TransactionTracker.
vector<scoped_refptr<TransactionDriver> > pending_transactions;
txn_tracker_.GetPendingTransactions(&pending_transactions);
- BOOST_FOREACH(const scoped_refptr<TransactionDriver>& driver, pending_transactions) {
+ for (const scoped_refptr<TransactionDriver>& driver : pending_transactions) {
OpId tx_op_id = driver->GetOpId();
// A transaction which doesn't have an opid hasn't been submitted for replication yet and
// thus has no need to anchor the log.
@@ -589,7 +589,7 @@ void TabletPeer::RegisterMaintenanceOps(MaintenanceManager* maint_mgr) {
void TabletPeer::UnregisterMaintenanceOps() {
DCHECK(state_change_lock_.is_locked());
- BOOST_FOREACH(MaintenanceOp* op, maintenance_ops_) {
+ for (MaintenanceOp* op : maintenance_ops_) {
op->Unregister();
}
STLDeleteElements(&maintenance_ops_);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/tablet_random_access-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_random_access-test.cc b/src/kudu/tablet/tablet_random_access-test.cc
index 0c85509..bb7b6cd 100644
--- a/src/kudu/tablet/tablet_random_access-test.cc
+++ b/src/kudu/tablet/tablet_random_access-test.cc
@@ -128,7 +128,7 @@ class TestRandomAccess : public KuduTabletTest {
}
}
CHECK_OK(writer_->WriteBatch(pending));
- BOOST_FOREACH(LocalTabletWriter::Op op, pending) {
+ for (LocalTabletWriter::Op op : pending) {
delete op.row;
}
}
@@ -354,7 +354,7 @@ void GenerateTestCase(vector<TestOp>* ops, int len) {
string DumpTestCase(const vector<TestOp>& ops) {
vector<string> names;
- BOOST_FOREACH(TestOp test_op, ops) {
+ for (TestOp test_op : ops) {
names.push_back(TestOp_names[test_op]);
}
return JoinStrings(names, ",\n");
@@ -371,7 +371,7 @@ void TestRandomAccess::RunFuzzCase(const vector<TestOp>& test_ops,
string pending_val = "";
int i = 0;
- BOOST_FOREACH(TestOp test_op, test_ops) {
+ for (TestOp test_op : test_ops) {
string val_in_table = GetRow(1);
ASSERT_EQ("(" + cur_val + ")", val_in_table);
@@ -391,7 +391,7 @@ void TestRandomAccess::RunFuzzCase(const vector<TestOp>& test_ops,
break;
case TEST_FLUSH_OPS:
ASSERT_OK(writer.WriteBatch(ops));
- BOOST_FOREACH(LocalTabletWriter::Op op, ops) {
+ for (LocalTabletWriter::Op op : ops) {
delete op.row;
}
ops.clear();
@@ -416,7 +416,7 @@ void TestRandomAccess::RunFuzzCase(const vector<TestOp>& test_ops,
LOG(FATAL) << test_op;
}
}
- BOOST_FOREACH(LocalTabletWriter::Op op, ops) {
+ for (LocalTabletWriter::Op op : ops) {
delete op.row;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/transactions/transaction_tracker-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/transactions/transaction_tracker-test.cc b/src/kudu/tablet/transactions/transaction_tracker-test.cc
index 9e0817e..af7067c 100644
--- a/src/kudu/tablet/transactions/transaction_tracker-test.cc
+++ b/src/kudu/tablet/transactions/transaction_tracker-test.cc
@@ -99,7 +99,7 @@ class TransactionTrackerTest : public KuduTest {
local_drivers.push_back(driver);
}
- BOOST_FOREACH(const scoped_refptr<TransactionDriver>& d, local_drivers) {
+ for (const scoped_refptr<TransactionDriver>& d : local_drivers) {
drivers->push_back(d);
}
return Status::OK();
@@ -143,7 +143,7 @@ void TransactionTrackerTest::RunTransactionsThread(CountDownLatch* finish_latch)
SleepFor(MonoDelta::FromMilliseconds(1));
// Finish all the transactions
- BOOST_FOREACH(const scoped_refptr<TransactionDriver>& driver, drivers) {
+ for (const scoped_refptr<TransactionDriver>& driver : drivers) {
// And mark the transaction as failed, which will cause it to unregister itself.
driver->Abort(Status::Aborted(""));
}
@@ -248,7 +248,7 @@ TEST_F(TransactionTrackerTest, TestTooManyTransactions) {
NO_FATALS(CheckMemTracker(t));
// Clean up.
- BOOST_FOREACH(const scoped_refptr<TransactionDriver>& driver, drivers) {
+ for (const scoped_refptr<TransactionDriver>& driver : drivers) {
driver->Abort(Status::Aborted(""));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/transactions/transaction_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/transactions/transaction_tracker.cc b/src/kudu/tablet/transactions/transaction_tracker.cc
index eeb68da..ca21cd5 100644
--- a/src/kudu/tablet/transactions/transaction_tracker.cc
+++ b/src/kudu/tablet/transactions/transaction_tracker.cc
@@ -21,7 +21,6 @@
#include <limits>
#include <vector>
-#include <boost/foreach.hpp>
#include "kudu/gutil/map-util.h"
#include "kudu/gutil/strings/substitute.h"
@@ -185,7 +184,7 @@ void TransactionTracker::GetPendingTransactions(
vector<scoped_refptr<TransactionDriver> >* pending_out) const {
DCHECK(pending_out->empty());
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const TxnMap::value_type& e, pending_txns_) {
+ for (const TxnMap::value_type& e : pending_txns_) {
// Increments refcount of each transaction.
pending_out->push_back(e.first);
}
@@ -229,7 +228,7 @@ Status TransactionTracker::WaitForAllToFinish(const MonoDelta& timeout) const {
wait_time = std::min(wait_time * 5 / 4, 1000000);
LOG(INFO) << "Dumping currently running transactions: ";
- BOOST_FOREACH(scoped_refptr<TransactionDriver> driver, txns) {
+ for (scoped_refptr<TransactionDriver> driver : txns) {
LOG(INFO) << driver->ToString();
}
SleepFor(MonoDelta::FromMicroseconds(wait_time));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/transactions/write_transaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/transactions/write_transaction.cc b/src/kudu/tablet/transactions/write_transaction.cc
index 7d6b242..013b312 100644
--- a/src/kudu/tablet/transactions/write_transaction.cc
+++ b/src/kudu/tablet/transactions/write_transaction.cc
@@ -125,7 +125,7 @@ Status WriteTransaction::Apply(gscoped_ptr<CommitMsg>* commit_msg) {
// Add per-row errors to the result, update metrics.
int i = 0;
- BOOST_FOREACH(const RowOp* op, state()->row_ops()) {
+ for (const RowOp* op : state()->row_ops()) {
if (state()->response() != NULL && op->result->has_failed_status()) {
// Replicas disregard the per row errors, for now
// TODO check the per-row errors against the leader's, at least in debug mode
@@ -285,7 +285,7 @@ void WriteTransactionState::Commit() {
void WriteTransactionState::ReleaseTxResultPB(TxResultPB* result) const {
result->Clear();
result->mutable_ops()->Reserve(row_ops_.size());
- BOOST_FOREACH(RowOp* op, row_ops_) {
+ for (RowOp* op : row_ops_) {
result->mutable_ops()->AddAllocated(CHECK_NOTNULL(op->result.release()));
}
}
@@ -312,7 +312,7 @@ void WriteTransactionState::UpdateMetricsForOp(const RowOp& op) {
void WriteTransactionState::release_row_locks() {
// free the row locks
- BOOST_FOREACH(RowOp* op, row_ops_) {
+ for (RowOp* op : row_ops_) {
op->row_lock.Release();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/fs_dump-tool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/fs_dump-tool.cc b/src/kudu/tools/fs_dump-tool.cc
index 9d76ff8..24c151f 100644
--- a/src/kudu/tools/fs_dump-tool.cc
+++ b/src/kudu/tools/fs_dump-tool.cc
@@ -24,7 +24,6 @@
#include <sstream>
#include <vector>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -96,7 +95,7 @@ void PrintUsageToStream(const std::string& prog_name, std::ostream* out) {
<< "-fs_wal_dir <dir> -fs_data_dirs <dirs> <command> <options> "
<< std::endl << std::endl;
*out << "Commands: " << std::endl;
- BOOST_FOREACH(const CommandHandler& handler, kCommandHandlers) {
+ for (const CommandHandler& handler : kCommandHandlers) {
*out << handler.name_ << ": " << handler.desc_ << std::endl;
}
}
@@ -110,7 +109,7 @@ bool ValidateCommand(int argc, char** argv, CommandType* out) {
Usage(argv[0], "At least one command must be specified!");
return false;
}
- BOOST_FOREACH(const CommandHandler& handler, kCommandHandlers) {
+ for (const CommandHandler& handler : kCommandHandlers) {
if (argv[1] == handler.name_) {
*out = handler.type_;
return true;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/fs_list-tool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/fs_list-tool.cc b/src/kudu/tools/fs_list-tool.cc
index 14f6705..996a70f 100644
--- a/src/kudu/tools/fs_list-tool.cc
+++ b/src/kudu/tools/fs_list-tool.cc
@@ -23,7 +23,6 @@
#include <sstream>
#include <vector>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -76,7 +75,7 @@ void PrintUsageToStream(const string& prog_name, std::ostream* out) {
<< "-fs_wal_dir <dir> -fs_data_dirs <dirs> <command> [option] "
<< std::endl << std::endl
<< "Commands: " << std::endl;
- BOOST_FOREACH(const CommandHandler& handler, kCommandHandlers) {
+ for (const CommandHandler& handler : kCommandHandlers) {
*out << handler.name_ << ": " << handler.desc_ << std::endl;
}
}
@@ -92,7 +91,7 @@ bool ValidateCommand(int argc, char** argv, CommandType* out) {
Usage(argv[0], "At least one command must be specified!");
return false;
}
- BOOST_FOREACH(const CommandHandler& handler, kCommandHandlers) {
+ for (const CommandHandler& handler : kCommandHandlers) {
if (argv[1] == handler.name_) {
*out = handler.type_;
return true;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/fs_tool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/fs_tool.cc b/src/kudu/tools/fs_tool.cc
index fe2aef8..83f26bb 100644
--- a/src/kudu/tools/fs_tool.cc
+++ b/src/kudu/tools/fs_tool.cc
@@ -22,7 +22,6 @@
#include <memory>
#include <vector>
-#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -126,7 +125,7 @@ Status FsTool::ListAllLogSegments() {
vector<string> children;
RETURN_NOT_OK_PREPEND(fs_manager_->ListDir(wals_dir, &children),
"Could not list log directories");
- BOOST_FOREACH(const string& child, children) {
+ for (const string& child : children) {
if (HasPrefixString(child, ".")) {
// Hidden files or ./..
VLOG(1) << "Ignoring hidden file in root log directory " << child;
@@ -167,7 +166,7 @@ Status FsTool::ListAllTablets() {
vector<string> tablets;
RETURN_NOT_OK(fs_manager_->ListTabletIds(&tablets));
- BOOST_FOREACH(const string& tablet, tablets) {
+ for (const string& tablet : tablets) {
if (detail_level_ >= HEADERS_ONLY) {
std::cout << "Tablet: " << tablet << std::endl;
RETURN_NOT_OK(PrintTabletMeta(tablet, 2));
@@ -183,7 +182,7 @@ Status FsTool::ListSegmentsInDir(const string& segments_dir) {
RETURN_NOT_OK_PREPEND(fs_manager_->ListDir(segments_dir, &segments),
"Unable to list log segments");
std::cout << "Segments in " << segments_dir << ":" << std::endl;
- BOOST_FOREACH(const string& segment, segments) {
+ for (const string& segment : segments) {
if (!log::IsLogFileName(segment)) {
continue;
}
@@ -249,7 +248,7 @@ Status FsTool::ListBlocksForAllTablets() {
vector<string> tablets;
RETURN_NOT_OK(fs_manager_->ListTabletIds(&tablets));
- BOOST_FOREACH(string tablet, tablets) {
+ for (string tablet : tablets) {
RETURN_NOT_OK(ListBlocksForTablet(tablet));
}
return Status::OK();
@@ -271,7 +270,7 @@ Status FsTool::ListBlocksForTablet(const string& tablet_id) {
Schema schema = meta->schema();
size_t idx = 0;
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rs_meta, meta->rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& rs_meta : meta->rowsets()) {
std::cout << "Rowset " << idx++ << std::endl;
RETURN_NOT_OK(ListBlocksInRowSet(schema, *rs_meta));
}
@@ -282,7 +281,7 @@ Status FsTool::ListBlocksForTablet(const string& tablet_id) {
Status FsTool::ListBlocksInRowSet(const Schema& schema,
const RowSetMetadata& rs_meta) {
RowSetMetadata::ColumnIdToBlockIdMap col_blocks = rs_meta.GetColumnBlocksById();
- BOOST_FOREACH(const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e, col_blocks) {
+ for (const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e : col_blocks) {
ColumnId col_id = e.first;
const BlockId& block_id = e.second;
std::cout << "Column block for column ID " << col_id;
@@ -294,11 +293,11 @@ Status FsTool::ListBlocksInRowSet(const Schema& schema,
std::cout << block_id.ToString() << std::endl;
}
- BOOST_FOREACH(const BlockId& block, rs_meta.undo_delta_blocks()) {
+ for (const BlockId& block : rs_meta.undo_delta_blocks()) {
std::cout << "UNDO: " << block.ToString() << std::endl;
}
- BOOST_FOREACH(const BlockId& block, rs_meta.redo_delta_blocks()) {
+ for (const BlockId& block : rs_meta.redo_delta_blocks()) {
std::cout << "REDO: " << block.ToString() << std::endl;
}
@@ -322,7 +321,7 @@ Status FsTool::DumpTabletBlocks(const std::string& tablet_id,
Schema schema = meta->schema();
size_t idx = 0;
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rs_meta, meta->rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& rs_meta : meta->rowsets()) {
std::cout << std::endl << Indent(indent) << "Dumping rowset " << idx++
<< std::endl << Indent(indent) << kSeparatorLine;
RETURN_NOT_OK(DumpRowSetInternal(meta->schema(), rs_meta, opts, indent + 2));
@@ -341,7 +340,7 @@ Status FsTool::DumpTabletData(const std::string& tablet_id) {
RETURN_NOT_OK_PREPEND(t.Open(), "Couldn't open tablet");
vector<string> lines;
RETURN_NOT_OK_PREPEND(t.DebugDump(&lines), "Couldn't dump tablet");
- BOOST_FOREACH(const string& line, lines) {
+ for (const string& line : lines) {
std::cout << line << std::endl;
}
return Status::OK();
@@ -356,7 +355,7 @@ Status FsTool::DumpRowSet(const string& tablet_id,
scoped_refptr<TabletMetadata> meta;
RETURN_NOT_OK(TabletMetadata::Load(fs_manager_.get(), tablet_id, &meta));
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& rs_meta, meta->rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& rs_meta : meta->rowsets()) {
if (rs_meta->id() == rowset_id) {
return DumpRowSetInternal(meta->schema(), rs_meta, opts, indent);
}
@@ -377,7 +376,7 @@ Status FsTool::DumpRowSetInternal(const Schema& schema,
<< std::endl;
RowSetMetadata::ColumnIdToBlockIdMap col_blocks = rs_meta->GetColumnBlocksById();
- BOOST_FOREACH(const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e, col_blocks) {
+ for (const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e : col_blocks) {
ColumnId col_id = e.first;
const BlockId& block_id = e.second;
@@ -394,7 +393,7 @@ Status FsTool::DumpRowSetInternal(const Schema& schema,
std::cout << std::endl;
}
- BOOST_FOREACH(const BlockId& block, rs_meta->undo_delta_blocks()) {
+ for (const BlockId& block : rs_meta->undo_delta_blocks()) {
std::cout << Indent(indent) << "Dumping undo delta block " << block << ":" << std::endl
<< Indent(indent) << kSeparatorLine;
RETURN_NOT_OK(DumpDeltaCFileBlockInternal(schema,
@@ -407,7 +406,7 @@ Status FsTool::DumpRowSetInternal(const Schema& schema,
std::cout << std::endl;
}
- BOOST_FOREACH(const BlockId& block, rs_meta->redo_delta_blocks()) {
+ for (const BlockId& block : rs_meta->redo_delta_blocks()) {
std::cout << Indent(indent) << "Dumping redo delta block " << block << ":" << std::endl
<< Indent(indent) << kSeparatorLine;
RETURN_NOT_OK(DumpDeltaCFileBlockInternal(schema,
@@ -557,7 +556,7 @@ Status FsTool::DumpDeltaCFileBlockInternal(const Schema& schema,
RETURN_NOT_OK(delta_iter->FilterColumnIdsAndCollectDeltas(vector<ColumnId>(),
&out,
&arena));
- BOOST_FOREACH(const DeltaKeyAndUpdate& upd, out) {
+ for (const DeltaKeyAndUpdate& upd : out) {
if (detail_level_ > HEADERS_ONLY) {
std::cout << Indent(indent) << upd.key.ToString() << " "
<< RowChangeList(upd.cell).ToString(schema) << std::endl;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/insert-generated-rows.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/insert-generated-rows.cc b/src/kudu/tools/insert-generated-rows.cc
index 6422933..8e59857 100644
--- a/src/kudu/tools/insert-generated-rows.cc
+++ b/src/kudu/tools/insert-generated-rows.cc
@@ -19,7 +19,6 @@
// First column is in ascending order, the rest are random data.
// Helps make things like availability demos a little easier.
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <iostream>
@@ -107,7 +106,7 @@ static int WriteRandomDataToTable(int argc, char** argv) {
bool overflow;
session->GetPendingErrors(&errors, &overflow);
CHECK(!overflow);
- BOOST_FOREACH(const client::KuduError* e, errors) {
+ for (const client::KuduError* e : errors) {
if (e->status().IsAlreadyPresent()) {
LOG(WARNING) << "Ignoring insert error: " << e->status().ToString();
} else {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/ksck-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ksck-test.cc b/src/kudu/tools/ksck-test.cc
index aeb4a7c..5cbdee0 100644
--- a/src/kudu/tools/ksck-test.cc
+++ b/src/kudu/tools/ksck-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <gtest/gtest.h>
#include <memory>
@@ -119,7 +118,7 @@ class KsckTest : public KuduTest {
protected:
void CreateDefaultAssignmentPlan(int tablets_count) {
while (tablets_count > 0) {
- BOOST_FOREACH(const KsckMaster::TSMap::value_type& entry, master_->tablet_servers_) {
+ for (const KsckMaster::TSMap::value_type& entry : master_->tablet_servers_) {
if (tablets_count-- == 0) return;
assignment_plan_.push_back(entry.second->uuid());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/ksck.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ksck.cc b/src/kudu/tools/ksck.cc
index f02ceda..5ab4e74 100644
--- a/src/kudu/tools/ksck.cc
+++ b/src/kudu/tools/ksck.cc
@@ -17,7 +17,6 @@
#include "kudu/tools/ksck.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <iostream>
#include <unordered_set>
@@ -96,7 +95,7 @@ Status KsckCluster::FetchTableAndTabletInfo() {
RETURN_NOT_OK(master_->Connect());
RETURN_NOT_OK(RetrieveTablesList());
RETURN_NOT_OK(RetrieveTabletServers());
- BOOST_FOREACH(const shared_ptr<KsckTable>& table, tables()) {
+ for (const shared_ptr<KsckTable>& table : tables()) {
RETURN_NOT_OK(RetrieveTabletsList(table));
}
return Status::OK();
@@ -140,7 +139,7 @@ Status Ksck::CheckTabletServersRunning() {
int bad_servers = 0;
VLOG(1) << "Connecting to all the Tablet Servers";
- BOOST_FOREACH(const KsckMaster::TSMap::value_type& entry, cluster_->tablet_servers()) {
+ for (const KsckMaster::TSMap::value_type& entry : cluster_->tablet_servers()) {
Status s = ConnectToTabletServer(entry.second);
if (!s.ok()) {
bad_servers++;
@@ -180,7 +179,7 @@ Status Ksck::CheckTablesConsistency() {
VLOG(1) << "Verifying each table";
int bad_tables_count = 0;
- BOOST_FOREACH(const shared_ptr<KsckTable> &table, cluster_->tables()) {
+ for (const shared_ptr<KsckTable> &table : cluster_->tables()) {
if (!VerifyTable(table)) {
bad_tables_count++;
}
@@ -293,10 +292,10 @@ Status Ksck::ChecksumData(const vector<string>& tables,
TabletTableMap tablet_table_map;
int num_tablet_replicas = 0;
- BOOST_FOREACH(const shared_ptr<KsckTable>& table, cluster_->tables()) {
+ for (const shared_ptr<KsckTable>& table : cluster_->tables()) {
VLOG(1) << "Table: " << table->name();
if (!tables_filter.empty() && !ContainsKey(tables_filter, table->name())) continue;
- BOOST_FOREACH(const shared_ptr<KsckTablet>& tablet, table->tablets()) {
+ for (const shared_ptr<KsckTablet>& tablet : table->tablets()) {
VLOG(1) << "Tablet: " << tablet->id();
if (!tablets_filter.empty() && !ContainsKey(tablets_filter, tablet->id())) continue;
InsertOrDie(&tablet_table_map, tablet, table);
@@ -324,10 +323,10 @@ Status Ksck::ChecksumData(const vector<string>& tables,
scoped_refptr<ChecksumResultReporter> reporter(new ChecksumResultReporter(num_tablet_replicas));
// Create a queue of checksum callbacks grouped by the tablet server.
- BOOST_FOREACH(const TabletTableMap::value_type& entry, tablet_table_map) {
+ for (const TabletTableMap::value_type& entry : tablet_table_map) {
const shared_ptr<KsckTablet>& tablet = entry.first;
const shared_ptr<KsckTable>& table = entry.second;
- BOOST_FOREACH(const shared_ptr<KsckTabletReplica>& replica, tablet->replicas()) {
+ for (const shared_ptr<KsckTabletReplica>& replica : tablet->replicas()) {
const shared_ptr<KsckTabletServer>& ts =
FindOrDie(cluster_->tablet_servers(), replica->ts_uuid());
@@ -346,7 +345,7 @@ Status Ksck::ChecksumData(const vector<string>& tables,
// Kick off checksum scans in parallel. For each tablet server, we start
// scan_concurrency scans. Each callback then initiates one additional
// scan when it returns if the queue for that TS is not empty.
- BOOST_FOREACH(const TabletServerQueueMap::value_type& entry, tablet_server_queues) {
+ for (const TabletServerQueueMap::value_type& entry : tablet_server_queues) {
const shared_ptr<KsckTabletServer>& tablet_server = entry.first;
const TabletQueue& queue = entry.second;
queue->Shutdown(); // Ensures that BlockingGet() will not block.
@@ -375,9 +374,9 @@ Status Ksck::ChecksumData(const vector<string>& tables,
int num_errors = 0;
int num_mismatches = 0;
int num_results = 0;
- BOOST_FOREACH(const shared_ptr<KsckTable>& table, cluster_->tables()) {
+ for (const shared_ptr<KsckTable>& table : cluster_->tables()) {
bool printed_table_name = false;
- BOOST_FOREACH(const shared_ptr<KsckTablet>& tablet, table->tablets()) {
+ for (const shared_ptr<KsckTablet>& tablet : table->tablets()) {
if (ContainsKey(checksums, tablet->id())) {
if (!printed_table_name) {
printed_table_name = true;
@@ -388,7 +387,7 @@ Status Ksck::ChecksumData(const vector<string>& tables,
bool seen_first_replica = false;
uint64_t first_checksum = 0;
- BOOST_FOREACH(const ChecksumResultReporter::ReplicaResultMap::value_type& r,
+ for (const ChecksumResultReporter::ReplicaResultMap::value_type& r :
FindOrDie(checksums, tablet->id())) {
const string& replica_uuid = r.first;
@@ -447,7 +446,7 @@ bool Ksck::VerifyTable(const shared_ptr<KsckTable>& table) {
tablets_count, table->name(), table_num_replicas);
int bad_tablets_count = 0;
// TODO check if the tablets are contiguous and in order.
- BOOST_FOREACH(const shared_ptr<KsckTablet> &tablet, tablets) {
+ for (const shared_ptr<KsckTablet> &tablet : tablets) {
if (!VerifyTablet(tablet, table_num_replicas)) {
bad_tablets_count++;
}
@@ -474,7 +473,7 @@ bool Ksck::VerifyTablet(const shared_ptr<KsckTablet>& tablet, int table_num_repl
}
int leaders_count = 0;
int followers_count = 0;
- BOOST_FOREACH(const shared_ptr<KsckTabletReplica> replica, replicas) {
+ for (const shared_ptr<KsckTabletReplica> replica : replicas) {
if (replica->is_leader()) {
VLOG(1) << Substitute("Replica at $0 is a LEADER", replica->ts_uuid());
leaders_count++;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/ksck_remote-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ksck_remote-test.cc b/src/kudu/tools/ksck_remote-test.cc
index 523fb34..579f571 100644
--- a/src/kudu/tools/ksck_remote-test.cc
+++ b/src/kudu/tools/ksck_remote-test.cc
@@ -137,7 +137,7 @@ class RemoteKsckTest : public KuduTest {
vector<const KuduPartialRow*> GenerateSplitRows() {
vector<const KuduPartialRow*> split_rows;
vector<int> split_nums = { 33, 66 };
- BOOST_FOREACH(int i, split_nums) {
+ for (int i : split_nums) {
KuduPartialRow* row = schema_.NewRow();
CHECK_OK(row->SetInt32(0, i));
split_rows.push_back(row);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/ksck_remote.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ksck_remote.cc b/src/kudu/tools/ksck_remote.cc
index fe1efcf..c800ee4 100644
--- a/src/kudu/tools/ksck_remote.cc
+++ b/src/kudu/tools/ksck_remote.cc
@@ -241,7 +241,7 @@ Status RemoteKsckMaster::RetrieveTabletServers(TSMap* tablet_servers) {
rpc.set_timeout(GetDefaultTimeout());
RETURN_NOT_OK(proxy_->ListTabletServers(req, &resp, &rpc));
tablet_servers->clear();
- BOOST_FOREACH(const master::ListTabletServersResponsePB_Entry& e, resp.servers()) {
+ for (const master::ListTabletServersResponsePB_Entry& e : resp.servers()) {
HostPortPB addr = e.registration().rpc_addresses(0);
vector<Sockaddr> addresses;
RETURN_NOT_OK(ParseAddressList(HostPort(addr.host(), addr.port()).ToString(),
@@ -264,7 +264,7 @@ Status RemoteKsckMaster::RetrieveTablesList(vector<shared_ptr<KsckTable> >* tabl
return StatusFromPB(resp.error().status());
}
vector<shared_ptr<KsckTable> > tables_temp;
- BOOST_FOREACH(const master::ListTablesResponsePB_TableInfo& info, resp.tables()) {
+ for (const master::ListTablesResponsePB_TableInfo& info : resp.tables()) {
Schema schema;
int num_replicas;
RETURN_NOT_OK(GetTableInfo(info.name(), &schema, &num_replicas));
@@ -301,10 +301,10 @@ Status RemoteKsckMaster::GetTabletsBatch(const string& table_name,
rpc.set_timeout(GetDefaultTimeout());
RETURN_NOT_OK(proxy_->GetTableLocations(req, &resp, &rpc));
- BOOST_FOREACH(const master::TabletLocationsPB& locations, resp.tablet_locations()) {
+ for (const master::TabletLocationsPB& locations : resp.tablet_locations()) {
shared_ptr<KsckTablet> tablet(new KsckTablet(locations.tablet_id()));
vector<shared_ptr<KsckTabletReplica> > replicas;
- BOOST_FOREACH(const master::TabletLocationsPB_ReplicaPB& replica, locations.replicas()) {
+ for (const master::TabletLocationsPB_ReplicaPB& replica : locations.replicas()) {
bool is_leader = replica.role() == consensus::RaftPeerPB::LEADER;
bool is_follower = replica.role() == consensus::RaftPeerPB::FOLLOWER;
replicas.push_back(shared_ptr<KsckTabletReplica>(
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/kudu-admin-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/kudu-admin-test.cc b/src/kudu/tools/kudu-admin-test.cc
index a9474b2..9ba8bd8 100644
--- a/src/kudu/tools/kudu-admin-test.cc
+++ b/src/kudu/tools/kudu-admin-test.cc
@@ -17,7 +17,6 @@
//
// Tests for the kudu-admin command-line tool.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/client/client.h"
@@ -82,7 +81,7 @@ TEST_F(AdminCliTest, TestChangeConfig) {
InsertOrDie(&active_tablet_servers, follower->uuid(), follower);
TServerDetails* new_node = NULL;
- BOOST_FOREACH(TServerDetails* ts, tservers) {
+ for (TServerDetails* ts : tservers) {
if (!ContainsKey(active_tablet_servers, ts->uuid())) {
new_node = ts;
break;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/kudu-admin.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/kudu-admin.cc b/src/kudu/tools/kudu-admin.cc
index 6c472ce..d2952ef 100644
--- a/src/kudu/tools/kudu-admin.cc
+++ b/src/kudu/tools/kudu-admin.cc
@@ -17,7 +17,6 @@
//
// Tool to administer a cluster from the CLI.
-#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -278,7 +277,7 @@ Status ClusterAdminClient::GetTabletLeader(const string& tablet_id,
RETURN_NOT_OK(GetTabletLocations(tablet_id, &locations));
CHECK_EQ(tablet_id, locations.tablet_id()) << locations.ShortDebugString();
bool found = false;
- BOOST_FOREACH(const TabletLocationsPB::ReplicaPB& replica, locations.replicas()) {
+ for (const TabletLocationsPB::ReplicaPB& replica : locations.replicas()) {
if (replica.role() == RaftPeerPB::LEADER) {
*ts_info = replica.ts_info();
found = true;
@@ -311,7 +310,7 @@ Status ClusterAdminClient::ListTabletServers(
Status ClusterAdminClient::GetFirstRpcAddressForTS(const std::string& uuid, HostPort* hp) {
RepeatedPtrField<ListTabletServersResponsePB::Entry> servers;
RETURN_NOT_OK(ListTabletServers(&servers));
- BOOST_FOREACH(const ListTabletServersResponsePB::Entry& server, servers) {
+ for (const ListTabletServersResponsePB::Entry& server : servers) {
if (server.instance_id().permanent_uuid() == uuid) {
if (!server.has_registration() || server.registration().rpc_addresses_size() == 0) {
break;
@@ -328,7 +327,7 @@ Status ClusterAdminClient::GetFirstRpcAddressForTS(const std::string& uuid, Host
Status ClusterAdminClient::ListTables() {
vector<string> tables;
RETURN_NOT_OK(kudu_client_->ListTables(&tables));
- BOOST_FOREACH(const string& table, tables) {
+ for (const string& table : tables) {
std::cout << table << std::endl;
}
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/kudu-ksck.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/kudu-ksck.cc b/src/kudu/tools/kudu-ksck.cc
index dacd797..86f4a3a 100644
--- a/src/kudu/tools/kudu-ksck.cc
+++ b/src/kudu/tools/kudu-ksck.cc
@@ -139,7 +139,7 @@ int main(int argc, char** argv) {
cerr << "==================" << endl;
cerr << "Errors:" << endl;
cerr << "==================" << endl;
- BOOST_FOREACH(const string& s, error_messages) {
+ for (const string& s : error_messages) {
cerr << s << endl;
}
cerr << endl;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/kudu-ts-cli-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/kudu-ts-cli-test.cc b/src/kudu/tools/kudu-ts-cli-test.cc
index 6a353dc..2a65de0 100644
--- a/src/kudu/tools/kudu-ts-cli-test.cc
+++ b/src/kudu/tools/kudu-ts-cli-test.cc
@@ -18,7 +18,6 @@
// Tests for the kudu-admin command-line tool.
#include <boost/assign/list_of.hpp>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include "kudu/gutil/map-util.h"
@@ -69,7 +68,7 @@ TEST_F(KuduTsCliTest, TestDeleteTablet) {
workload.Setup(); // Easy way to create a new tablet.
vector<tserver::ListTabletsResponsePB::StatusAndSchemaPB> tablets;
- BOOST_FOREACH(const itest::TabletServerMap::value_type& entry, ts_map_) {
+ for (const itest::TabletServerMap::value_type& entry : ts_map_) {
TServerDetails* ts = entry.second;
ASSERT_OK(itest::WaitForNumTabletsOnTS(ts, 1, timeout, &tablets));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tools/ts-cli.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ts-cli.cc b/src/kudu/tools/ts-cli.cc
index 9d77023..dd204b8 100644
--- a/src/kudu/tools/ts-cli.cc
+++ b/src/kudu/tools/ts-cli.cc
@@ -17,7 +17,6 @@
//
// Tool to query tablet server operational data
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <iostream>
@@ -236,7 +235,7 @@ Status TsAdminClient::GetTabletSchema(const std::string& tablet_id,
VLOG(1) << "Fetching schema for tablet " << tablet_id;
vector<StatusAndSchemaPB> tablets;
RETURN_NOT_OK(ListTablets(&tablets));
- BOOST_FOREACH(const StatusAndSchemaPB& pair, tablets) {
+ for (const StatusAndSchemaPB& pair : tablets) {
if (pair.tablet_status().tablet_id() == tablet_id) {
*schema = pair.schema();
return Status::OK();
@@ -276,7 +275,7 @@ Status TsAdminClient::DumpTablet(const std::string& tablet_id) {
rows.clear();
RETURN_NOT_OK(KuduScanner::Data::ExtractRows(rpc, &schema, &resp, &rows));
- BOOST_FOREACH(const KuduRowResult& r, rows) {
+ for (const KuduRowResult& r : rows) {
std::cout << r.ToString() << std::endl;
}
@@ -389,7 +388,7 @@ static int TsCliMain(int argc, char** argv) {
vector<StatusAndSchemaPB> tablets;
RETURN_NOT_OK_PREPEND_FROM_MAIN(client.ListTablets(&tablets),
"Unable to list tablets on " + addr);
- BOOST_FOREACH(const StatusAndSchemaPB& status_and_schema, tablets) {
+ for (const StatusAndSchemaPB& status_and_schema : tablets) {
Schema schema;
RETURN_NOT_OK_PREPEND_FROM_MAIN(SchemaFromPB(status_and_schema.schema(), &schema),
"Unable to deserialize schema from " + addr);
@@ -423,7 +422,7 @@ static int TsCliMain(int argc, char** argv) {
RETURN_NOT_OK_PREPEND_FROM_MAIN(client.ListTablets(&tablets),
"Unable to list tablets on " + addr);
bool all_running = true;
- BOOST_FOREACH(const StatusAndSchemaPB& status_and_schema, tablets) {
+ for (const StatusAndSchemaPB& status_and_schema : tablets) {
TabletStatusPB ts = status_and_schema.tablet_status();
if (ts.state() != tablet::RUNNING) {
std::cout << "Tablet id: " << ts.tablet_id() << " is "
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/heartbeater.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/heartbeater.cc b/src/kudu/tserver/heartbeater.cc
index 6a92fcf..18687be 100644
--- a/src/kudu/tserver/heartbeater.cc
+++ b/src/kudu/tserver/heartbeater.cc
@@ -17,7 +17,6 @@
#include "kudu/tserver/heartbeater.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <memory>
@@ -207,7 +206,7 @@ Status Heartbeater::Thread::FindLeaderMaster(const MonoTime& deadline,
return Status::OK();
}
vector<Sockaddr> master_sock_addrs;
- BOOST_FOREACH(const HostPort& master_addr, master_addrs_) {
+ for (const HostPort& master_addr : master_addrs_) {
vector<Sockaddr> addrs;
Status s = master_addr.ResolveAddresses(&addrs);
if (!s.ok()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_client-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_client-test.cc b/src/kudu/tserver/remote_bootstrap_client-test.cc
index eb51d67..eda5f0c 100644
--- a/src/kudu/tserver/remote_bootstrap_client-test.cc
+++ b/src/kudu/tserver/remote_bootstrap_client-test.cc
@@ -181,14 +181,14 @@ namespace {
vector<BlockId> GetAllSortedBlocks(const tablet::TabletSuperBlockPB& sb) {
vector<BlockId> data_blocks;
- BOOST_FOREACH(const tablet::RowSetDataPB& rowset, sb.rowsets()) {
- BOOST_FOREACH(const tablet::DeltaDataPB& redo, rowset.redo_deltas()) {
+ for (const tablet::RowSetDataPB& rowset : sb.rowsets()) {
+ for (const tablet::DeltaDataPB& redo : rowset.redo_deltas()) {
data_blocks.push_back(BlockId::FromPB(redo.block()));
}
- BOOST_FOREACH(const tablet::DeltaDataPB& undo, rowset.undo_deltas()) {
+ for (const tablet::DeltaDataPB& undo : rowset.undo_deltas()) {
data_blocks.push_back(BlockId::FromPB(undo.block()));
}
- BOOST_FOREACH(const tablet::ColumnDataPB& column, rowset.columns()) {
+ for (const tablet::ColumnDataPB& column : rowset.columns()) {
data_blocks.push_back(BlockId::FromPB(column.block()));
}
if (rowset.has_bloom_block()) {
@@ -226,13 +226,13 @@ TEST_F(RemoteBootstrapClientTest, TestDownloadAllBlocks) {
// Verify that the old blocks aren't found. We're using a different
// FsManager than 'tablet_peer', so the only way an old block could end
// up in ours is due to a remote bootstrap client bug.
- BOOST_FOREACH(const BlockId& block_id, old_data_blocks) {
+ for (const BlockId& block_id : old_data_blocks) {
gscoped_ptr<fs::ReadableBlock> block;
Status s = fs_manager_->OpenBlock(block_id, &block);
ASSERT_TRUE(s.IsNotFound()) << "Expected block not found: " << s.ToString();
}
// And the new blocks are all present.
- BOOST_FOREACH(const BlockId& block_id, new_data_blocks) {
+ for (const BlockId& block_id : new_data_blocks) {
gscoped_ptr<fs::ReadableBlock> block;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_client.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_client.cc b/src/kudu/tserver/remote_bootstrap_client.cc
index 7d4cda8..1eb0e4f 100644
--- a/src/kudu/tserver/remote_bootstrap_client.cc
+++ b/src/kudu/tserver/remote_bootstrap_client.cc
@@ -344,7 +344,7 @@ Status RemoteBootstrapClient::DownloadWALs() {
int num_segments = wal_seqnos_.size();
LOG_WITH_PREFIX(INFO) << "Starting download of " << num_segments << " WAL segments...";
uint64_t counter = 0;
- BOOST_FOREACH(uint64_t seg_seqno, wal_seqnos_) {
+ for (uint64_t seg_seqno : wal_seqnos_) {
UpdateStatusMessage(Substitute("Downloading WAL segment with seq. number $0 ($1/$2)",
seg_seqno, counter + 1, num_segments));
RETURN_NOT_OK(DownloadWAL(seg_seqno));
@@ -360,7 +360,7 @@ Status RemoteBootstrapClient::DownloadBlocks() {
// Count up the total number of blocks to download.
int num_blocks = 0;
- BOOST_FOREACH(const RowSetDataPB& rowset, superblock_->rowsets()) {
+ for (const RowSetDataPB& rowset : superblock_->rowsets()) {
num_blocks += rowset.columns_size();
num_blocks += rowset.redo_deltas_size();
num_blocks += rowset.undo_deltas_size();
@@ -378,16 +378,16 @@ Status RemoteBootstrapClient::DownloadBlocks() {
new_sb->CopyFrom(*superblock_);
int block_count = 0;
LOG_WITH_PREFIX(INFO) << "Starting download of " << num_blocks << " data blocks...";
- BOOST_FOREACH(RowSetDataPB& rowset, *new_sb->mutable_rowsets()) {
- BOOST_FOREACH(ColumnDataPB& col, *rowset.mutable_columns()) {
+ for (RowSetDataPB& rowset : *new_sb->mutable_rowsets()) {
+ for (ColumnDataPB& col : *rowset.mutable_columns()) {
RETURN_NOT_OK(DownloadAndRewriteBlock(col.mutable_block(),
&block_count, num_blocks));
}
- BOOST_FOREACH(DeltaDataPB& redo, *rowset.mutable_redo_deltas()) {
+ for (DeltaDataPB& redo : *rowset.mutable_redo_deltas()) {
RETURN_NOT_OK(DownloadAndRewriteBlock(redo.mutable_block(),
&block_count, num_blocks));
}
- BOOST_FOREACH(DeltaDataPB& undo, *rowset.mutable_undo_deltas()) {
+ for (DeltaDataPB& undo : *rowset.mutable_undo_deltas()) {
RETURN_NOT_OK(DownloadAndRewriteBlock(undo.mutable_block(),
&block_count, num_blocks));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_service-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_service-test.cc b/src/kudu/tserver/remote_bootstrap_service-test.cc
index e1e4183..ebf9c69 100644
--- a/src/kudu/tserver/remote_bootstrap_service-test.cc
+++ b/src/kudu/tserver/remote_bootstrap_service-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include "kudu/tserver/remote_bootstrap-test-base.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <limits>
@@ -223,7 +222,7 @@ TEST_F(RemoteBootstrapServiceTest, TestInvalidSessionId) {
bad_session_ids.push_back(GetLocalUUID());
// Fetch a block for a non-existent session.
- BOOST_FOREACH(const string& session_id, bad_session_ids) {
+ for (const string& session_id : bad_session_ids) {
FetchDataResponsePB resp;
RpcController controller;
DataIdPB data_id;
@@ -235,7 +234,7 @@ TEST_F(RemoteBootstrapServiceTest, TestInvalidSessionId) {
}
// End a non-existent session.
- BOOST_FOREACH(const string& session_id, bad_session_ids) {
+ for (const string& session_id : bad_session_ids) {
EndRemoteBootstrapSessionResponsePB resp;
RpcController controller;
Status status = DoEndRemoteBootstrapSession(session_id, true, NULL, &resp, &controller);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_service.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_service.cc b/src/kudu/tserver/remote_bootstrap_service.cc
index 119c452..eb9ab89 100644
--- a/src/kudu/tserver/remote_bootstrap_service.cc
+++ b/src/kudu/tserver/remote_bootstrap_service.cc
@@ -18,7 +18,6 @@
#include <algorithm>
#include <boost/date_time/time_duration.hpp>
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -150,7 +149,7 @@ void RemoteBootstrapServiceImpl::BeginRemoteBootstrapSession(
resp->mutable_superblock()->CopyFrom(session->tablet_superblock());
resp->mutable_initial_committed_cstate()->CopyFrom(session->initial_committed_cstate());
- BOOST_FOREACH(const scoped_refptr<log::ReadableLogSegment>& segment, session->log_segments()) {
+ for (const scoped_refptr<log::ReadableLogSegment>& segment : session->log_segments()) {
resp->add_wal_segment_seqnos(segment->header().sequence_number());
}
@@ -258,10 +257,10 @@ void RemoteBootstrapServiceImpl::Shutdown() {
// Destroy all remote bootstrap sessions.
vector<string> session_ids;
- BOOST_FOREACH(const MonoTimeMap::value_type& entry, session_expirations_) {
+ for (const MonoTimeMap::value_type& entry : session_expirations_) {
session_ids.push_back(entry.first);
}
- BOOST_FOREACH(const string& session_id, session_ids) {
+ for (const string& session_id : session_ids) {
LOG(INFO) << "Destroying remote bootstrap session " << session_id << " due to service shutdown";
RemoteBootstrapErrorPB::Code app_error;
CHECK_OK(DoEndRemoteBootstrapSessionUnlocked(session_id, &app_error));
@@ -339,14 +338,14 @@ void RemoteBootstrapServiceImpl::EndExpiredSessions() {
MonoTime now = MonoTime::Now(MonoTime::FINE);
vector<string> expired_session_ids;
- BOOST_FOREACH(const MonoTimeMap::value_type& entry, session_expirations_) {
+ for (const MonoTimeMap::value_type& entry : session_expirations_) {
const string& session_id = entry.first;
const MonoTime& expiration = entry.second;
if (expiration.ComesBefore(now)) {
expired_session_ids.push_back(session_id);
}
}
- BOOST_FOREACH(const string& session_id, expired_session_ids) {
+ for (const string& session_id : expired_session_ids) {
LOG(INFO) << "Remote bootstrap session " << session_id
<< " has expired. Terminating session.";
RemoteBootstrapErrorPB::Code app_error;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_session-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_session-test.cc b/src/kudu/tserver/remote_bootstrap_session-test.cc
index 4852020..11443e7 100644
--- a/src/kudu/tserver/remote_bootstrap_session-test.cc
+++ b/src/kudu/tserver/remote_bootstrap_session-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include "kudu/tablet/tablet-test-util.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <memory>
@@ -291,14 +290,14 @@ TEST_F(RemoteBootstrapTest, TestBlocksAreFetchableAfterBeingDeleted) {
// Gather all the blocks.
vector<BlockId> data_blocks;
- BOOST_FOREACH(const RowSetDataPB& rowset, tablet_superblock.rowsets()) {
- BOOST_FOREACH(const DeltaDataPB& redo, rowset.redo_deltas()) {
+ for (const RowSetDataPB& rowset : tablet_superblock.rowsets()) {
+ for (const DeltaDataPB& redo : rowset.redo_deltas()) {
data_blocks.push_back(BlockId::FromPB(redo.block()));
}
- BOOST_FOREACH(const DeltaDataPB& undo, rowset.undo_deltas()) {
+ for (const DeltaDataPB& undo : rowset.undo_deltas()) {
data_blocks.push_back(BlockId::FromPB(undo.block()));
}
- BOOST_FOREACH(const ColumnDataPB& column, rowset.columns()) {
+ for (const ColumnDataPB& column : rowset.columns()) {
data_blocks.push_back(BlockId::FromPB(column.block()));
}
if (rowset.has_bloom_block()) {
@@ -310,12 +309,12 @@ TEST_F(RemoteBootstrapTest, TestBlocksAreFetchableAfterBeingDeleted) {
}
// Delete them.
- BOOST_FOREACH(const BlockId& block_id, data_blocks) {
+ for (const BlockId& block_id : data_blocks) {
ASSERT_OK(fs_manager()->DeleteBlock(block_id));
}
// Read them back.
- BOOST_FOREACH(const BlockId& block_id, data_blocks) {
+ for (const BlockId& block_id : data_blocks) {
ASSERT_TRUE(session_->IsBlockOpenForTests(block_id));
string data;
RemoteBootstrapErrorPB::Code error_code;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/remote_bootstrap_session.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/remote_bootstrap_session.cc b/src/kudu/tserver/remote_bootstrap_session.cc
index 7a80f93..8520810 100644
--- a/src/kudu/tserver/remote_bootstrap_session.cc
+++ b/src/kudu/tserver/remote_bootstrap_session.cc
@@ -92,7 +92,7 @@ Status RemoteBootstrapSession::Init() {
// All subsequent requests should reuse the opened blocks.
vector<BlockIdPB> data_blocks;
TabletMetadata::CollectBlockIdPBs(tablet_superblock_, &data_blocks);
- BOOST_FOREACH(const BlockIdPB& block_id, data_blocks) {
+ for (const BlockIdPB& block_id : data_blocks) {
LOG(INFO) << "Opening block " << block_id.DebugString();
RETURN_NOT_OK(OpenBlockUnlocked(BlockId::FromPB(block_id)));
}
@@ -105,7 +105,7 @@ Status RemoteBootstrapSession::Init() {
// The Log doesn't add the active segment to the log reader's list until
// a header has been written to it (but it will not have a footer).
RETURN_NOT_OK(tablet_peer_->log()->GetLogReader()->GetSegmentsSnapshot(&log_segments_));
- BOOST_FOREACH(const scoped_refptr<ReadableLogSegment>& segment, log_segments_) {
+ for (const scoped_refptr<ReadableLogSegment>& segment : log_segments_) {
RETURN_NOT_OK(OpenLogSegmentUnlocked(segment->header().sequence_number()));
}
LOG(INFO) << "Got snapshot of " << log_segments_.size() << " log segments";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/scanners.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/scanners.cc b/src/kudu/tserver/scanners.cc
index 684e8ac..0f1aca3 100644
--- a/src/kudu/tserver/scanners.cc
+++ b/src/kudu/tserver/scanners.cc
@@ -136,7 +136,7 @@ bool ScannerManager::UnregisterScanner(const string& scanner_id) {
size_t ScannerManager::CountActiveScanners() const {
size_t total = 0;
- BOOST_FOREACH(const ScannerMapStripe* e, scanner_maps_) {
+ for (const ScannerMapStripe* e : scanner_maps_) {
boost::shared_lock<boost::shared_mutex> l(e->lock_);
total += e->scanners_by_id_.size();
}
@@ -144,9 +144,9 @@ size_t ScannerManager::CountActiveScanners() const {
}
void ScannerManager::ListScanners(std::vector<SharedScanner>* scanners) {
- BOOST_FOREACH(const ScannerMapStripe* stripe, scanner_maps_) {
+ for (const ScannerMapStripe* stripe : scanner_maps_) {
boost::shared_lock<boost::shared_mutex> l(stripe->lock_);
- BOOST_FOREACH(const ScannerMapEntry& se, stripe->scanners_by_id_) {
+ for (const ScannerMapEntry& se : stripe->scanners_by_id_) {
scanners->push_back(se.second);
}
}
@@ -155,7 +155,7 @@ void ScannerManager::ListScanners(std::vector<SharedScanner>* scanners) {
void ScannerManager::RemoveExpiredScanners() {
MonoDelta scanner_ttl = MonoDelta::FromMilliseconds(FLAGS_scanner_ttl_ms);
- BOOST_FOREACH(ScannerMapStripe* stripe, scanner_maps_) {
+ for (ScannerMapStripe* stripe : scanner_maps_) {
boost::lock_guard<boost::shared_mutex> l(stripe->lock_);
for (ScannerMap::iterator it = stripe->scanners_by_id_.begin();
it != stripe->scanners_by_id_.end(); ) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tablet_server-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_server-stress-test.cc b/src/kudu/tserver/tablet_server-stress-test.cc
index 48e525d..d9c2931 100644
--- a/src/kudu/tserver/tablet_server-stress-test.cc
+++ b/src/kudu/tserver/tablet_server-stress-test.cc
@@ -66,7 +66,7 @@ class TSStressTest : public TabletServerTestBase {
}
void JoinThreads() {
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tablet_server-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_server-test-base.h b/src/kudu/tserver/tablet_server-test-base.h
index b3e3394..1a1e836 100644
--- a/src/kudu/tserver/tablet_server-test-base.h
+++ b/src/kudu/tserver/tablet_server-test-base.h
@@ -20,7 +20,6 @@
#include <algorithm>
#include <assert.h>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <iostream>
#include <memory>
@@ -326,7 +325,7 @@ class TabletServerTestBase : public KuduTest {
ASSERT_OK(ExtractRowsFromRowBlockPB(projection, *rrpb,
indirect, &direct, &rows));
VLOG(1) << "Round trip got " << rows.size() << " rows";
- BOOST_FOREACH(const uint8_t* row_ptr, rows) {
+ for (const uint8_t* row_ptr : rows) {
ConstContiguousRow row(&projection, row_ptr);
results->push_back(projection.DebugRow(row));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tablet_server-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_server-test.cc b/src/kudu/tserver/tablet_server-test.cc
index b582b63..16dfcc9 100644
--- a/src/kudu/tserver/tablet_server-test.cc
+++ b/src/kudu/tserver/tablet_server-test.cc
@@ -1001,7 +1001,7 @@ TEST_F(TabletServerTest, TestSnapshotScan) {
RpcController rpc;
int batch_idx = 1;
- BOOST_FOREACH(uint64_t write_timestamp, write_timestamps_collector) {
+ for (uint64_t write_timestamp : write_timestamps_collector) {
req.Clear();
resp.Clear();
rpc.Reset();
@@ -1041,7 +1041,7 @@ TEST_F(TabletServerTest, TestSnapshotScan) {
if (VLOG_IS_ON(2)) {
VLOG(2) << "Scanner: " << resp.scanner_id() << " performing a snapshot read at: "
<< read_timestamp.ToString() << " got back: ";
- BOOST_FOREACH(const string& result, results) {
+ for (const string& result : results) {
VLOG(2) << result;
}
}
@@ -2058,7 +2058,7 @@ TEST_F(TabletServerTest, TestWriteOutOfBounds) {
vector<RowOperationsPB::Type> ops = { RowOperationsPB::INSERT, RowOperationsPB::UPDATE };
- BOOST_FOREACH(const RowOperationsPB::Type &op, ops) {
+ for (const RowOperationsPB::Type &op : ops) {
RowOperationsPB* data = req.mutable_row_operations();
AddTestRowToPB(op, schema_, 20, 1, "1", data);
SCOPED_TRACE(req.DebugString());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tserver/tablet_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tserver/tablet_server.cc b/src/kudu/tserver/tablet_server.cc
index d30ed1d..14841e7 100644
--- a/src/kudu/tserver/tablet_server.cc
+++ b/src/kudu/tserver/tablet_server.cc
@@ -17,7 +17,6 @@
#include "kudu/tserver/tablet_server.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <list>
#include <vector>
@@ -68,7 +67,7 @@ string TabletServer::ToString() const {
}
Status TabletServer::ValidateMasterAddressResolution() const {
- BOOST_FOREACH(const HostPort& master_addr, opts_.master_addresses) {
+ for (const HostPort& master_addr : opts_.master_addresses) {
RETURN_NOT_OK_PREPEND(master_addr.ResolveAddresses(NULL),
strings::Substitute(
"Couldn't resolve master service address '$0'",
[3/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Posted by da...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/inbound_call.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/inbound_call.cc b/src/kudu/rpc/inbound_call.cc
index 2aa0087..da7f9b2 100644
--- a/src/kudu/rpc/inbound_call.cc
+++ b/src/kudu/rpc/inbound_call.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/inbound_call.h"
-#include <boost/foreach.hpp>
#include <memory>
#include "kudu/gutil/strings/substitute.h"
@@ -137,7 +136,7 @@ Status InboundCall::SerializeResponseBuffer(const MessageLite& response,
resp_hdr.set_call_id(header_.call_id());
resp_hdr.set_is_error(!is_success);
uint32_t absolute_sidecar_offset = protobuf_msg_size;
- BOOST_FOREACH(RpcSidecar* car, sidecars_) {
+ for (RpcSidecar* car : sidecars_) {
resp_hdr.add_sidecar_offsets(absolute_sidecar_offset);
absolute_sidecar_offset += car->AsSlice().size();
}
@@ -159,7 +158,7 @@ void InboundCall::SerializeResponseTo(vector<Slice>* slices) const {
slices->reserve(slices->size() + 2 + sidecars_.size());
slices->push_back(Slice(response_hdr_buf_));
slices->push_back(Slice(response_msg_buf_));
- BOOST_FOREACH(RpcSidecar* car, sidecars_) {
+ for (RpcSidecar* car : sidecars_) {
slices->push_back(car->AsSlice());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/messenger.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/messenger.cc b/src/kudu/rpc/messenger.cc
index dfb6860..ce869cc 100644
--- a/src/kudu/rpc/messenger.cc
+++ b/src/kudu/rpc/messenger.cc
@@ -22,7 +22,6 @@
#include <sys/types.h>
#include <unistd.h>
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <list>
@@ -142,7 +141,7 @@ void Messenger::Shutdown() {
DCHECK(rpc_services_.empty()) << "Unregister RPC services before shutting down Messenger";
rpc_services_.clear();
- BOOST_FOREACH(const shared_ptr<AcceptorPool>& acceptor_pool, acceptor_pools_) {
+ for (const shared_ptr<AcceptorPool>& acceptor_pool : acceptor_pools_) {
acceptor_pool->Shutdown();
}
acceptor_pools_.clear();
@@ -152,7 +151,7 @@ void Messenger::Shutdown() {
// threads' blocking reads & writes.
negotiation_pool_->Shutdown();
- BOOST_FOREACH(Reactor* reactor, reactors_) {
+ for (Reactor* reactor : reactors_) {
reactor->Shutdown();
}
}
@@ -258,7 +257,7 @@ Reactor* Messenger::RemoteToReactor(const Sockaddr &remote) {
Status Messenger::Init() {
Status status;
- BOOST_FOREACH(Reactor* r, reactors_) {
+ for (Reactor* r : reactors_) {
RETURN_NOT_OK(r->Init());
}
@@ -268,7 +267,7 @@ Status Messenger::Init() {
Status Messenger::DumpRunningRpcs(const DumpRunningRpcsRequestPB& req,
DumpRunningRpcsResponsePB* resp) {
shared_lock<rw_spinlock> guard(&lock_.get_lock());
- BOOST_FOREACH(Reactor* reactor, reactors_) {
+ for (Reactor* reactor : reactors_) {
RETURN_NOT_OK(reactor->DumpRunningRpcs(req, resp));
}
return Status::OK();
@@ -280,7 +279,7 @@ void Messenger::ScheduleOnReactor(const boost::function<void(const Status&)>& fu
// If we're already running on a reactor thread, reuse it.
Reactor* chosen = NULL;
- BOOST_FOREACH(Reactor* r, reactors_) {
+ for (Reactor* r : reactors_) {
if (r->IsCurrentThread()) {
chosen = r;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/mt-rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/mt-rpc-test.cc b/src/kudu/rpc/mt-rpc-test.cc
index f6d1977..c9ed7c8 100644
--- a/src/kudu/rpc/mt-rpc-test.cc
+++ b/src/kudu/rpc/mt-rpc-test.cc
@@ -281,7 +281,7 @@ TEST_F(MultiThreadedRpcTest, TestShutdownWithIncomingConnections) {
service_pool_->Shutdown();
server_messenger_->Shutdown();
- BOOST_FOREACH(scoped_refptr<kudu::Thread>& t, threads) {
+ for (scoped_refptr<kudu::Thread>& t : threads) {
ASSERT_OK(ThreadJoiner(t.get()).warn_every_ms(500).Join());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/protoc-gen-krpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/protoc-gen-krpc.cc b/src/kudu/rpc/protoc-gen-krpc.cc
index e7fbcc1..25f8ebe 100644
--- a/src/kudu/rpc/protoc-gen-krpc.cc
+++ b/src/kudu/rpc/protoc-gen-krpc.cc
@@ -20,7 +20,6 @@
// protoc --plugin=protoc-gen-krpc --krpc_out . --proto_path . <file>.proto
////////////////////////////////////////////////////////////////////////////////
-#include <boost/foreach.hpp>
#include <ctype.h>
#include <glog/logging.h>
#include <google/protobuf/compiler/code_generator.h>
@@ -104,7 +103,7 @@ class FileSubstitutions : public Substituter {
virtual void InitSubstitutionMap(map<string, string> *map) const OVERRIDE {
typedef std::map<string, string>::value_type kv_pair;
- BOOST_FOREACH(const kv_pair &pair, map_) {
+ for (const kv_pair &pair : map_) {
(*map)[pair.first] = pair.second;
}
}
@@ -140,7 +139,7 @@ class FileSubstitutions : public Substituter {
static string GenerateOpenNamespace(const string &str) {
vector<string> components = strings::Split(str, ".");
string out;
- BOOST_FOREACH(const string &c, components) {
+ for (const string &c : components) {
out.append("namespace ").append(c).append(" {\n");
}
return out;
@@ -149,8 +148,8 @@ class FileSubstitutions : public Substituter {
static string GenerateCloseNamespace(const string &str) {
vector<string> components = strings::Split(str, ".");
string out;
- BOOST_REVERSE_FOREACH(const string &c, components) {
- out.append("} // namespace ").append(c).append("\n");
+ for (auto c = components.crbegin(); c != components.crend(); c++) {
+ out.append("} // namespace ").append(*c).append("\n");
}
return out;
}
@@ -253,7 +252,7 @@ class SubstitutionContext {
}
void InitSubstitutionMap(map<string, string> *subs) const {
- BOOST_FOREACH(const shared_ptr<const Substituter> &sub, subs_) {
+ for (const shared_ptr<const Substituter> &sub : subs_) {
sub->InitSubstitutionMap(subs);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/reactor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/reactor.cc b/src/kudu/rpc/reactor.cc
index bcdb3e8..8eeb76f 100644
--- a/src/kudu/rpc/reactor.cc
+++ b/src/kudu/rpc/reactor.cc
@@ -19,7 +19,6 @@
#include <arpa/inet.h>
#include <boost/intrusive/list.hpp>
-#include <boost/foreach.hpp>
#include <ev++.h>
#include <netinet/in.h>
#include <stdlib.h>
@@ -124,7 +123,7 @@ void ReactorThread::ShutdownInternal() {
// Tear down any inbound TCP connections.
VLOG(1) << name() << ": tearing down inbound TCP connections...";
- BOOST_FOREACH(const scoped_refptr<Connection>& conn, server_conns_) {
+ for (const scoped_refptr<Connection>& conn : server_conns_) {
VLOG(1) << name() << ": shutting down " << conn->ToString();
conn->Shutdown(service_unavailable);
}
@@ -135,7 +134,7 @@ void ReactorThread::ShutdownInternal() {
// These won't be found in the ReactorThread's list of pending tasks
// because they've been "run" (that is, they've been scheduled).
Status aborted = ShutdownError(true); // aborted
- BOOST_FOREACH(DelayedTask* task, scheduled_tasks_) {
+ for (DelayedTask* task : scheduled_tasks_) {
task->Abort(aborted); // should also free the task.
}
scheduled_tasks_.clear();
@@ -156,10 +155,10 @@ Status ReactorThread::GetMetrics(ReactorMetrics *metrics) {
Status ReactorThread::DumpRunningRpcs(const DumpRunningRpcsRequestPB& req,
DumpRunningRpcsResponsePB* resp) {
DCHECK(IsCurrentThread());
- BOOST_FOREACH(const scoped_refptr<Connection>& conn, server_conns_) {
+ for (const scoped_refptr<Connection>& conn : server_conns_) {
RETURN_NOT_OK(conn->DumpPB(req, resp->add_inbound_connections()));
}
- BOOST_FOREACH(const conn_map_t::value_type& entry, client_conns_) {
+ for (const conn_map_t::value_type& entry : client_conns_) {
Connection* conn = entry.second.get();
RETURN_NOT_OK(conn->DumpPB(req, resp->add_outbound_connections()));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/rpc-bench.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-bench.cc b/src/kudu/rpc/rpc-bench.cc
index 63afb31..0fbd0a0 100644
--- a/src/kudu/rpc/rpc-bench.cc
+++ b/src/kudu/rpc/rpc-bench.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/thread/thread.hpp>
#include <gtest/gtest.h>
@@ -112,7 +111,7 @@ TEST_F(RpcBench, BenchmarkCalls) {
int total_reqs = 0;
- BOOST_FOREACH(ClientThread &thr, threads) {
+ for (ClientThread &thr : threads) {
thr.Join();
total_reqs += thr.request_count_;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc
index ab0f49a..ce811db 100644
--- a/src/kudu/rpc/rpc-test.cc
+++ b/src/kudu/rpc/rpc-test.cc
@@ -21,7 +21,6 @@
#include <string>
#include <unordered_map>
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <gtest/gtest.h>
@@ -374,7 +373,7 @@ TEST_F(TestRpc, TestServerShutsDown) {
ASSERT_OK(listen_sock.Accept(&server_sock, &remote, 0));
// The call is still in progress at this point.
- BOOST_FOREACH(const RpcController &controller, controllers) {
+ for (const RpcController &controller : controllers) {
ASSERT_FALSE(controller.finished());
}
@@ -386,7 +385,7 @@ TEST_F(TestRpc, TestServerShutsDown) {
latch.Wait();
// Should get the appropriate error on the client for all calls;
- BOOST_FOREACH(const RpcController &controller, controllers) {
+ for (const RpcController &controller : controllers) {
ASSERT_TRUE(controller.finished());
Status s = controller.status();
ASSERT_TRUE(s.IsNetworkError()) <<
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/rpc_stub-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc_stub-test.cc b/src/kudu/rpc/rpc_stub-test.cc
index e0fc5fc..b2df45b 100644
--- a/src/kudu/rpc/rpc_stub-test.cc
+++ b/src/kudu/rpc/rpc_stub-test.cc
@@ -19,7 +19,6 @@
#include <gtest/gtest.h>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include "kudu/gutil/stl_util.h"
@@ -115,7 +114,7 @@ TEST_F(RpcStubTest, TestBigCallData) {
latch.Wait();
- BOOST_FOREACH(RpcController &c, controllers) {
+ for (RpcController &c : controllers) {
ASSERT_OK(c.status());
}
}
@@ -339,7 +338,7 @@ TEST_F(RpcStubTest, TestDontHandleTimedOutCalls) {
Status s = p.Sleep(req, &resp, &rpc);
ASSERT_TRUE(s.IsTimedOut()) << s.ToString();
- BOOST_FOREACH(AsyncSleep* s, sleeps) {
+ for (AsyncSleep* s : sleeps) {
s->latch.Wait();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/sasl_client.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_client.cc b/src/kudu/rpc/sasl_client.cc
index f18eb08..0956356 100644
--- a/src/kudu/rpc/sasl_client.cc
+++ b/src/kudu/rpc/sasl_client.cc
@@ -23,7 +23,6 @@
#include <set>
#include <string>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <sasl/sasl.h>
@@ -306,7 +305,7 @@ Status SaslClient::HandleNegotiateResponse(const SaslMessagePB& response) {
string mech_list;
mech_list.reserve(64); // Avoid resizing the buffer later.
- BOOST_FOREACH(const SaslMessagePB::SaslAuth& auth, response.auths()) {
+ for (const SaslMessagePB::SaslAuth& auth : response.auths()) {
if (mech_list.length() > 0) mech_list.append(" ");
string mech = auth.mechanism();
mech_list.append(mech);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/sasl_helper.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_helper.cc b/src/kudu/rpc/sasl_helper.cc
index d3d2db9..7ea2b97 100644
--- a/src/kudu/rpc/sasl_helper.cc
+++ b/src/kudu/rpc/sasl_helper.cc
@@ -20,7 +20,6 @@
#include <set>
#include <string>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <google/protobuf/message_lite.h>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/sasl_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_server.cc b/src/kudu/rpc/sasl_server.cc
index 42e3b57..0ceaa58 100644
--- a/src/kudu/rpc/sasl_server.cc
+++ b/src/kudu/rpc/sasl_server.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/sasl_server.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <google/protobuf/message_lite.h>
#include <limits>
@@ -294,7 +293,7 @@ Status SaslServer::SendNegotiateResponse(const set<string>& server_mechs) {
SaslMessagePB response;
response.set_state(SaslMessagePB::NEGOTIATE);
- BOOST_FOREACH(const string& mech, server_mechs) {
+ for (const string& mech : server_mechs) {
SaslMessagePB::SaslAuth* auth = response.add_auths();
// The 'method' field is deprecated, but older versions of Kudu marked it 'required'.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/service_pool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/service_pool.cc b/src/kudu/rpc/service_pool.cc
index a1ba072..8a10b6f 100644
--- a/src/kudu/rpc/service_pool.cc
+++ b/src/kudu/rpc/service_pool.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/service_pool.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <memory>
#include <string>
@@ -90,7 +89,7 @@ void ServicePool::Shutdown() {
if (closing_) return;
closing_ = true;
// TODO: Use a proper thread pool implementation.
- BOOST_FOREACH(scoped_refptr<kudu::Thread>& thread, threads_) {
+ for (scoped_refptr<kudu::Thread>& thread : threads_) {
CHECK_OK(ThreadJoiner(thread.get()).Join());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/transfer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/transfer.cc b/src/kudu/rpc/transfer.cc
index 6273076..b1807ae 100644
--- a/src/kudu/rpc/transfer.cc
+++ b/src/kudu/rpc/transfer.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/transfer.h"
-#include <boost/foreach.hpp>
#include <stdint.h>
#include <iostream>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/default-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/default-path-handlers.cc b/src/kudu/server/default-path-handlers.cc
index 89fa8b2..15f7677 100644
--- a/src/kudu/server/default-path-handlers.cc
+++ b/src/kudu/server/default-path-handlers.cc
@@ -31,7 +31,6 @@
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <fstream>
#include <gperftools/malloc_extension.h>
#include <memory>
@@ -157,7 +156,7 @@ static void MemTrackersHandler(const Webserver::WebRequest& req, std::stringstre
vector<shared_ptr<MemTracker> > trackers;
MemTracker::ListTrackers(&trackers);
- BOOST_FOREACH(const shared_ptr<MemTracker>& tracker, trackers) {
+ for (const shared_ptr<MemTracker>& tracker : trackers) {
string parent = tracker->parent() == NULL ? "none" : tracker->parent()->id();
string limit_str = tracker->limit() == -1 ? "none" :
HumanReadableNumBytes::ToString(tracker->limit());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/hybrid_clock-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/hybrid_clock-test.cc b/src/kudu/server/hybrid_clock-test.cc
index dceae25..e8212df 100644
--- a/src/kudu/server/hybrid_clock-test.cc
+++ b/src/kudu/server/hybrid_clock-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -227,7 +226,7 @@ TEST_F(HybridClockTest, TestClockDoesntGoBackwardsWithUpdates) {
SleepFor(MonoDelta::FromSeconds(1));
stop.Store(true);
- BOOST_FOREACH(const scoped_refptr<Thread> t, threads) {
+ for (const scoped_refptr<Thread> t : threads) {
t->Join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/pprof-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/pprof-path-handlers.cc b/src/kudu/server/pprof-path-handlers.cc
index 9cdc1d5..6f6159b 100644
--- a/src/kudu/server/pprof-path-handlers.cc
+++ b/src/kudu/server/pprof-path-handlers.cc
@@ -30,7 +30,6 @@
#include "kudu/server/pprof-path-handlers.h"
#include <fstream>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gperftools/heap-profiler.h>
#include <gperftools/malloc_extension.h>
@@ -215,7 +214,7 @@ static void PprofSymbolHandler(const Webserver::WebRequest& req, stringstream* o
// Symbolization request.
vector<StringPiece> pieces = strings::Split(req.post_data, "+");
- BOOST_FOREACH(StringPiece p, pieces) {
+ for (StringPiece p : pieces) {
string hex_addr;
if (!TryStripPrefixString(p, "0x", &hex_addr)) {
invalid_addrs++;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/rpc_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpc_server.cc b/src/kudu/server/rpc_server.cc
index c95f532..d9772b8 100644
--- a/src/kudu/server/rpc_server.cc
+++ b/src/kudu/server/rpc_server.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <list>
#include <string>
#include <vector>
@@ -96,7 +95,7 @@ Status RpcServer::Init(const shared_ptr<Messenger>& messenger) {
RETURN_NOT_OK(ParseAddressList(options_.rpc_bind_addresses,
options_.default_port,
&rpc_bind_addresses_));
- BOOST_FOREACH(const Sockaddr& addr, rpc_bind_addresses_) {
+ for (const Sockaddr& addr : rpc_bind_addresses_) {
if (IsPrivilegedPort(addr.port())) {
LOG(WARNING) << "May be unable to bind to privileged port for address "
<< addr.ToString();
@@ -133,7 +132,7 @@ Status RpcServer::Bind() {
// Create the Acceptor pools (one per bind address)
vector<shared_ptr<AcceptorPool> > new_acceptor_pools;
// Create the AcceptorPool for each bind address.
- BOOST_FOREACH(const Sockaddr& bind_addr, rpc_bind_addresses_) {
+ for (const Sockaddr& bind_addr : rpc_bind_addresses_) {
shared_ptr<rpc::AcceptorPool> pool;
RETURN_NOT_OK(messenger_->AddAcceptorPool(
bind_addr,
@@ -153,14 +152,14 @@ Status RpcServer::Start() {
CHECK_EQ(server_state_, BOUND);
server_state_ = STARTED;
- BOOST_FOREACH(const shared_ptr<AcceptorPool>& pool, acceptor_pools_) {
+ for (const shared_ptr<AcceptorPool>& pool : acceptor_pools_) {
RETURN_NOT_OK(pool->Start(options_.num_acceptors_per_address));
}
vector<Sockaddr> bound_addrs;
RETURN_NOT_OK(GetBoundAddresses(&bound_addrs));
string bound_addrs_str;
- BOOST_FOREACH(const Sockaddr& bind_addr, bound_addrs) {
+ for (const Sockaddr& bind_addr : bound_addrs) {
if (!bound_addrs_str.empty()) bound_addrs_str += ", ";
bound_addrs_str += bind_addr.ToString();
}
@@ -170,7 +169,7 @@ Status RpcServer::Start() {
}
void RpcServer::Shutdown() {
- BOOST_FOREACH(const shared_ptr<AcceptorPool>& pool, acceptor_pools_) {
+ for (const shared_ptr<AcceptorPool>& pool : acceptor_pools_) {
pool->Shutdown();
}
acceptor_pools_.clear();
@@ -183,7 +182,7 @@ void RpcServer::Shutdown() {
Status RpcServer::GetBoundAddresses(vector<Sockaddr>* addresses) const {
CHECK(server_state_ == BOUND ||
server_state_ == STARTED) << "bad state: " << server_state_;
- BOOST_FOREACH(const shared_ptr<AcceptorPool>& pool, acceptor_pools_) {
+ for (const shared_ptr<AcceptorPool>& pool : acceptor_pools_) {
Sockaddr bound_addr;
RETURN_NOT_OK_PREPEND(pool->GetBoundAddress(&bound_addr),
"Unable to get bound address from AcceptorPool");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/server_base.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/server_base.cc b/src/kudu/server/server_base.cc
index 4ad42ed..85303c1 100644
--- a/src/kudu/server/server_base.cc
+++ b/src/kudu/server/server_base.cc
@@ -16,7 +16,6 @@
// under the License.
#include "kudu/server/server_base.h"
-#include <boost/foreach.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <gflags/gflags.h>
#include <string>
@@ -195,7 +194,7 @@ void ServerBase::GetStatusPB(ServerStatusPB* status) const {
{
vector<Sockaddr> addrs;
CHECK_OK(rpc_server_->GetBoundAddresses(&addrs));
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
HostPortPB* pb = status->add_bound_rpc_addresses();
pb->set_host(addr.host());
pb->set_port(addr.port());
@@ -206,7 +205,7 @@ void ServerBase::GetStatusPB(ServerStatusPB* status) const {
{
vector<Sockaddr> addrs;
CHECK_OK(web_server_->GetBoundAddresses(&addrs));
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
HostPortPB* pb = status->add_bound_http_addresses();
pb->set_host(addr.host());
pb->set_port(addr.port());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/tracing-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/tracing-path-handlers.cc b/src/kudu/server/tracing-path-handlers.cc
index bfc593a..6b0205b 100644
--- a/src/kudu/server/tracing-path-handlers.cc
+++ b/src/kudu/server/tracing-path-handlers.cc
@@ -22,7 +22,6 @@
#include <vector>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <rapidjson/document.h>
#include <rapidjson/prettywriter.h>
#include <rapidjson/rapidjson.h>
@@ -141,7 +140,7 @@ void GetCategories(stringstream* out) {
kudu::debug::TraceLog::GetInstance()->GetKnownCategoryGroups(&groups);
JsonWriter j(out, JsonWriter::COMPACT);
j.StartArray();
- BOOST_FOREACH(const string& g, groups) {
+ for (const string& g : groups) {
j.String(g);
}
j.EndArray();
@@ -255,7 +254,7 @@ void TracingPathHandlers::RegisterHandlers(Webserver* server) {
{ "/tracing/json/simple_dump", kSimpleDump } };
typedef pair<string, Handler> HandlerPair;
- BOOST_FOREACH(const HandlerPair& e, handlers) {
+ for (const HandlerPair& e : handlers) {
server->RegisterPathHandler(
e.first, "",
boost::bind(&HandleRequest, e.second, _1, _2),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/webserver.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/webserver.cc b/src/kudu/server/webserver.cc
index 01b35de..d19a889 100644
--- a/src/kudu/server/webserver.cc
+++ b/src/kudu/server/webserver.cc
@@ -36,7 +36,6 @@
#include <map>
#include <vector>
#include <boost/lexical_cast.hpp>
-#include <boost/foreach.hpp>
#include <boost/bind.hpp>
#include <boost/mem_fn.hpp>
#include <boost/algorithm/string.hpp>
@@ -88,7 +87,7 @@ Webserver::~Webserver() {
void Webserver::RootHandler(const Webserver::WebRequest& args, stringstream* output) {
(*output) << "<h2>Status Pages</h2>";
- BOOST_FOREACH(const PathHandlerMap::value_type& handler, path_handlers_) {
+ for (const PathHandlerMap::value_type& handler : path_handlers_) {
if (handler.second->is_on_nav_bar()) {
(*output) << "<a href=\"" << handler.first << "\">" << handler.second->alias() << "</a><br/>";
}
@@ -101,7 +100,7 @@ void Webserver::RootHandler(const Webserver::WebRequest& args, stringstream* out
void Webserver::BuildArgumentMap(const string& args, ArgumentMap* output) {
vector<StringPiece> arg_pairs = strings::Split(args, "&");
- BOOST_FOREACH(const StringPiece& arg_pair, arg_pairs) {
+ for (const StringPiece& arg_pair : arg_pairs) {
vector<StringPiece> key_value = strings::Split(arg_pair, "=");
if (key_value.empty()) continue;
@@ -123,7 +122,7 @@ Status Webserver::BuildListenSpec(string* spec) const {
RETURN_NOT_OK(ParseAddressList(http_address_, 80, &addrs));
vector<string> parts;
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
// Mongoose makes sockets with 's' suffixes accept SSL traffic only
parts.push_back(addr.ToString() + (IsSecure() ? "s" : ""));
}
@@ -220,7 +219,7 @@ Status Webserver::Start() {
vector<Sockaddr> addrs;
RETURN_NOT_OK(GetBoundAddresses(&addrs));
string bound_addresses_str;
- BOOST_FOREACH(const Sockaddr& addr, addrs) {
+ for (const Sockaddr& addr : addrs) {
if (!bound_addresses_str.empty()) {
bound_addresses_str += ", ";
}
@@ -353,7 +352,7 @@ int Webserver::RunPathHandler(const PathHandler& handler,
stringstream output;
if (use_style) BootstrapPageHeader(&output);
- BOOST_FOREACH(const PathHandlerCallback& callback_, handler.callbacks()) {
+ for (const PathHandlerCallback& callback_ : handler.callbacks()) {
callback_(req, &output);
}
if (use_style) BootstrapPageFooter(&output);
@@ -417,7 +416,7 @@ static const char* const NAVIGATION_BAR_SUFFIX =
void Webserver::BootstrapPageHeader(stringstream* output) {
(*output) << PAGE_HEADER;
(*output) << NAVIGATION_BAR_PREFIX;
- BOOST_FOREACH(const PathHandlerMap::value_type& handler, path_handlers_) {
+ for (const PathHandlerMap::value_type& handler : path_handlers_) {
if (handler.second->is_on_nav_bar()) {
(*output) << "<li><a href=\"" << handler.first << "\">" << handler.second->alias()
<< "</a></li>";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/server/webui_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/webui_util.cc b/src/kudu/server/webui_util.cc
index 28f03ed..c7a8135 100644
--- a/src/kudu/server/webui_util.cc
+++ b/src/kudu/server/webui_util.cc
@@ -135,7 +135,7 @@ void HtmlOutputTaskList(const std::vector<scoped_refptr<MonitoredTask> >& tasks,
std::stringstream* output) {
*output << "<table class='table table-striped'>\n";
*output << " <tr><th>Task Name</th><th>State</th><th>Time</th><th>Description</th></tr>\n";
- BOOST_FOREACH(const scoped_refptr<MonitoredTask>& task, tasks) {
+ for (const scoped_refptr<MonitoredTask>& task : tasks) {
string state;
switch (task->state()) {
case MonitoredTask::kStatePreparing:
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/cbtree-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cbtree-test.cc b/src/kudu/tablet/cbtree-test.cc
index 1ef3ac3..d9402cd 100644
--- a/src/kudu/tablet/cbtree-test.cc
+++ b/src/kudu/tablet/cbtree-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/barrier.hpp>
@@ -316,7 +315,7 @@ TEST_F(TestCBTree, TestInsertAndVerifyRandom) {
InsertRandomKeys(&t, n_keys, &inserted);
- BOOST_FOREACH(int key, inserted) {
+ for (int key : inserted) {
memcpy(kbuf, &key, sizeof(key));
// Do a Get() and check that the real value is still accessible.
@@ -386,7 +385,7 @@ TEST_F(TestCBTree, TestVersionLockConcurrent) {
LockCycleThread, &v, split_per_thread, insert_per_thread));
}
- BOOST_FOREACH(boost::thread &thr, threads) {
+ for (boost::thread &thr : threads) {
thr.join();
}
@@ -447,7 +446,7 @@ TEST_F(TestCBTree, TestConcurrentInsert) {
tree.reset(NULL);
go_barrier.wait();
- BOOST_FOREACH(boost::thread &thr, threads) {
+ for (boost::thread &thr : threads) {
thr.join();
}
}
@@ -714,7 +713,7 @@ TEST_F(TestCBTree, TestConcurrentIterateAndInsert) {
tree.reset(NULL);
go_barrier.wait();
- BOOST_FOREACH(boost::thread &thr, threads) {
+ for (boost::thread &thr : threads) {
thr.join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/cfile_set-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cfile_set-test.cc b/src/kudu/tablet/cfile_set-test.cc
index cdda87b..52df47d 100644
--- a/src/kudu/tablet/cfile_set-test.cc
+++ b/src/kudu/tablet/cfile_set-test.cc
@@ -219,7 +219,7 @@ TEST_F(TestCFileSet, TestIteratePartialSchema) {
ASSERT_OK(IterateToStringList(iter.get(), &results));
VLOG(1) << "Results of iterating over sparse partial schema: ";
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
VLOG(1) << str;
}
@@ -268,7 +268,7 @@ TEST_F(TestCFileSet, TestRangeScan) {
ASSERT_OK(IterateToStringList(iter.get(), &results));
// Ensure that we got the expected rows.
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
LOG(INFO) << str;
}
ASSERT_EQ(5, results.size());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/cfile_set.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cfile_set.cc b/src/kudu/tablet/cfile_set.cc
index 789077e..121dd70 100644
--- a/src/kudu/tablet/cfile_set.cc
+++ b/src/kudu/tablet/cfile_set.cc
@@ -78,7 +78,7 @@ Status CFileSet::Open() {
// Lazily open the column data cfiles. Each one will be fully opened
// later, when the first iterator seeks for the first time.
RowSetMetadata::ColumnIdToBlockIdMap block_map = rowset_metadata_->GetColumnBlocksById();
- BOOST_FOREACH(const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e, block_map) {
+ for (const RowSetMetadata::ColumnIdToBlockIdMap::value_type& e : block_map) {
ColumnId col_id = e.first;
DCHECK(!ContainsKey(readers_by_col_id_, col_id)) << "already open";
@@ -188,7 +188,7 @@ Status CFileSet::GetBounds(Slice *min_encoded_key,
uint64_t CFileSet::EstimateOnDiskSize() const {
uint64_t ret = 0;
- BOOST_FOREACH(const ReaderMap::value_type& e, readers_by_col_id_) {
+ for (const ReaderMap::value_type& e : readers_by_col_id_) {
const shared_ptr<CFileReader> &reader = e.second;
ret += reader->file_size();
}
@@ -475,7 +475,7 @@ Status CFileSet::Iterator::FinishBatch() {
void CFileSet::Iterator::GetIteratorStats(vector<IteratorStats>* stats) const {
stats->clear();
stats->reserve(col_iters_.size());
- BOOST_FOREACH(const ColumnIterator* iter, col_iters_) {
+ for (const ColumnIterator* iter : col_iters_) {
stats->push_back(iter->io_statistics());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction-test.cc b/src/kudu/tablet/compaction-test.cc
index a3446b8..384c798 100644
--- a/src/kudu/tablet/compaction-test.cc
+++ b/src/kudu/tablet/compaction-test.cc
@@ -214,12 +214,12 @@ class TestCompaction : public KuduRowSetTest {
vector<shared_ptr<RowSetMetadata> > metas;
rsw.GetWrittenRowSetMetadata(&metas);
ASSERT_GE(metas.size(), 1);
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, metas) {
+ for (const shared_ptr<RowSetMetadata>& meta : metas) {
ASSERT_TRUE(meta->HasBloomDataBlockForTests());
}
if (result_rowsets) {
// Re-open the outputs
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, metas) {
+ for (const shared_ptr<RowSetMetadata>& meta : metas) {
shared_ptr<DiskRowSet> rs;
ASSERT_OK(DiskRowSet::Open(meta, log_anchor_registry_.get(), &rs));
result_rowsets->push_back(rs);
@@ -232,7 +232,7 @@ class TestCompaction : public KuduRowSetTest {
const Schema& projection,
gscoped_ptr<CompactionInput>* out) {
vector<shared_ptr<CompactionInput> > merge_inputs;
- BOOST_FOREACH(const shared_ptr<DiskRowSet> &rs, rowsets) {
+ for (const shared_ptr<DiskRowSet> &rs : rowsets) {
gscoped_ptr<CompactionInput> input;
RETURN_NOT_OK(CompactionInput::Create(*rs, &projection, merge_snap, &input));
merge_inputs.push_back(shared_ptr<CompactionInput>(input.release()));
@@ -294,7 +294,7 @@ class TestCompaction : public KuduRowSetTest {
// Create one input rowset for each of the input schemas
int delta = 0;
- BOOST_FOREACH(const Schema& schema, schemas) {
+ for (const Schema& schema : schemas) {
// Create a memrowset with a bunch of rows and updates.
shared_ptr<MemRowSet> mrs(new MemRowSet(delta, schema, log_anchor_registry_.get()));
InsertRows(mrs.get(), 1000, delta);
@@ -359,7 +359,7 @@ class TestCompaction : public KuduRowSetTest {
scoped_refptr<TabletMetadata> input_meta;
ASSERT_OK(TabletMetadata::Load(&fs_manager, tablet_id, &input_meta));
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, input_meta->rowsets()) {
+ for (const shared_ptr<RowSetMetadata>& meta : input_meta->rowsets()) {
shared_ptr<DiskRowSet> rs;
CHECK_OK(DiskRowSet::Open(meta, log_anchor_registry_.get(), &rs));
rowsets.push_back(rs);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction.cc b/src/kudu/tablet/compaction.cc
index 52b2be2..c452f8a 100644
--- a/src/kudu/tablet/compaction.cc
+++ b/src/kudu/tablet/compaction.cc
@@ -268,7 +268,7 @@ class MergeCompactionInput : public CompactionInput {
MergeCompactionInput(const vector<shared_ptr<CompactionInput> > &inputs,
const Schema* schema)
: schema_(schema) {
- BOOST_FOREACH(const shared_ptr<CompactionInput> &input, inputs) {
+ for (const shared_ptr<CompactionInput> &input : inputs) {
gscoped_ptr<MergeState> state(new MergeState);
state->input = input;
states_.push_back(state.release());
@@ -280,7 +280,7 @@ class MergeCompactionInput : public CompactionInput {
}
virtual Status Init() OVERRIDE {
- BOOST_FOREACH(MergeState *state, states_) {
+ for (MergeState *state : states_) {
RETURN_NOT_OK(state->input->Init());
}
@@ -292,7 +292,7 @@ class MergeCompactionInput : public CompactionInput {
virtual bool HasMoreBlocks() OVERRIDE {
// Return true if any of the input blocks has more rows pending
// or more blocks which have yet to be pulled.
- BOOST_FOREACH(MergeState *state, states_) {
+ for (MergeState *state : states_) {
if (!state->empty() ||
state->input->HasMoreBlocks()) {
return true;
@@ -573,7 +573,7 @@ Status RowSetsInCompaction::CreateCompactionInput(const MvccSnapshot &snap,
CHECK(schema->has_column_ids());
vector<shared_ptr<CompactionInput> > inputs;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, rowsets_) {
+ for (const shared_ptr<RowSet> &rs : rowsets_) {
gscoped_ptr<CompactionInput> input;
RETURN_NOT_OK_PREPEND(rs->NewCompactionInput(schema, snap, &input),
Substitute("Could not create compaction input for rowset $0",
@@ -593,7 +593,7 @@ Status RowSetsInCompaction::CreateCompactionInput(const MvccSnapshot &snap,
void RowSetsInCompaction::DumpToLog() const {
LOG(INFO) << "Selected " << rowsets_.size() << " rowsets to compact:";
// Dump the selected rowsets to the log, and collect corresponding iterators.
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, rowsets_) {
+ for (const shared_ptr<RowSet> &rs : rowsets_) {
LOG(INFO) << rs->ToString() << "(current size on disk: ~"
<< rs->EstimateOnDiskSize() << " bytes)";
}
@@ -760,7 +760,7 @@ Status FlushCompactionInput(CompactionInput* input,
RETURN_NOT_OK(input->PrepareBlock(&rows));
int n = 0;
- BOOST_FOREACH(const CompactionInputRow &input_row, rows) {
+ for (const CompactionInputRow &input_row : rows) {
RETURN_NOT_OK(out->RollIfNecessary());
const Schema* schema = input_row.row.schema();
@@ -853,7 +853,7 @@ Status ReupdateMissedDeltas(const string &tablet_name,
// Collect the delta trackers that we'll push the updates into.
deque<DeltaTracker *> delta_trackers;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, output_rowsets) {
+ for (const shared_ptr<RowSet> &rs : output_rowsets) {
delta_trackers.push_back(down_cast<DiskRowSet *>(rs.get())->delta_tracker());
}
@@ -883,7 +883,7 @@ Status ReupdateMissedDeltas(const string &tablet_name,
while (input->HasMoreBlocks()) {
RETURN_NOT_OK(input->PrepareBlock(&rows));
- BOOST_FOREACH(const CompactionInputRow &row, rows) {
+ for (const CompactionInputRow &row : rows) {
DVLOG(2) << "Revisiting row: " << schema->DebugRow(row.row) <<
" Redo Mutations: " << Mutation::StringifyMutationList(*schema, row.redo_head) <<
" Undo Mutations: " << Mutation::StringifyMutationList(*schema, row.undo_head);
@@ -989,7 +989,7 @@ Status ReupdateMissedDeltas(const string &tablet_name,
{
TRACE_EVENT0("tablet", "Flushing missed deltas");
- BOOST_FOREACH(DeltaTracker* tracker, updated_trackers) {
+ for (DeltaTracker* tracker : updated_trackers) {
VLOG(1) << "Flushing DeltaTracker updated with missed deltas...";
RETURN_NOT_OK_PREPEND(tracker->Flush(DeltaTracker::NO_FLUSH_METADATA),
"Could not flush delta tracker after missed delta update");
@@ -1007,7 +1007,7 @@ Status DebugDumpCompactionInput(CompactionInput *input, vector<string> *lines) {
while (input->HasMoreBlocks()) {
RETURN_NOT_OK(input->PrepareBlock(&rows));
- BOOST_FOREACH(const CompactionInputRow &input_row, rows) {
+ for (const CompactionInputRow &input_row : rows) {
const Schema* schema = input_row.row.schema();
LOG_STRING(INFO, lines) << schema->DebugRow(input_row.row) <<
" Undos: " + Mutation::StringifyMutationList(*schema, input_row.undo_head) <<
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/compaction_policy.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction_policy.cc b/src/kudu/tablet/compaction_policy.cc
index 436cb73..1809e47 100644
--- a/src/kudu/tablet/compaction_policy.cc
+++ b/src/kudu/tablet/compaction_policy.cc
@@ -17,7 +17,6 @@
#include "kudu/tablet/compaction_policy.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <algorithm>
@@ -229,7 +228,7 @@ Status BudgetedCompactionPolicy::PickRowSets(const RowSetTree &tree,
inrange_candidates.reserve(asc_min_key.size());
vector<double> upper_bounds;
- BOOST_FOREACH(const RowSetInfo& cc_a, asc_min_key) {
+ for (const RowSetInfo& cc_a : asc_min_key) {
chosen_indexes.clear();
inrange_candidates.clear();
ub_calc.clear();
@@ -260,7 +259,7 @@ Status BudgetedCompactionPolicy::PickRowSets(const RowSetTree &tree,
// problem by adding just a single rowset, meaning that we can reuse the
// existing dynamic programming state to incrementally update the solution,
// rather than having to rebuild from scratch.
- BOOST_FOREACH(const RowSetInfo& cc_b, asc_max_key) {
+ for (const RowSetInfo& cc_b : asc_max_key) {
if (cc_b.cdf_min_key() < ab_min) {
// Would expand support to the left.
// TODO: possible optimization here: binary search to skip to the first
@@ -312,7 +311,7 @@ Status BudgetedCompactionPolicy::PickRowSets(const RowSetTree &tree,
// If we came up with a new solution, replace.
if (!chosen_indexes.empty()) {
best_chosen.clear();
- BOOST_FOREACH(int i, chosen_indexes) {
+ for (int i : chosen_indexes) {
best_chosen.insert(inrange_candidates[i].rowset());
}
}
@@ -321,7 +320,7 @@ Status BudgetedCompactionPolicy::PickRowSets(const RowSetTree &tree,
// Log the input and output of the selection.
if (VLOG_IS_ON(1) || log != NULL) {
LOG_STRING(INFO, log) << "Budgeted compaction selection:";
- BOOST_FOREACH(RowSetInfo &cand, asc_min_key) {
+ for (RowSetInfo &cand : asc_min_key) {
const char *checkbox = "[ ]";
if (ContainsKey(best_chosen, cand.rowset())) {
checkbox = "[x]";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/composite-pushdown-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/composite-pushdown-test.cc b/src/kudu/tablet/composite-pushdown-test.cc
index 8502cd2..4add5dd 100644
--- a/src/kudu/tablet/composite-pushdown-test.cc
+++ b/src/kudu/tablet/composite-pushdown-test.cc
@@ -100,7 +100,7 @@ class CompositePushdownTest : public KuduTabletTest {
ASSERT_OK(IterateToStringList(iter.get(), results));
}
std::sort(results->begin(), results->end(), SuffixComparator());
- BOOST_FOREACH(const string &str, *results) {
+ for (const string &str : *results) {
VLOG(1) << str;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction-test.cc b/src/kudu/tablet/delta_compaction-test.cc
index 3900692..6d67d3e 100644
--- a/src/kudu/tablet/delta_compaction-test.cc
+++ b/src/kudu/tablet/delta_compaction-test.cc
@@ -117,7 +117,7 @@ TEST_F(TestDeltaCompaction, TestMergeMultipleSchemas) {
int row_id = 0;
int curr_timestamp = 0;
int deltafile_idx = 0;
- BOOST_FOREACH(const Schema& schema, schemas) {
+ for (const Schema& schema : schemas) {
// Write the Deltas
BlockId block_id;
gscoped_ptr<DeltaFileWriter> dfw;
@@ -202,7 +202,7 @@ TEST_F(TestDeltaCompaction, TestMergeMultipleSchemas) {
vector<string> results;
ASSERT_OK(DebugDumpDeltaIterator(REDO, scoped_iter.get(), merge_schema,
ITERATE_OVER_ALL_ROWS, &results));
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
VLOG(1) << str;
}
ASSERT_TRUE(is_sorted(results.begin(), results.end()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction.cc b/src/kudu/tablet/delta_compaction.cc
index 9093248..d2ae28e 100644
--- a/src/kudu/tablet/delta_compaction.cc
+++ b/src/kudu/tablet/delta_compaction.cc
@@ -79,7 +79,7 @@ MajorDeltaCompaction::~MajorDeltaCompaction() {
string MajorDeltaCompaction::ColumnNamesToString() const {
std::string result;
- BOOST_FOREACH(ColumnId col_id, column_ids_) {
+ for (ColumnId col_id : column_ids_) {
int col_idx = base_schema_.find_column_by_id(col_id);
if (col_idx != Schema::kColumnNotFound) {
result += base_schema_.column_by_id(col_id).ToString() + " ";
@@ -187,7 +187,7 @@ Status MajorDeltaCompaction::FlushRowSetAndDeltas() {
}
// 6) Write the deltas we're not compacting back into a delta file.
- BOOST_FOREACH(const DeltaKeyAndUpdate& key_and_update, out) {
+ for (const DeltaKeyAndUpdate& key_and_update : out) {
RowChangeList update(key_and_update.cell);
RETURN_NOT_OK_PREPEND(new_redo_delta_writer_->AppendDelta<REDO>(key_and_update.key, update),
"Failed to append a delta");
@@ -255,7 +255,7 @@ Status MajorDeltaCompaction::Compact() {
LOG(INFO) << "Starting major delta compaction for columns " << ColumnNamesToString();
RETURN_NOT_OK(base_schema_.CreateProjectionByIdsIgnoreMissing(column_ids_, &partial_schema_));
- BOOST_FOREACH(const shared_ptr<DeltaStore>& ds, included_stores_) {
+ for (const shared_ptr<DeltaStore>& ds : included_stores_) {
LOG(INFO) << "Preparing to major compact delta file: " << ds->ToString();
}
@@ -273,7 +273,7 @@ Status MajorDeltaCompaction::CreateMetadataUpdate(
CHECK_EQ(state_, kFinished);
vector<BlockId> compacted_delta_blocks;
- BOOST_FOREACH(const shared_ptr<DeltaStore>& store, included_stores_) {
+ for (const shared_ptr<DeltaStore>& store : included_stores_) {
DeltaFileReader* dfr = down_cast<DeltaFileReader*>(store.get());
compacted_delta_blocks.push_back(dfr->block_id());
}
@@ -299,7 +299,7 @@ Status MajorDeltaCompaction::CreateMetadataUpdate(
// For those deleted columns, we just remove the old column data.
CHECK_LE(new_column_blocks.size(), column_ids_.size());
- BOOST_FOREACH(ColumnId col_id, column_ids_) {
+ for (ColumnId col_id : column_ids_) {
BlockId new_block;
if (FindCopy(new_column_blocks, col_id, &new_block)) {
update->ReplaceColumnId(col_id, new_block);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_iterator_merger.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_iterator_merger.cc b/src/kudu/tablet/delta_iterator_merger.cc
index 5e0f08c..90a2381 100644
--- a/src/kudu/tablet/delta_iterator_merger.cc
+++ b/src/kudu/tablet/delta_iterator_merger.cc
@@ -37,42 +37,42 @@ DeltaIteratorMerger::DeltaIteratorMerger(const vector<shared_ptr<DeltaIterator>
}
Status DeltaIteratorMerger::Init(ScanSpec *spec) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->Init(spec));
}
return Status::OK();
}
Status DeltaIteratorMerger::SeekToOrdinal(rowid_t idx) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->SeekToOrdinal(idx));
}
return Status::OK();
}
Status DeltaIteratorMerger::PrepareBatch(size_t nrows, PrepareFlag flag) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->PrepareBatch(nrows, flag));
}
return Status::OK();
}
Status DeltaIteratorMerger::ApplyUpdates(size_t col_to_apply, ColumnBlock *dst) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->ApplyUpdates(col_to_apply, dst));
}
return Status::OK();
}
Status DeltaIteratorMerger::ApplyDeletes(SelectionVector *sel_vec) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->ApplyDeletes(sel_vec));
}
return Status::OK();
}
Status DeltaIteratorMerger::CollectMutations(vector<Mutation *> *dst, Arena *arena) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
RETURN_NOT_OK(iter->CollectMutations(dst, arena));
}
// TODO: do we need to do some kind of sorting here to deal with out-of-order
@@ -90,7 +90,7 @@ Status DeltaIteratorMerger::FilterColumnIdsAndCollectDeltas(
const vector<ColumnId>& col_ids,
vector<DeltaKeyAndUpdate>* out,
Arena* arena) {
- BOOST_FOREACH(const shared_ptr<DeltaIterator>& iter, iters_) {
+ for (const shared_ptr<DeltaIterator>& iter : iters_) {
RETURN_NOT_OK(iter->FilterColumnIdsAndCollectDeltas(col_ids, out, arena));
}
// We use a stable sort here since an input may include multiple deltas for the
@@ -101,7 +101,7 @@ Status DeltaIteratorMerger::FilterColumnIdsAndCollectDeltas(
}
bool DeltaIteratorMerger::HasNext() {
- BOOST_FOREACH(const shared_ptr<DeltaIterator>& iter, iters_) {
+ for (const shared_ptr<DeltaIterator>& iter : iters_) {
if (iter->HasNext()) {
return true;
}
@@ -115,7 +115,7 @@ string DeltaIteratorMerger::ToString() const {
ret.append("DeltaIteratorMerger(");
bool first = true;
- BOOST_FOREACH(const shared_ptr<DeltaIterator> &iter, iters_) {
+ for (const shared_ptr<DeltaIterator> &iter : iters_) {
if (!first) {
ret.append(", ");
}
@@ -135,7 +135,7 @@ Status DeltaIteratorMerger::Create(
shared_ptr<DeltaIterator>* out) {
vector<shared_ptr<DeltaIterator> > delta_iters;
- BOOST_FOREACH(const shared_ptr<DeltaStore> &store, stores) {
+ for (const shared_ptr<DeltaStore> &store : stores) {
DeltaIterator* raw_iter;
Status s = store->NewDeltaIterator(projection, snapshot, &raw_iter);
if (s.IsNotFound()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_stats.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_stats.cc b/src/kudu/tablet/delta_stats.cc
index f14e3ef..4594ca6 100644
--- a/src/kudu/tablet/delta_stats.cc
+++ b/src/kudu/tablet/delta_stats.cc
@@ -56,7 +56,7 @@ Status DeltaStats::UpdateStats(const Timestamp& timestamp,
} else if (PREDICT_TRUE(update_decoder.is_update())) {
vector<ColumnId> col_ids;
RETURN_NOT_OK(update_decoder.GetIncludedColumnIds(&col_ids));
- BOOST_FOREACH(ColumnId col_id, col_ids) {
+ for (ColumnId col_id : col_ids) {
IncrUpdateCount(col_id, 1);
}
} // Don't handle re-inserts
@@ -89,7 +89,7 @@ void DeltaStats::ToPB(DeltaStatsPB* pb) const {
pb->Clear();
pb->set_delete_count(delete_count_);
typedef std::pair<ColumnId, int64_t> entry;
- BOOST_FOREACH(const entry& e, update_counts_by_col_id_) {
+ for (const entry& e : update_counts_by_col_id_) {
DeltaStatsPB::ColumnStats* stats = pb->add_column_stats();
stats->set_col_id(e.first);
stats->set_update_count(e.second);
@@ -102,7 +102,7 @@ void DeltaStats::ToPB(DeltaStatsPB* pb) const {
Status DeltaStats::InitFromPB(const DeltaStatsPB& pb) {
delete_count_ = pb.delete_count();
update_counts_by_col_id_.clear();
- BOOST_FOREACH(const DeltaStatsPB::ColumnStats stats, pb.column_stats()) {
+ for (const DeltaStatsPB::ColumnStats stats : pb.column_stats()) {
IncrUpdateCount(ColumnId(stats.col_id()), stats.update_count());
}
RETURN_NOT_OK(max_timestamp_.FromUint64(pb.max_timestamp()));
@@ -112,7 +112,7 @@ Status DeltaStats::InitFromPB(const DeltaStatsPB& pb) {
void DeltaStats::AddColumnIdsWithUpdates(std::set<ColumnId>* col_ids) const {
typedef std::pair<ColumnId, int64_t> entry;
- BOOST_FOREACH(const entry& e, update_counts_by_col_id_) {
+ for (const entry& e : update_counts_by_col_id_) {
if (e.second > 0) {
col_ids->insert(e.first);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_store.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_store.cc b/src/kudu/tablet/delta_store.cc
index 057579f..029015c 100644
--- a/src/kudu/tablet/delta_store.cc
+++ b/src/kudu/tablet/delta_store.cc
@@ -71,7 +71,7 @@ Status DebugDumpDeltaIterator(DeltaType type,
vector<ColumnId>(),
&cells,
&arena));
- BOOST_FOREACH(const DeltaKeyAndUpdate& cell, cells) {
+ for (const DeltaKeyAndUpdate& cell : cells) {
LOG_STRING(INFO, out) << cell.Stringify(type, schema);
}
@@ -110,7 +110,7 @@ Status WriteDeltaIteratorToFile(DeltaIterator* iter,
RETURN_NOT_OK(iter->FilterColumnIdsAndCollectDeltas(vector<ColumnId>(),
&cells,
&arena));
- BOOST_FOREACH(const DeltaKeyAndUpdate& cell, cells) {
+ for (const DeltaKeyAndUpdate& cell : cells) {
RowChangeList rcl(cell.cell);
RETURN_NOT_OK(out->AppendDelta<Type>(cell.key, rcl));
RETURN_NOT_OK(stats.UpdateStats(cell.key.timestamp(), rcl));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/delta_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_tracker.cc b/src/kudu/tablet/delta_tracker.cc
index 9d64c9b..6d2dddc 100644
--- a/src/kudu/tablet/delta_tracker.cc
+++ b/src/kudu/tablet/delta_tracker.cc
@@ -15,8 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
-
#include "kudu/gutil/strings/join.h"
#include "kudu/gutil/strings/strip.h"
#include "kudu/gutil/strings/substitute.h"
@@ -53,7 +51,7 @@ Status DeltaTracker::OpenDeltaReaders(const vector<BlockId>& blocks,
vector<shared_ptr<DeltaStore> >* stores,
DeltaType type) {
FsManager* fs = rowset_metadata_->fs_manager();
- BOOST_FOREACH(const BlockId& block_id, blocks) {
+ for (const BlockId& block_id : blocks) {
gscoped_ptr<ReadableBlock> block;
Status s = fs->OpenBlock(block_id, &block);
if (!s.ok()) {
@@ -135,7 +133,7 @@ namespace {
string JoinDeltaStoreStrings(const SharedDeltaStoreVector& stores) {
vector<string> strings;
- BOOST_FOREACH(const shared_ptr<DeltaStore>& store, stores) {
+ for (const shared_ptr<DeltaStore>& store : stores) {
strings.push_back(store->ToString());
}
return ::JoinStrings(strings, ",");
@@ -162,7 +160,7 @@ Status DeltaTracker::AtomicUpdateStores(const SharedDeltaStoreVector& to_remove,
std::find(stores_to_update->begin(), stores_to_update->end(), to_remove[0]);
SharedDeltaStoreVector::iterator end_it = start_it;
- BOOST_FOREACH(const shared_ptr<DeltaStore>& ds, to_remove) {
+ for (const shared_ptr<DeltaStore>& ds : to_remove) {
if (end_it == stores_to_update->end() || *end_it != ds) {
return Status::InvalidArgument(
strings::Substitute("Cannot find deltastore sequence <$0> in <$1>",
@@ -279,7 +277,7 @@ Status DeltaTracker::CheckSnapshotComesAfterAllUndos(const MvccSnapshot& snap) c
lock_guard<rw_spinlock> lock(&component_lock_);
undos = undo_delta_stores_;
}
- BOOST_FOREACH(const shared_ptr<DeltaStore>& undo, undos) {
+ for (const shared_ptr<DeltaStore>& undo : undos) {
DeltaFileReader* dfr = down_cast<DeltaFileReader*>(undo.get());
// Even though IsRelevantForSnapshot() is safe to call without
@@ -327,7 +325,7 @@ Status DeltaTracker::NewDeltaFileIterator(
// TODO: we need to somehow ensure this doesn't fail - we have to somehow coordinate
// minor delta compaction against delta flush. Add a test case here to trigger this
// condition.
- BOOST_FOREACH(const shared_ptr<DeltaStore>& store, *included_stores) {
+ for (const shared_ptr<DeltaStore>& store : *included_stores) {
ignore_result(down_cast<DeltaFileReader*>(store.get()));
}
@@ -377,9 +375,9 @@ Status DeltaTracker::CheckRowDeleted(rowid_t row_idx, bool *deleted,
}
// Then check backwards through the list of trackers.
- BOOST_REVERSE_FOREACH(const shared_ptr<DeltaStore>& ds, redo_delta_stores_) {
+ for (auto ds = redo_delta_stores_.crbegin(); ds != redo_delta_stores_.crend(); ds++) {
stats->deltas_consulted++;
- RETURN_NOT_OK(ds->CheckRowDeleted(row_idx, deleted));
+ RETURN_NOT_OK((*ds)->CheckRowDeleted(row_idx, deleted));
if (*deleted) {
return Status::OK();
}
@@ -506,7 +504,7 @@ size_t DeltaTracker::CountRedoDeltaStores() const {
uint64_t DeltaTracker::EstimateOnDiskSize() const {
shared_lock<rw_spinlock> lock(&component_lock_);
uint64_t size = 0;
- BOOST_FOREACH(const shared_ptr<DeltaStore>& ds, redo_delta_stores_) {
+ for (const shared_ptr<DeltaStore>& ds : redo_delta_stores_) {
size += ds->EstimateSize();
}
return size;
@@ -516,7 +514,7 @@ void DeltaTracker::GetColumnIdsWithUpdates(std::vector<ColumnId>* col_ids) const
shared_lock<rw_spinlock> lock(&component_lock_);
set<ColumnId> column_ids_with_updates;
- BOOST_FOREACH(const shared_ptr<DeltaStore>& ds, redo_delta_stores_) {
+ for (const shared_ptr<DeltaStore>& ds : redo_delta_stores_) {
// We won't force open files just to read their stats.
if (!ds->Initted()) {
continue;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/deltafile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltafile-test.cc b/src/kudu/tablet/deltafile-test.cc
index e5de159..c97726b 100644
--- a/src/kudu/tablet/deltafile-test.cc
+++ b/src/kudu/tablet/deltafile-test.cc
@@ -209,7 +209,7 @@ TEST_F(TestDeltaFile, TestDumpDeltaFileIterator) {
schema_,
ITERATE_OVER_ALL_ROWS,
&it_contents));
- BOOST_FOREACH(const string& str, it_contents) {
+ for (const string& str : it_contents) {
VLOG(1) << str;
}
ASSERT_TRUE(is_sorted(it_contents.begin(), it_contents.end()));
@@ -246,7 +246,7 @@ TEST_F(TestDeltaFile, TestWriteDeltaFileIteratorToFile) {
schema_,
ITERATE_OVER_ALL_ROWS,
&it_contents));
- BOOST_FOREACH(const string& str, it_contents) {
+ for (const string& str : it_contents) {
VLOG(1) << str;
}
ASSERT_TRUE(is_sorted(it_contents.begin(), it_contents.end()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/deltafile.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltafile.cc b/src/kudu/tablet/deltafile.cc
index 0c07ce6..97f31e0 100644
--- a/src/kudu/tablet/deltafile.cc
+++ b/src/kudu/tablet/deltafile.cc
@@ -513,7 +513,7 @@ Status DeltaFileIterator::VisitMutations(Visitor *visitor) {
rowid_t start_row = prepared_idx_;
- BOOST_FOREACH(PreparedDeltaBlock &block, delta_blocks_) {
+ for (PreparedDeltaBlock &block : delta_blocks_) {
BinaryPlainBlockDecoder &bpd = *block.decoder_;
DVLOG(2) << "Visiting delta block " << block.first_updated_idx_ << "-"
<< block.last_updated_idx_ << " for row block starting at " << start_row;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/deltamemstore-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltamemstore-test.cc b/src/kudu/tablet/deltamemstore-test.cc
index cecfa1c..b319bec 100644
--- a/src/kudu/tablet/deltamemstore-test.cc
+++ b/src/kudu/tablet/deltamemstore-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <memory>
#include <stdlib.h>
@@ -75,7 +74,7 @@ class TestDeltaMemStore : public KuduTest {
faststring buf;
RowChangeListEncoder update(&buf);
- BOOST_FOREACH(uint32_t idx_to_update, indexes_to_update) {
+ for (uint32_t idx_to_update : indexes_to_update) {
ScopedTransaction tx(&mvcc_);
tx.StartApplying();
update.Reset();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/deltamemstore.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltamemstore.cc b/src/kudu/tablet/deltamemstore.cc
index 2b2999c..f6ac496 100644
--- a/src/kudu/tablet/deltamemstore.cc
+++ b/src/kudu/tablet/deltamemstore.cc
@@ -228,7 +228,7 @@ Status DMSIterator::PrepareBatch(size_t nrows, PrepareFlag flag) {
if (updates_by_col_.empty()) {
updates_by_col_.resize(projection_->num_columns());
}
- BOOST_FOREACH(UpdatesForColumn& ufc, updates_by_col_) {
+ for (UpdatesForColumn& ufc : updates_by_col_) {
ufc.clear();
}
deletes_and_reinserts_.clear();
@@ -311,7 +311,7 @@ Status DMSIterator::ApplyUpdates(size_t col_to_apply, ColumnBlock *dst) {
DCHECK_EQ(prepared_count_, dst->nrows());
const ColumnSchema* col_schema = &projection_->column(col_to_apply);
- BOOST_FOREACH(const ColumnUpdate& cu, updates_by_col_[col_to_apply]) {
+ for (const ColumnUpdate& cu : updates_by_col_[col_to_apply]) {
int32_t idx_in_block = cu.row_id - prepared_idx_;
DCHECK_GE(idx_in_block, 0);
SimpleConstCell src(col_schema, cu.new_val_ptr);
@@ -327,7 +327,7 @@ Status DMSIterator::ApplyDeletes(SelectionVector *sel_vec) {
DCHECK_EQ(prepared_for_, PREPARED_FOR_APPLY);
DCHECK_EQ(prepared_count_, sel_vec->nrows());
- BOOST_FOREACH(const DeleteOrReinsert& dor, deletes_and_reinserts_) {
+ for (const DeleteOrReinsert& dor : deletes_and_reinserts_) {
uint32_t idx_in_block = dor.row_id - prepared_idx_;
if (!dor.exists) {
sel_vec->SetRowUnselected(idx_in_block);
@@ -340,7 +340,7 @@ Status DMSIterator::ApplyDeletes(SelectionVector *sel_vec) {
Status DMSIterator::CollectMutations(vector<Mutation *> *dst, Arena *arena) {
DCHECK_EQ(prepared_for_, PREPARED_FOR_COLLECT);
- BOOST_FOREACH(const PreparedDelta& src, prepared_deltas_) {
+ for (const PreparedDelta& src : prepared_deltas_) {
DeltaKey key = src.key;;
RowChangeList changelist(src.val);
uint32_t rel_idx = key.row_idx() - prepared_idx_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/diskrowset-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/diskrowset-test-base.h b/src/kudu/tablet/diskrowset-test-base.h
index 173a5d4..1ef1b80 100644
--- a/src/kudu/tablet/diskrowset-test-base.h
+++ b/src/kudu/tablet/diskrowset-test-base.h
@@ -74,7 +74,7 @@ class TestRowSet : public KuduRowSetTest {
const vector<string>& cols) {
vector<ColumnSchema> col_schemas;
vector<ColumnId> col_ids;
- BOOST_FOREACH(const string& col, cols) {
+ for (const string& col : cols) {
int idx = schema.find_column(col);
CHECK_GE(idx, 0);
col_schemas.push_back(schema.column(idx));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/diskrowset-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/diskrowset-test.cc b/src/kudu/tablet/diskrowset-test.cc
index e445335..877fa05 100644
--- a/src/kudu/tablet/diskrowset-test.cc
+++ b/src/kudu/tablet/diskrowset-test.cc
@@ -430,7 +430,7 @@ TEST_F(TestRowSet, TestRollingDiskRowSetWriter) {
vector<shared_ptr<RowSetMetadata> > metas;
writer.GetWrittenRowSetMetadata(&metas);
EXPECT_EQ(4, metas.size());
- BOOST_FOREACH(const shared_ptr<RowSetMetadata>& meta, metas) {
+ for (const shared_ptr<RowSetMetadata>& meta : metas) {
ASSERT_TRUE(meta->HasDataForColumnIdForTests(schema_.column_id(0)));
}
}
@@ -455,7 +455,7 @@ TEST_F(TestRowSet, TestMakeDeltaIteratorMergerUnlocked) {
ASSERT_OK(DebugDumpDeltaIterator(REDO, merge_iter.get(), schema_,
ITERATE_OVER_ALL_ROWS,
&results));
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
VLOG(1) << str;
}
ASSERT_EQ(compacted_stores.size(), num_stores);
@@ -530,7 +530,7 @@ TEST_F(TestRowSet, TestCompactStores) {
ASSERT_OK(DebugDumpDeltaIterator(REDO, merge_iter.get(), schema_,
ITERATE_OVER_ALL_ROWS,
&results));
- BOOST_FOREACH(const string &str, results) {
+ for (const string &str : results) {
VLOG(1) << str;
}
ASSERT_TRUE(is_sorted(results.begin(), results.end()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/local_tablet_writer.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/local_tablet_writer.h b/src/kudu/tablet/local_tablet_writer.h
index d8dd7c6..3a6a645 100644
--- a/src/kudu/tablet/local_tablet_writer.h
+++ b/src/kudu/tablet/local_tablet_writer.h
@@ -17,7 +17,6 @@
#ifndef KUDU_TABLET_LOCAL_TABLET_WRITER_H
#define KUDU_TABLET_LOCAL_TABLET_WRITER_H
-#include <boost/foreach.hpp>
#include <vector>
#include "kudu/common/partial_row.h"
@@ -85,7 +84,7 @@ class LocalTabletWriter {
req_.mutable_row_operations()->Clear();
RowOperationsPBEncoder encoder(req_.mutable_row_operations());
- BOOST_FOREACH(const Op& op, ops) {
+ for (const Op& op : ops) {
encoder.Add(op.type, *op.row);
}
@@ -106,7 +105,7 @@ class LocalTabletWriter {
// Return the status of first failed op.
int op_idx = 0;
- BOOST_FOREACH(const OperationResultPB& result, result_.ops()) {
+ for (const OperationResultPB& result : result_.ops()) {
if (result.has_failed_status()) {
return StatusFromPB(result.failed_status())
.CloneAndPrepend(ops[op_idx].row->ToString());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/lock_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/lock_manager-test.cc b/src/kudu/tablet/lock_manager-test.cc
index 6d01907..0a405e7 100644
--- a/src/kudu/tablet/lock_manager-test.cc
+++ b/src/kudu/tablet/lock_manager-test.cc
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include <boost/thread/thread.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -163,16 +162,16 @@ class LmTestThread {
for (int i = 0; i < FLAGS_num_iterations; i++) {
std::vector<shared_ptr<ScopedRowLock> > locks;
// TODO: We don't have an API for multi-row
- BOOST_FOREACH(const Slice* key, keys_) {
+ for (const Slice* key : keys_) {
locks.push_back(shared_ptr<ScopedRowLock>(
new ScopedRowLock(manager_, my_txn,
*key, LockManager::LOCK_EXCLUSIVE)));
}
- BOOST_FOREACH(LmTestResource* r, resources_) {
+ for (LmTestResource* r : resources_) {
r->acquire(tid_);
}
- BOOST_FOREACH(LmTestResource* r, resources_) {
+ for (LmTestResource* r : resources_) {
r->release(tid_);
}
}
@@ -199,11 +198,11 @@ static void runPerformanceTest(const char *test_type,
vector<shared_ptr<LmTestThread> > *threads) {
Stopwatch sw(Stopwatch::ALL_THREADS);
sw.start();
- BOOST_FOREACH(const shared_ptr<LmTestThread>& t, *threads) {
+ for (const shared_ptr<LmTestThread>& t : *threads) {
t->Start();
}
- BOOST_FOREACH(const shared_ptr<LmTestThread>& t, *threads) {
+ for (const shared_ptr<LmTestThread>& t : *threads) {
t->Join();
}
sw.stop();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/maintenance_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/maintenance_manager.cc b/src/kudu/tablet/maintenance_manager.cc
index 56b2d9e..f344430 100644
--- a/src/kudu/tablet/maintenance_manager.cc
+++ b/src/kudu/tablet/maintenance_manager.cc
@@ -17,7 +17,6 @@
#include "kudu/tablet/maintenance_manager.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <memory>
#include <stdint.h>
@@ -271,7 +270,7 @@ MaintenanceOp* MaintenanceManager::FindBestOp() {
double best_perf_improvement = 0;
MaintenanceOp* best_perf_improvement_op = NULL;
- BOOST_FOREACH(OpMapTy::value_type &val, ops_) {
+ for (OpMapTy::value_type &val : ops_) {
MaintenanceOp* op(val.first);
MaintenanceOpStats& stats(val.second);
// Update op stats.
@@ -385,7 +384,7 @@ void MaintenanceManager::GetMaintenanceManagerStatusDump(MaintenanceManagerStatu
DCHECK(out_pb != NULL);
lock_guard<Mutex> guard(&lock_);
MaintenanceOp* best_op = FindBestOp();
- BOOST_FOREACH(MaintenanceManager::OpMapTy::value_type& val, ops_) {
+ for (MaintenanceManager::OpMapTy::value_type& val : ops_) {
MaintenanceManagerStatusPB_MaintenanceOpPB* op_pb = out_pb->add_registered_operations();
MaintenanceOp* op(val.first);
MaintenanceOpStats& stat(val.second);
@@ -401,7 +400,7 @@ void MaintenanceManager::GetMaintenanceManagerStatusDump(MaintenanceManagerStatu
}
}
- BOOST_FOREACH(const CompletedOp& completed_op, completed_ops_) {
+ for (const CompletedOp& completed_op : completed_ops_) {
if (!completed_op.name.empty()) {
MaintenanceManagerStatusPB_CompletedOpPB* completed_pb = out_pb->add_completed_operations();
completed_pb->set_name(completed_op.name);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/memrowset.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/memrowset.cc b/src/kudu/tablet/memrowset.cc
index 534a247..0b1348e 100644
--- a/src/kudu/tablet/memrowset.cc
+++ b/src/kudu/tablet/memrowset.cc
@@ -562,8 +562,7 @@ Status MemRowSet::Iterator::ApplyMutationsToProjectedRow(
// TODO: this is slow, since it makes multiple passes through the rowchangelist.
// Instead, we should keep the backwards mapping of columns.
- BOOST_FOREACH(const RowProjector::ProjectionIdxMapping& mapping,
- projector_->base_cols_mapping()) {
+ for (const RowProjector::ProjectionIdxMapping& mapping : projector_->base_cols_mapping()) {
RowChangeListDecoder decoder(mut->changelist());
RETURN_NOT_OK(decoder.Init());
ColumnBlock dst_col = dst_row->column_block(mapping.first);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/metadata-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/metadata-test.cc b/src/kudu/tablet/metadata-test.cc
index c5d879c..8d5c059 100644
--- a/src/kudu/tablet/metadata-test.cc
+++ b/src/kudu/tablet/metadata-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <string>
#include <vector>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/mt-diskrowset-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mt-diskrowset-test.cc b/src/kudu/tablet/mt-diskrowset-test.cc
index dd6ba82..98b3dc4 100644
--- a/src/kudu/tablet/mt-diskrowset-test.cc
+++ b/src/kudu/tablet/mt-diskrowset-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/thread/thread.hpp>
#include <memory>
@@ -60,7 +59,7 @@ class TestMultiThreadedRowSet : public TestRowSet {
}
void JoinThreads(boost::ptr_vector<boost::thread> *threads) {
- BOOST_FOREACH(boost::thread &thr, *threads) {
+ for (boost::thread &thr : *threads) {
thr.join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mt-rowset_delta_compaction-test.cc b/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
index fa83453..ff7c370 100644
--- a/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
+++ b/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/thread/thread.hpp>
#include <memory>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/mt-tablet-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mt-tablet-test.cc b/src/kudu/tablet/mt-tablet-test.cc
index 4c30568..ab77f19 100644
--- a/src/kudu/tablet/mt-tablet-test.cc
+++ b/src/kudu/tablet/mt-tablet-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
@@ -381,7 +380,7 @@ class MultiThreadedTabletTest : public TabletTestBase<SETUP> {
}
void JoinThreads() {
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/multi_column_writer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/multi_column_writer.cc b/src/kudu/tablet/multi_column_writer.cc
index 4efc7de..0632415 100644
--- a/src/kudu/tablet/multi_column_writer.cc
+++ b/src/kudu/tablet/multi_column_writer.cc
@@ -134,7 +134,7 @@ void MultiColumnWriter::GetFlushedBlocksByColumnId(std::map<ColumnId, BlockId>*
size_t MultiColumnWriter::written_size() const {
size_t size = 0;
- BOOST_FOREACH(const CFileWriter *writer, cfile_writers_) {
+ for (const CFileWriter *writer : cfile_writers_) {
size += writer->written_size();
}
return size;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/mvcc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mvcc.cc b/src/kudu/tablet/mvcc.cc
index 58c4de5..b7f50f3 100644
--- a/src/kudu/tablet/mvcc.cc
+++ b/src/kudu/tablet/mvcc.cc
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
#include <glog/logging.h>
@@ -347,7 +346,7 @@ bool MvccManager::AreAllTransactionsCommittedUnlocked(Timestamp ts) const {
}
bool MvccManager::AnyApplyingAtOrBeforeUnlocked(Timestamp ts) const {
- BOOST_FOREACH(const InFlightMap::value_type entry, timestamps_in_flight_) {
+ for (const InFlightMap::value_type entry : timestamps_in_flight_) {
if (entry.first <= ts.value()) {
return true;
}
@@ -381,7 +380,7 @@ void MvccManager::WaitForApplyingTransactionsToCommit() const {
Timestamp wait_for = Timestamp::kMin;
{
boost::lock_guard<LockType> l(lock_);
- BOOST_FOREACH(const InFlightMap::value_type entry, timestamps_in_flight_) {
+ for (const InFlightMap::value_type entry : timestamps_in_flight_) {
if (entry.second == APPLYING) {
wait_for = Timestamp(std::max(entry.first, wait_for.value()));
}
@@ -417,7 +416,7 @@ Timestamp MvccManager::GetCleanTimestamp() const {
void MvccManager::GetApplyingTransactionsTimestamps(std::vector<Timestamp>* timestamps) const {
boost::lock_guard<LockType> l(lock_);
timestamps->reserve(timestamps_in_flight_.size());
- BOOST_FOREACH(const InFlightMap::value_type entry, timestamps_in_flight_) {
+ for (const InFlightMap::value_type entry : timestamps_in_flight_) {
if (entry.second == APPLYING) {
timestamps->push_back(Timestamp(entry.first));
}
@@ -455,7 +454,7 @@ MvccSnapshot MvccSnapshot::CreateSnapshotIncludingNoTransactions() {
}
bool MvccSnapshot::IsCommittedFallback(const Timestamp& timestamp) const {
- BOOST_FOREACH(const Timestamp::val_type& v, committed_timestamps_) {
+ for (const Timestamp::val_type& v : committed_timestamps_) {
if (v == timestamp.value()) return true;
}
@@ -486,7 +485,7 @@ std::string MvccSnapshot::ToString() const {
" or (T in {");
bool first = true;
- BOOST_FOREACH(Timestamp::val_type t, committed_timestamps_) {
+ for (Timestamp::val_type t : committed_timestamps_) {
if (!first) {
ret.push_back(',');
}
@@ -498,7 +497,7 @@ std::string MvccSnapshot::ToString() const {
}
void MvccSnapshot::AddCommittedTimestamps(const std::vector<Timestamp>& timestamps) {
- BOOST_FOREACH(const Timestamp& ts, timestamps) {
+ for (const Timestamp& ts : timestamps) {
AddCommittedTimestamp(ts);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/rowset.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset.cc b/src/kudu/tablet/rowset.cc
index f6b3266..b2768ba 100644
--- a/src/kudu/tablet/rowset.cc
+++ b/src/kudu/tablet/rowset.cc
@@ -48,7 +48,7 @@ DuplicatingRowSet::~DuplicatingRowSet() {
static void AppendRowSetStrings(const RowSetVector &rowsets, string *dst) {
bool first = true;
dst->append("[");
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, rowsets) {
+ for (const shared_ptr<RowSet> &rs : rowsets) {
if (!first) {
dst->append(", ");
}
@@ -79,7 +79,7 @@ Status DuplicatingRowSet::NewRowIterator(const Schema *projection,
// Union between them
vector<shared_ptr<RowwiseIterator> > iters;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, old_rowsets_) {
+ for (const shared_ptr<RowSet> &rowset : old_rowsets_) {
gscoped_ptr<RowwiseIterator> iter;
RETURN_NOT_OK_PREPEND(rowset->NewRowIterator(projection, snap, &iter),
Substitute("Could not create iterator for rowset $0",
@@ -116,7 +116,7 @@ Status DuplicatingRowSet::MutateRow(Timestamp timestamp,
// First mutate the relevant input rowset.
bool updated = false;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, old_rowsets_) {
+ for (const shared_ptr<RowSet> &rowset : old_rowsets_) {
Status s = rowset->MutateRow(timestamp, probe, update, op_id, stats, result);
if (s.ok()) {
updated = true;
@@ -136,7 +136,7 @@ Status DuplicatingRowSet::MutateRow(Timestamp timestamp,
// If it succeeded there, we also need to mirror into the new rowset.
int mirrored_count = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &new_rowset, new_rowsets_) {
+ for (const shared_ptr<RowSet> &new_rowset : new_rowsets_) {
Status s = new_rowset->MutateRow(timestamp, probe, update, op_id, stats, result);
if (s.ok()) {
mirrored_count++;
@@ -162,7 +162,7 @@ Status DuplicatingRowSet::MutateRow(Timestamp timestamp,
Status DuplicatingRowSet::CheckRowPresent(const RowSetKeyProbe &probe,
bool *present, ProbeStats* stats) const {
*present = false;
- BOOST_FOREACH(const shared_ptr<RowSet> &rowset, old_rowsets_) {
+ for (const shared_ptr<RowSet> &rowset : old_rowsets_) {
RETURN_NOT_OK(rowset->CheckRowPresent(probe, present, stats));
if (*present) {
return Status::OK();
@@ -173,7 +173,7 @@ Status DuplicatingRowSet::CheckRowPresent(const RowSetKeyProbe &probe,
Status DuplicatingRowSet::CountRows(rowid_t *count) const {
int64_t accumulated_count = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, new_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : new_rowsets_) {
rowid_t this_count;
RETURN_NOT_OK(rs->CountRows(&this_count));
accumulated_count += this_count;
@@ -202,7 +202,7 @@ uint64_t DuplicatingRowSet::EstimateOnDiskSize() const {
// The actual value of this doesn't matter, since it won't be selected
// for compaction.
uint64_t size = 0;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, new_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : new_rowsets_) {
size += rs->EstimateOnDiskSize();
}
return size;
@@ -214,14 +214,14 @@ shared_ptr<RowSetMetadata> DuplicatingRowSet::metadata() {
Status DuplicatingRowSet::DebugDump(vector<string> *lines) {
int i = 1;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, old_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : old_rowsets_) {
LOG_STRING(INFO, lines) << "Duplicating rowset input " << ToString() << " "
<< i << "/" << old_rowsets_.size() << ":";
RETURN_NOT_OK(rs->DebugDump(lines));
i++;
}
i = 1;
- BOOST_FOREACH(const shared_ptr<RowSet> &rs, new_rowsets_) {
+ for (const shared_ptr<RowSet> &rs : new_rowsets_) {
LOG_STRING(INFO, lines) << "Duplicating rowset output " << ToString() << " "
<< i << "/" << new_rowsets_.size() << ":";
RETURN_NOT_OK(rs->DebugDump(lines));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/rowset_info.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_info.cc b/src/kudu/tablet/rowset_info.cc
index 7d570d4..5e45f6a 100644
--- a/src/kudu/tablet/rowset_info.cc
+++ b/src/kudu/tablet/rowset_info.cc
@@ -144,7 +144,7 @@ double WidthByDataSize(const Slice& prev, const Slice& next,
const unordered_map<RowSet*, RowSetInfo*>& active) {
double weight = 0;
- BOOST_FOREACH(const RowSetRowSetInfoPair& rsi, active) {
+ for (const RowSetRowSetInfoPair& rsi : active) {
RowSet* rs = rsi.first;
double fraction = StringFractionInRange(rs, prev, next);
weight += rs->EstimateOnDiskSize() * fraction;
@@ -173,7 +173,7 @@ void CheckCollectOrderedCorrectness(const vector<RowSetInfo>& min_key,
void RowSetInfo::Collect(const RowSetTree& tree, vector<RowSetInfo>* rsvec) {
rsvec->reserve(tree.all_rowsets().size());
- BOOST_FOREACH(const shared_ptr<RowSet>& ptr, tree.all_rowsets()) {
+ for (const shared_ptr<RowSet>& ptr : tree.all_rowsets()) {
rsvec->push_back(RowSetInfo(ptr.get(), 0));
}
}
@@ -209,7 +209,7 @@ void RowSetInfo::CollectOrdered(const RowSetTree& tree,
// else there's a race since we see endpoints twice and a delta compaction might finish in
// between.
RowSetVector available_rowsets;
- BOOST_FOREACH(const shared_ptr<RowSet> rs, tree.all_rowsets()) {
+ for (const shared_ptr<RowSet> rs : tree.all_rowsets()) {
if (rs->IsAvailableForCompaction()) {
available_rowsets.push_back(rs);
}
@@ -217,14 +217,14 @@ void RowSetInfo::CollectOrdered(const RowSetTree& tree,
RowSetTree available_rs_tree;
available_rs_tree.Reset(available_rowsets);
- BOOST_FOREACH(const RowSetTree::RSEndpoint& rse,
+ for (const RowSetTree::RSEndpoint& rse :
available_rs_tree.key_endpoints()) {
RowSet* rs = rse.rowset_;
const Slice& next = rse.slice_;
double interval_width = WidthByDataSize(prev, next, active);
// Increment active rowsets in min_key by the interval_width.
- BOOST_FOREACH(const RowSetRowSetInfoPair& rsi, active) {
+ for (const RowSetRowSetInfoPair& rsi : active) {
RowSetInfo& cdf_rs = *rsi.second;
cdf_rs.cdf_max_key_ += interval_width;
}
@@ -272,7 +272,7 @@ RowSetInfo::RowSetInfo(RowSet* rs, double init_cdf)
void RowSetInfo::FinalizeCDFVector(vector<RowSetInfo>* vec,
double quot) {
if (quot == 0) return;
- BOOST_FOREACH(RowSetInfo& cdf_rs, *vec) {
+ for (RowSetInfo& cdf_rs : *vec) {
CHECK_GT(cdf_rs.size_mb_, 0) << "Expected file size to be at least 1MB "
<< "for RowSet " << cdf_rs.rowset_->ToString()
<< ", was " << cdf_rs.rowset_->EstimateOnDiskSize()
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/rowset_metadata.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_metadata.cc b/src/kudu/tablet/rowset_metadata.cc
index 7723af6..6259e92 100644
--- a/src/kudu/tablet/rowset_metadata.cc
+++ b/src/kudu/tablet/rowset_metadata.cc
@@ -69,20 +69,20 @@ Status RowSetMetadata::InitFromPB(const RowSetDataPB& pb) {
}
// Load Column Files
- BOOST_FOREACH(const ColumnDataPB& col_pb, pb.columns()) {
+ for (const ColumnDataPB& col_pb : pb.columns()) {
ColumnId col_id = ColumnId(col_pb.column_id());
blocks_by_col_id_[col_id] = BlockId::FromPB(col_pb.block());
}
// Load redo delta files
- BOOST_FOREACH(const DeltaDataPB& redo_delta_pb, pb.redo_deltas()) {
+ for (const DeltaDataPB& redo_delta_pb : pb.redo_deltas()) {
redo_delta_blocks_.push_back(BlockId::FromPB(redo_delta_pb.block()));
}
last_durable_redo_dms_id_ = pb.last_durable_dms_id();
// Load undo delta files
- BOOST_FOREACH(const DeltaDataPB& undo_delta_pb, pb.undo_deltas()) {
+ for (const DeltaDataPB& undo_delta_pb : pb.undo_deltas()) {
undo_delta_blocks_.push_back(BlockId::FromPB(undo_delta_pb.block()));
}
@@ -96,7 +96,7 @@ void RowSetMetadata::ToProtobuf(RowSetDataPB *pb) {
lock_guard<LockType> l(&lock_);
// Write Column Files
- BOOST_FOREACH(const ColumnIdToBlockIdMap::value_type& e, blocks_by_col_id_) {
+ for (const ColumnIdToBlockIdMap::value_type& e : blocks_by_col_id_) {
ColumnId col_id = e.first;
const BlockId& block_id = e.second;
@@ -108,12 +108,12 @@ void RowSetMetadata::ToProtobuf(RowSetDataPB *pb) {
// Write Delta Files
pb->set_last_durable_dms_id(last_durable_redo_dms_id_);
- BOOST_FOREACH(const BlockId& redo_delta_block, redo_delta_blocks_) {
+ for (const BlockId& redo_delta_block : redo_delta_blocks_) {
DeltaDataPB *redo_delta_pb = pb->add_redo_deltas();
redo_delta_block.CopyToPB(redo_delta_pb->mutable_block());
}
- BOOST_FOREACH(const BlockId& undo_delta_block, undo_delta_blocks_) {
+ for (const BlockId& undo_delta_block : undo_delta_blocks_) {
DeltaDataPB *undo_delta_pb = pb->add_undo_deltas();
undo_delta_block.CopyToPB(undo_delta_pb->mutable_block());
}
@@ -157,7 +157,7 @@ Status RowSetMetadata::CommitUpdate(const RowSetMetadataUpdate& update) {
{
lock_guard<LockType> l(&lock_);
- BOOST_FOREACH(const RowSetMetadataUpdate::ReplaceDeltaBlocks rep,
+ for (const RowSetMetadataUpdate::ReplaceDeltaBlocks rep :
update.replace_redo_blocks_) {
CHECK(!rep.to_remove.empty());
@@ -166,7 +166,7 @@ Status RowSetMetadata::CommitUpdate(const RowSetMetadataUpdate& update) {
redo_delta_blocks_.end(), rep.to_remove[0]);
vector<BlockId>::iterator end_it = start_it;
- BOOST_FOREACH(const BlockId& b, rep.to_remove) {
+ for (const BlockId& b : rep.to_remove) {
if (end_it == redo_delta_blocks_.end() || *end_it != b) {
return Status::InvalidArgument(
Substitute("Cannot find subsequence <$0> in <$1>",
@@ -182,7 +182,7 @@ Status RowSetMetadata::CommitUpdate(const RowSetMetadataUpdate& update) {
}
// Add new redo blocks
- BOOST_FOREACH(const BlockId& b, update.new_redo_blocks_) {
+ for (const BlockId& b : update.new_redo_blocks_) {
redo_delta_blocks_.push_back(b);
}
@@ -191,7 +191,7 @@ Status RowSetMetadata::CommitUpdate(const RowSetMetadataUpdate& update) {
undo_delta_blocks_.insert(undo_delta_blocks_.begin(), update.new_undo_block_);
}
- BOOST_FOREACH(const ColumnIdToBlockIdMap::value_type& e, update.cols_to_replace_) {
+ for (const ColumnIdToBlockIdMap::value_type& e : update.cols_to_replace_) {
// If we are major-compacting deltas into a column which previously had no
// base-data (e.g. because it was newly added), then there will be no original
// block there to replace.
@@ -201,7 +201,7 @@ Status RowSetMetadata::CommitUpdate(const RowSetMetadataUpdate& update) {
}
}
- BOOST_FOREACH(ColumnId col_id, update.col_ids_to_remove_) {
+ for (ColumnId col_id : update.col_ids_to_remove_) {
BlockId old = FindOrDie(blocks_by_col_id_, col_id);
CHECK_EQ(1, blocks_by_col_id_.erase(col_id));
removed.push_back(old);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/tablet/rowset_tree-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_tree-test.cc b/src/kudu/tablet/rowset_tree-test.cc
index 190d48d..bd8aefc 100644
--- a/src/kudu/tablet/rowset_tree-test.cc
+++ b/src/kudu/tablet/rowset_tree-test.cc
@@ -147,7 +147,7 @@ TEST_F(TestRowSetTree, TestEndpointsConsistency) {
unordered_set<RowSet*> visited;
Slice prev;
- BOOST_FOREACH(const RowSetTree::RSEndpoint& rse, tree.key_endpoints()) {
+ for (const RowSetTree::RSEndpoint& rse : tree.key_endpoints()) {
RowSet* rs = rse.rowset_;
enum RowSetTree::EndpointType ept = rse.endpoint_;
const Slice& slice = rse.slice_;
[4/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Posted by da...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/cluster_itest_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.cc b/src/kudu/integration-tests/cluster_itest_util.cc
index 48f88b4..2cbfa4f 100644
--- a/src/kudu/integration-tests/cluster_itest_util.cc
+++ b/src/kudu/integration-tests/cluster_itest_util.cc
@@ -17,7 +17,6 @@
#include <algorithm>
#include <boost/optional.hpp>
-#include <boost/foreach.hpp>
#include <glog/stl_logging.h>
#include <limits>
@@ -114,7 +113,7 @@ Status GetLastOpIdForEachReplica(const string& tablet_id,
RpcController controller;
op_ids->clear();
- BOOST_FOREACH(TServerDetails* ts, replicas) {
+ for (TServerDetails* ts : replicas) {
controller.Reset();
controller.set_timeout(MonoDelta::FromSeconds(3));
opid_resp.Clear();
@@ -159,7 +158,7 @@ Status WaitForServersToAgree(const MonoDelta& timeout,
bool any_behind = false;
bool any_disagree = false;
int64_t cur_index = kInvalidOpIdIndex;
- BOOST_FOREACH(const OpId& id, ids) {
+ for (const OpId& id : ids) {
if (cur_index == kInvalidOpIdIndex) {
cur_index = id.index();
}
@@ -200,7 +199,7 @@ Status WaitUntilAllReplicasHaveOp(const int64_t log_index,
Status s = GetLastOpIdForEachReplica(tablet_id, replicas, &op_ids);
if (s.ok()) {
bool any_behind = false;
- BOOST_FOREACH(const OpId& op_id, op_ids) {
+ for (const OpId& op_id : op_ids) {
if (op_id.index() < log_index) {
any_behind = true;
break;
@@ -217,7 +216,7 @@ Status WaitUntilAllReplicasHaveOp(const int64_t log_index,
SleepFor(MonoDelta::FromMilliseconds(50));
}
string replicas_str;
- BOOST_FOREACH(const TServerDetails* replica, replicas) {
+ for (const TServerDetails* replica : replicas) {
if (!replicas_str.empty()) replicas_str += ", ";
replicas_str += "{ " + replica->ToString() + " }";
}
@@ -240,7 +239,7 @@ Status CreateTabletServerMap(MasterServiceProxy* master_proxy,
}
ts_map->clear();
- BOOST_FOREACH(const ListTabletServersResponsePB::Entry& entry, resp.servers()) {
+ for (const ListTabletServersResponsePB::Entry& entry : resp.servers()) {
HostPort host_port;
RETURN_NOT_OK(HostPortFromPB(entry.registration().rpc_addresses(0), &host_port));
vector<Sockaddr> addresses;
@@ -568,7 +567,7 @@ Status ListRunningTabletIds(const TServerDetails* ts,
vector<ListTabletsResponsePB::StatusAndSchemaPB> tablets;
RETURN_NOT_OK(ListTablets(ts, timeout, &tablets));
tablet_ids->clear();
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& t, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& t : tablets) {
if (t.tablet_status().state() == tablet::RUNNING) {
tablet_ids->push_back(t.tablet_status().tablet_id());
}
@@ -628,7 +627,7 @@ Status WaitForNumVotersInConfigOnMaster(const shared_ptr<MasterServiceProxy>& ma
s = GetTabletLocations(master_proxy, tablet_id, time_remaining, &tablet_locations);
if (s.ok()) {
num_voters_found = 0;
- BOOST_FOREACH(const TabletLocationsPB::ReplicaPB& r, tablet_locations.replicas()) {
+ for (const TabletLocationsPB::ReplicaPB& r : tablet_locations.replicas()) {
if (r.role() == RaftPeerPB::LEADER || r.role() == RaftPeerPB::FOLLOWER) num_voters_found++;
}
if (num_voters_found == num_voters) break;
@@ -681,7 +680,7 @@ Status WaitUntilTabletInState(TServerDetails* ts,
s = ListTablets(ts, MonoDelta::FromSeconds(10), &tablets);
if (s.ok()) {
bool seen = false;
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& t, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& t : tablets) {
if (t.tablet_status().tablet_id() == tablet_id) {
seen = true;
last_state = t.tablet_status().state();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/create-table-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/create-table-stress-test.cc b/src/kudu/integration-tests/create-table-stress-test.cc
index 0a2ddf3..622aa0c 100644
--- a/src/kudu/integration-tests/create-table-stress-test.cc
+++ b/src/kudu/integration-tests/create-table-stress-test.cc
@@ -275,11 +275,11 @@ TEST_F(CreateTableStressTest, TestGetTableLocationsOptions) {
LOG(INFO) << "========================================================";
std::vector<scoped_refptr<master::TableInfo> > tables;
cluster_->mini_master()->master()->catalog_manager()->GetAllTables(&tables);
- BOOST_FOREACH(const scoped_refptr<master::TableInfo>& table_info, tables) {
+ for (const scoped_refptr<master::TableInfo>& table_info : tables) {
LOG(INFO) << "Table: " << table_info->ToString();
std::vector<scoped_refptr<master::TabletInfo> > tablets;
table_info->GetAllTablets(&tablets);
- BOOST_FOREACH(const scoped_refptr<master::TabletInfo>& tablet_info, tablets) {
+ for (const scoped_refptr<master::TabletInfo>& tablet_info : tablets) {
master::TabletMetadataLock l_tablet(tablet_info.get(), master::TabletMetadataLock::READ);
const master::SysTabletsEntryPB& metadata = tablet_info->metadata().state().pb;
LOG(INFO) << " Tablet: " << tablet_info->ToString()
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/delete_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/delete_table-test.cc b/src/kudu/integration-tests/delete_table-test.cc
index 5c11d55..4edbba8 100644
--- a/src/kudu/integration-tests/delete_table-test.cc
+++ b/src/kudu/integration-tests/delete_table-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <glog/stl_logging.h>
#include <gtest/gtest.h>
@@ -952,7 +951,7 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
NO_FATALS(WaitForTabletTombstonedOnTS(kTsIndex, tablet_id, CMETA_EXPECTED));
ASSERT_OK(itest::WaitForNumTabletsOnTS(ts, 2, timeout, &tablets));
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& t, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& t : tablets) {
if (t.tablet_status().tablet_id() == tablet_id) {
ASSERT_EQ(tablet::SHUTDOWN, t.tablet_status().state());
ASSERT_EQ(TABLET_DATA_TOMBSTONED, t.tablet_status().tablet_data_state())
@@ -978,7 +977,7 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
// just with their data state set as TOMBSTONED. They should also be listed
// as NOT_STARTED because we restarted the server.
ASSERT_OK(itest::WaitForNumTabletsOnTS(ts, 2, timeout, &tablets));
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& t, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& t : tablets) {
ASSERT_EQ(tablet::NOT_STARTED, t.tablet_status().state());
ASSERT_EQ(TABLET_DATA_TOMBSTONED, t.tablet_status().tablet_data_state())
<< t.tablet_status().tablet_id() << " not tombstoned";
@@ -986,7 +985,7 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
// Finally, delete all tablets on the TS, and wait for all data to be gone.
LOG(INFO) << "Deleting all tablets...";
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& tablet, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& tablet : tablets) {
string tablet_id = tablet.tablet_status().tablet_id();
// We need retries here, since some of the tablets may still be
// bootstrapping after being restarted above.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/external_mini_cluster-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster-test.cc b/src/kudu/integration-tests/external_mini_cluster-test.cc
index ddc8230..cb3d37b 100644
--- a/src/kudu/integration-tests/external_mini_cluster-test.cc
+++ b/src/kudu/integration-tests/external_mini_cluster-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <sys/types.h>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/external_mini_cluster.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster.cc b/src/kudu/integration-tests/external_mini_cluster.cc
index 4ca4934..0af21c7 100644
--- a/src/kudu/integration-tests/external_mini_cluster.cc
+++ b/src/kudu/integration-tests/external_mini_cluster.cc
@@ -17,7 +17,6 @@
#include "kudu/integration-tests/external_mini_cluster.h"
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <memory>
#include <rapidjson/document.h>
@@ -151,27 +150,27 @@ Status ExternalMiniCluster::Start() {
void ExternalMiniCluster::Shutdown(NodeSelectionMode mode) {
if (mode == ALL) {
- BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
+ for (const scoped_refptr<ExternalMaster>& master : masters_) {
if (master) {
master->Shutdown();
}
}
}
- BOOST_FOREACH(const scoped_refptr<ExternalTabletServer>& ts, tablet_servers_) {
+ for (const scoped_refptr<ExternalTabletServer>& ts : tablet_servers_) {
ts->Shutdown();
}
}
Status ExternalMiniCluster::Restart() {
- BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
+ for (const scoped_refptr<ExternalMaster>& master : masters_) {
if (master && master->IsShutdown()) {
RETURN_NOT_OK_PREPEND(master->Restart(), "Cannot restart master bound at: " +
master->bound_rpc_hostport().ToString());
}
}
- BOOST_FOREACH(const scoped_refptr<ExternalTabletServer>& ts, tablet_servers_) {
+ for (const scoped_refptr<ExternalTabletServer>& ts : tablet_servers_) {
if (ts->IsShutdown()) {
RETURN_NOT_OK_PREPEND(ts->Restart(), "Cannot restart tablet server bound at: " +
ts->bound_rpc_hostport().ToString());
@@ -200,7 +199,7 @@ vector<string> SubstituteInFlags(const vector<string>& orig_flags,
int index) {
string str_index = strings::Substitute("$0", index);
vector<string> ret;
- BOOST_FOREACH(const string& orig, orig_flags) {
+ for (const string& orig : orig_flags) {
ret.push_back(StringReplace(orig, "${index}", str_index, true));
}
return ret;
@@ -306,8 +305,8 @@ Status ExternalMiniCluster::WaitForTabletServerCount(int count, const MonoDelta&
// Do a second step of verification to verify that the descs that we got
// are aligned (same uuid/seqno) with the TSs that we have in the cluster.
int match_count = 0;
- BOOST_FOREACH(const master::ListTabletServersResponsePB_Entry& e, resp.servers()) {
- BOOST_FOREACH(const scoped_refptr<ExternalTabletServer>& ets, tablet_servers_) {
+ for (const master::ListTabletServersResponsePB_Entry& e : resp.servers()) {
+ for (const scoped_refptr<ExternalTabletServer>& ets : tablet_servers_) {
if (ets->instance_id().permanent_uuid() == e.instance_id().permanent_uuid() &&
ets->instance_id().instance_seqno() == e.instance_id().instance_seqno()) {
match_count++;
@@ -326,7 +325,7 @@ Status ExternalMiniCluster::WaitForTabletServerCount(int count, const MonoDelta&
void ExternalMiniCluster::AssertNoCrashes() {
vector<ExternalDaemon*> daemons = this->daemons();
- BOOST_FOREACH(ExternalDaemon* d, daemons) {
+ for (ExternalDaemon* d : daemons) {
if (d->IsShutdown()) continue;
EXPECT_TRUE(d->IsProcessAlive()) << "At least one process crashed";
}
@@ -349,7 +348,7 @@ Status ExternalMiniCluster::WaitForTabletsRunning(ExternalTabletServer* ts,
}
int num_not_running = 0;
- BOOST_FOREACH(const StatusAndSchemaPB& status, resp.status_and_schema()) {
+ for (const StatusAndSchemaPB& status : resp.status_and_schema()) {
if (status.tablet_status().state() != tablet::RUNNING) {
num_not_running++;
}
@@ -385,7 +384,7 @@ Status ExternalMiniCluster::GetLeaderMasterIndex(int* idx) {
MonoTime deadline = MonoTime::Now(MonoTime::FINE);
deadline.AddDelta(MonoDelta::FromSeconds(5));
- BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
+ for (const scoped_refptr<ExternalMaster>& master : masters_) {
addrs.push_back(master->bound_rpc_addr());
}
rpc.reset(new GetLeaderMasterRpc(Bind(&LeaderMasterCallback,
@@ -414,7 +413,7 @@ Status ExternalMiniCluster::GetLeaderMasterIndex(int* idx) {
}
ExternalTabletServer* ExternalMiniCluster::tablet_server_by_uuid(const std::string& uuid) const {
- BOOST_FOREACH(const scoped_refptr<ExternalTabletServer>& ts, tablet_servers_) {
+ for (const scoped_refptr<ExternalTabletServer>& ts : tablet_servers_) {
if (ts->instance_id().permanent_uuid() == uuid) {
return ts.get();
}
@@ -433,10 +432,10 @@ int ExternalMiniCluster::tablet_server_index_by_uuid(const std::string& uuid) co
vector<ExternalDaemon*> ExternalMiniCluster::daemons() const {
vector<ExternalDaemon*> results;
- BOOST_FOREACH(const scoped_refptr<ExternalTabletServer>& ts, tablet_servers_) {
+ for (const scoped_refptr<ExternalTabletServer>& ts : tablet_servers_) {
results.push_back(ts.get());
}
- BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
+ for (const scoped_refptr<ExternalMaster>& master : masters_) {
results.push_back(master.get());
}
return results;
@@ -461,7 +460,7 @@ Status ExternalMiniCluster::CreateClient(client::KuduClientBuilder& builder,
client::sp::shared_ptr<client::KuduClient>* client) {
CHECK(!masters_.empty());
builder.clear_master_server_addrs();
- BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
+ for (const scoped_refptr<ExternalMaster>& master : masters_) {
builder.add_master_server_addr(master->bound_rpc_hostport().ToString());
}
return builder.Build(client);
@@ -718,7 +717,7 @@ Status ExternalDaemon::GetInt64Metric(const MetricEntityPrototype* entity_proto,
RETURN_NOT_OK(r.Init());
vector<const Value*> entities;
RETURN_NOT_OK(r.ExtractObjectArray(r.root(), NULL, &entities));
- BOOST_FOREACH(const Value* entity, entities) {
+ for (const Value* entity : entities) {
// Find the desired entity.
string type;
RETURN_NOT_OK(r.ExtractString(entity, "type", &type));
@@ -736,7 +735,7 @@ Status ExternalDaemon::GetInt64Metric(const MetricEntityPrototype* entity_proto,
// Find the desired metric within the entity.
vector<const Value*> metrics;
RETURN_NOT_OK(r.ExtractObjectArray(entity, "metrics", &metrics));
- BOOST_FOREACH(const Value* metric, metrics) {
+ for (const Value* metric : metrics) {
string name;
RETURN_NOT_OK(r.ExtractString(metric, "name", &name));
if (name != metric_proto->name()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc b/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
index ae227a0..5d5b2d2 100644
--- a/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
+++ b/src/kudu/integration-tests/external_mini_cluster_fs_inspector.cc
@@ -18,7 +18,6 @@
#include "kudu/integration-tests/external_mini_cluster_fs_inspector.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include "kudu/consensus/metadata.pb.h"
#include "kudu/gutil/strings/join.h"
@@ -75,7 +74,7 @@ int ExternalMiniClusterFsInspector::CountWALSegmentsOnTS(int index) {
vector<string> tablets;
CHECK_OK(ListFilesInDir(ts_wal_dir, &tablets));
int total_segments = 0;
- BOOST_FOREACH(const string& tablet, tablets) {
+ for (const string& tablet : tablets) {
string tablet_wal_dir = JoinPathSegments(ts_wal_dir, tablet);
total_segments += CountFilesInDir(tablet_wal_dir);
}
@@ -284,9 +283,9 @@ Status ExternalMiniClusterFsInspector::WaitForFilePatternInTabletWalDirOnTs(
error_msg = "";
bool any_missing_required = false;
- BOOST_FOREACH(const string& required_filter, substrings_required) {
+ for (const string& required_filter : substrings_required) {
bool filter_matched = false;
- BOOST_FOREACH(const string& entry, entries) {
+ for (const string& entry : entries) {
if (entry.find(required_filter) != string::npos) {
filter_matched = true;
break;
@@ -300,9 +299,9 @@ Status ExternalMiniClusterFsInspector::WaitForFilePatternInTabletWalDirOnTs(
}
bool any_present_disallowed = false;
- BOOST_FOREACH(const string& entry, entries) {
+ for (const string& entry : entries) {
if (any_present_disallowed) break;
- BOOST_FOREACH(const string& disallowed_filter, substrings_disallowed) {
+ for (const string& disallowed_filter : substrings_disallowed) {
if (entry.find(disallowed_filter) != string::npos) {
any_present_disallowed = true;
error_msg += "present from substrings_disallowed: " + entry +
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/flex_partitioning-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/flex_partitioning-itest.cc b/src/kudu/integration-tests/flex_partitioning-itest.cc
index e481876..5c2fea9 100644
--- a/src/kudu/integration-tests/flex_partitioning-itest.cc
+++ b/src/kudu/integration-tests/flex_partitioning-itest.cc
@@ -19,7 +19,6 @@
// of PK subsets, etc).
#include <algorithm>
-#include <boost/foreach.hpp>
#include <glog/stl_logging.h>
#include <map>
#include <memory>
@@ -222,7 +221,7 @@ void FlexPartitioningITest::CheckScanWithColumnPredicate(Slice col_name, int low
// Manually evaluate the predicate against the data we think we inserted.
vector<string> expected_rows;
- BOOST_FOREACH(const KuduPartialRow* row, inserted_rows_) {
+ for (const KuduPartialRow* row : inserted_rows_) {
int32_t val;
CHECK_OK(row->GetInt32(col_name, &val));
if (val >= lower && val <= upper) {
@@ -263,7 +262,7 @@ void FlexPartitioningITest::CheckPartitionKeyRangeScan() {
vector<string> rows;
- BOOST_FOREACH(const master::TabletLocationsPB& tablet_locations,
+ for (const master::TabletLocationsPB& tablet_locations :
table_locations.tablet_locations()) {
string partition_key_start = tablet_locations.partition().partition_key_start();
@@ -278,7 +277,7 @@ void FlexPartitioningITest::CheckPartitionKeyRangeScan() {
std::sort(rows.begin(), rows.end());
vector<string> expected_rows;
- BOOST_FOREACH(KuduPartialRow* row, inserted_rows_) {
+ for (KuduPartialRow* row : inserted_rows_) {
expected_rows.push_back("(" + row->ToString() + ")");
}
std::sort(expected_rows.begin(), expected_rows.end());
@@ -296,7 +295,7 @@ void FlexPartitioningITest::CheckPartitionKeyRangeScanWithPKRange(int lower, int
vector<string> rows;
- BOOST_FOREACH(const master::TabletLocationsPB& tablet_locations,
+ for (const master::TabletLocationsPB& tablet_locations :
table_locations.tablet_locations()) {
string partition_key_start = tablet_locations.partition().partition_key_start();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/full_stack-insert-scan-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/full_stack-insert-scan-test.cc b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
index c42707f..a2abf77 100644
--- a/src/kudu/integration-tests/full_stack-insert-scan-test.cc
+++ b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <cmath>
#include <cstdlib>
#include <gflags/gflags.h>
@@ -299,7 +298,7 @@ void FullStackInsertScanTest::DoConcurrentClientInserts() {
strings::Substitute("concurrent inserts ($0 rows, $1 threads)",
kNumRows, kNumInsertClients)) {
start_latch.CountDown();
- BOOST_FOREACH(const scoped_refptr<Thread>& thread, threads) {
+ for (const scoped_refptr<Thread>& thread : threads) {
ASSERT_OK(ThreadJoiner(thread.get())
.warn_every_ms(15000)
.Join());
@@ -333,7 +332,7 @@ void FullStackInsertScanTest::FlushToDisk() {
tserver::TSTabletManager* tm = ts->tablet_manager();
vector<scoped_refptr<TabletPeer> > peers;
tm->GetTabletPeers(&peers);
- BOOST_FOREACH(const scoped_refptr<TabletPeer>& peer, peers) {
+ for (const scoped_refptr<TabletPeer>& peer : peers) {
Tablet* tablet = peer->tablet();
if (!tablet->MemRowSetEmpty()) {
ASSERT_OK(tablet->Flush());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/linked_list-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test-util.h b/src/kudu/integration-tests/linked_list-test-util.h
index 42a0891..0536e6f 100644
--- a/src/kudu/integration-tests/linked_list-test-util.h
+++ b/src/kudu/integration-tests/linked_list-test-util.h
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <iostream>
#include <list>
@@ -303,7 +302,7 @@ class PeriodicWebUIChecker {
// Generate list of urls for each master and tablet server
for (int i = 0; i < cluster.num_masters(); i++) {
- BOOST_FOREACH(std::string page, master_pages) {
+ for (std::string page : master_pages) {
urls_.push_back(strings::Substitute(
"http://$0$1",
cluster.master(i)->bound_http_hostport().ToString(),
@@ -311,7 +310,7 @@ class PeriodicWebUIChecker {
}
}
for (int i = 0; i < cluster.num_tablet_servers(); i++) {
- BOOST_FOREACH(std::string page, ts_pages) {
+ for (std::string page : ts_pages) {
urls_.push_back(strings::Substitute(
"http://$0$1",
cluster.tablet_server(i)->bound_http_hostport().ToString(),
@@ -336,7 +335,7 @@ class PeriodicWebUIChecker {
faststring dst;
LOG(INFO) << "Curl thread will poll the following URLs every " << period_.ToMilliseconds()
<< " ms: ";
- BOOST_FOREACH(std::string url, urls_) {
+ for (std::string url : urls_) {
LOG(INFO) << url;
}
for (int count = 0; is_running_.Load(); count++) {
@@ -402,7 +401,7 @@ class LinkedListVerifier {
std::vector<const KuduPartialRow*> LinkedListTester::GenerateSplitRows(
const client::KuduSchema& schema) {
std::vector<const KuduPartialRow*> split_keys;
- BOOST_FOREACH(int64_t val, GenerateSplitInts()) {
+ for (int64_t val : GenerateSplitInts()) {
KuduPartialRow* row = schema.NewRow();
CHECK_OK(row->SetInt64(kKeyColumnName, val));
split_keys.push_back(row);
@@ -496,7 +495,7 @@ Status LinkedListTester::LoadLinkedList(
}
return Status::OK();
}
- BOOST_FOREACH(LinkedListChainGenerator* chain, chains) {
+ for (LinkedListChainGenerator* chain : chains) {
RETURN_NOT_OK_PREPEND(chain->GenerateNextInsert(table.get(), session.get()),
"Unable to generate next insert into linked list chain");
}
@@ -510,7 +509,7 @@ Status LinkedListTester::LoadLinkedList(
if (enable_mutation_) {
// Rows have been inserted; they're now safe to update.
- BOOST_FOREACH(LinkedListChainGenerator* chain, chains) {
+ for (LinkedListChainGenerator* chain : chains) {
updater.to_update()->Put(chain->prev_key());
}
}
@@ -611,7 +610,7 @@ Status LinkedListTester::VerifyLinkedListRemote(
cb_called = true;
}
RETURN_NOT_OK_PREPEND(scanner.NextBatch(&rows), "Couldn't fetch next row batch");
- BOOST_FOREACH(const client::KuduRowResult& row, rows) {
+ for (const client::KuduRowResult& row : rows) {
int64_t key;
int64_t link;
bool updated;
@@ -802,7 +801,7 @@ void LinkedListVerifier::SummarizeBrokenLinks(const std::vector<int64_t>& broken
int n_logged = 0;
const int kMaxToLog = 100;
- BOOST_FOREACH(int64_t broken, broken_links) {
+ for (int64_t broken : broken_links) {
int tablet = std::upper_bound(split_key_ints_.begin(),
split_key_ints_.end(),
broken) - split_key_ints_.begin();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/linked_list-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test.cc b/src/kudu/integration-tests/linked_list-test.cc
index f1dc222..ed5574a 100644
--- a/src/kudu/integration-tests/linked_list-test.cc
+++ b/src/kudu/integration-tests/linked_list-test.cc
@@ -135,7 +135,7 @@ class LinkedListTest : public tserver::TabletServerIntegrationTestBase {
return;
}
vector<string> split_flags = strings::Split(flags_str, " ");
- BOOST_FOREACH(const string& flag, split_flags) {
+ for (const string& flag : split_flags) {
flags->push_back(flag);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/mini_cluster.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/mini_cluster.cc b/src/kudu/integration-tests/mini_cluster.cc
index ccc1377..3af4192 100644
--- a/src/kudu/integration-tests/mini_cluster.cc
+++ b/src/kudu/integration-tests/mini_cluster.cc
@@ -17,7 +17,6 @@
#include "kudu/integration-tests/mini_cluster.h"
-#include <boost/foreach.hpp>
#include "kudu/client/client.h"
#include "kudu/gutil/strings/join.h"
@@ -118,7 +117,7 @@ Status MiniCluster::StartDistributedMasters() {
mini_masters_[i] = shared_ptr<MiniMaster>(mini_master.release());
}
int i = 0;
- BOOST_FOREACH(const shared_ptr<MiniMaster>& master, mini_masters_) {
+ for (const shared_ptr<MiniMaster>& master : mini_masters_) {
LOG(INFO) << "Waiting to initialize catalog manager on master " << i++;
RETURN_NOT_OK_PREPEND(master->WaitForCatalogManagerInit(),
Substitute("Could not initialize catalog manager on master $0", i));
@@ -129,7 +128,7 @@ Status MiniCluster::StartDistributedMasters() {
Status MiniCluster::StartSync() {
RETURN_NOT_OK(Start());
int count = 0;
- BOOST_FOREACH(const shared_ptr<MiniTabletServer>& tablet_server, mini_tablet_servers_) {
+ for (const shared_ptr<MiniTabletServer>& tablet_server : mini_tablet_servers_) {
RETURN_NOT_OK_PREPEND(tablet_server->WaitStarted(),
Substitute("TabletServer $0 failed to start.", count));
count++;
@@ -171,7 +170,7 @@ Status MiniCluster::AddTabletServer() {
// set the master addresses
tablet_server->options()->master_addresses.clear();
- BOOST_FOREACH(const shared_ptr<MiniMaster>& master, mini_masters_) {
+ for (const shared_ptr<MiniMaster>& master : mini_masters_) {
tablet_server->options()->master_addresses.push_back(HostPort(master->bound_rpc_addr()));
}
RETURN_NOT_OK(tablet_server->Start())
@@ -201,11 +200,11 @@ MiniMaster* MiniCluster::leader_mini_master() {
}
void MiniCluster::Shutdown() {
- BOOST_FOREACH(const shared_ptr<MiniTabletServer>& tablet_server, mini_tablet_servers_) {
+ for (const shared_ptr<MiniTabletServer>& tablet_server : mini_tablet_servers_) {
tablet_server->Shutdown();
}
mini_tablet_servers_.clear();
- BOOST_FOREACH(shared_ptr<MiniMaster>& master_server, mini_masters_) {
+ for (shared_ptr<MiniMaster>& master_server : mini_masters_) {
master_server->Shutdown();
master_server.reset();
}
@@ -213,7 +212,7 @@ void MiniCluster::Shutdown() {
}
void MiniCluster::ShutdownMasters() {
- BOOST_FOREACH(shared_ptr<MiniMaster>& master_server, mini_masters_) {
+ for (shared_ptr<MiniMaster>& master_server : mini_masters_) {
master_server->Shutdown();
master_server.reset();
}
@@ -280,7 +279,7 @@ Status MiniCluster::WaitForTabletServerCount(int count,
// Do a second step of verification to verify that the descs that we got
// are aligned (same uuid/seqno) with the TSs that we have in the cluster.
int match_count = 0;
- BOOST_FOREACH(const shared_ptr<TSDescriptor>& desc, *descs) {
+ for (const shared_ptr<TSDescriptor>& desc : *descs) {
for (int i = 0; i < mini_tablet_servers_.size(); ++i) {
TabletServer *ts = mini_tablet_servers_[i]->server();
if (ts->instance_pb().permanent_uuid() == desc->permanent_uuid() &&
@@ -309,7 +308,7 @@ Status MiniCluster::CreateClient(KuduClientBuilder* builder,
builder = &default_builder;
}
builder->clear_master_server_addrs();
- BOOST_FOREACH(const shared_ptr<MiniMaster>& master, mini_masters_) {
+ for (const shared_ptr<MiniMaster>& master : mini_masters_) {
CHECK(master);
builder->add_master_server_addr(master->bound_rpc_addr_str());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/raft_consensus-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index b8351c0..8496ddb 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -187,12 +186,12 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
replica_results.size());
StrAppend(&ret, "Leader Results: \n");
- BOOST_FOREACH(const string& result, leader_results) {
+ for (const string& result : leader_results) {
StrAppend(&ret, result, "\n");
}
StrAppend(&ret, "Replica Results: \n");
- BOOST_FOREACH(const string& result, replica_results) {
+ for (const string& result : replica_results) {
StrAppend(&ret, result, "\n");
}
@@ -237,13 +236,13 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
bool overflow;
session->GetPendingErrors(&errors, &overflow);
CHECK(!overflow);
- BOOST_FOREACH(const client::KuduError* e, errors) {
+ for (const client::KuduError* e : errors) {
CHECK(e->status().IsAlreadyPresent()) << "Unexpected error: " << e->status().ToString();
}
inserted -= errors.size();
}
- BOOST_FOREACH(CountDownLatch* latch, latches) {
+ for (CountDownLatch* latch : latches) {
latch->CountDown(inserted);
}
}
@@ -297,7 +296,7 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
vector<TServerDetails*> followers;
GetOnlyLiveFollowerReplicas(tablet_id_, &followers);
- BOOST_FOREACH(TServerDetails* ts, followers) {
+ for (TServerDetails* ts : followers) {
ExternalTabletServer* ets = cluster_->tablet_server_by_uuid(ts->uuid());
CHECK_OK(ets->Pause());
SleepFor(MonoDelta::FromMilliseconds(100));
@@ -312,7 +311,7 @@ class RaftConsensusITest : public TabletServerIntegrationTestBase {
}
// Resume the replicas.
- BOOST_FOREACH(TServerDetails* ts, followers) {
+ for (TServerDetails* ts : followers) {
ExternalTabletServer* ets = cluster_->tablet_server_by_uuid(ts->uuid());
CHECK_OK(ets->Resume());
}
@@ -524,7 +523,7 @@ TEST_F(RaftConsensusITest, MultiThreadedMutateAndInsertThroughConsensus) {
&new_thread));
threads_.push_back(new_thread);
}
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
@@ -1004,12 +1003,12 @@ TEST_F(RaftConsensusITest, MultiThreadedInsertWithFailovers) {
threads_.push_back(new_thread);
}
- BOOST_FOREACH(CountDownLatch* latch, latches) {
+ for (CountDownLatch* latch : latches) {
latch->Wait();
StopOrKillLeaderAndElectNewOne();
}
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
@@ -1055,7 +1054,7 @@ TEST_F(RaftConsensusITest, TestAutomaticLeaderElection) {
}
// Restart every node that was killed, and wait for the nodes to converge
- BOOST_FOREACH(TServerDetails* killed_node, killed_leaders) {
+ for (TServerDetails* killed_node : killed_leaders) {
CHECK_OK(cluster_->tablet_server_by_uuid(killed_node->uuid())->Restart());
}
// Verify the data on the remaining replicas.
@@ -1140,7 +1139,7 @@ TEST_F(RaftConsensusITest, TestKUDU_597) {
}
finish.Store(true);
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
}
@@ -1418,7 +1417,7 @@ void RaftConsensusITest::AssertMajorityRequiredForElectionsAndWrites(
int num_to_pause = config_size - minority_to_retain;
LOG(INFO) << "Pausing " << num_to_pause << " tablet servers in config of size " << config_size;
vector<string> paused_uuids;
- BOOST_FOREACH(const TabletServerMap::value_type& entry, tablet_servers) {
+ for (const TabletServerMap::value_type& entry : tablet_servers) {
if (paused_uuids.size() == num_to_pause) {
continue;
}
@@ -1450,7 +1449,7 @@ void RaftConsensusITest::AssertMajorityRequiredForElectionsAndWrites(
// Resume the paused servers.
LOG(INFO) << "Resuming " << num_to_pause << " tablet servers in config of size " << config_size;
- BOOST_FOREACH(const string& replica_uuid, paused_uuids) {
+ for (const string& replica_uuid : paused_uuids) {
ExternalTabletServer* replica_ts = cluster_->tablet_server_by_uuid(replica_uuid);
ASSERT_OK(replica_ts->Resume());
}
@@ -1503,7 +1502,7 @@ void RaftConsensusITest::WaitForReplicasReportedToMaster(
ASSERT_OK(GetTabletLocations(tablet_id, timeout, tablet_locations));
*has_leader = false;
if (tablet_locations->replicas_size() == num_replicas) {
- BOOST_FOREACH(const master::TabletLocationsPB_ReplicaPB& replica,
+ for (const master::TabletLocationsPB_ReplicaPB& replica :
tablet_locations->replicas()) {
if (replica.role() == RaftPeerPB::LEADER) {
*has_leader = true;
@@ -1566,7 +1565,7 @@ TEST_F(RaftConsensusITest, TestAddRemoveServer) {
// Go from 3 tablet servers down to 1 in the configuration.
vector<int> remove_list = { 2, 1 };
- BOOST_FOREACH(int to_remove_idx, remove_list) {
+ for (int to_remove_idx : remove_list) {
int num_servers = active_tablet_servers.size();
LOG(INFO) << "Remove: Going from " << num_servers << " to " << num_servers - 1 << " replicas";
@@ -1586,7 +1585,7 @@ TEST_F(RaftConsensusITest, TestAddRemoveServer) {
// Add the tablet servers back, in reverse order, going from 1 to 3 servers in the configuration.
vector<int> add_list = { 1, 2 };
- BOOST_FOREACH(int to_add_idx, add_list) {
+ for (int to_add_idx : add_list) {
int num_servers = active_tablet_servers.size();
LOG(INFO) << "Add: Going from " << num_servers << " to " << num_servers + 1 << " replicas";
@@ -1896,7 +1895,7 @@ TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
LOG(INFO) << "Removing servers...";
// Go from 3 tablet servers down to 1 in the configuration.
vector<int> remove_list = { 2, 1 };
- BOOST_FOREACH(int to_remove_idx, remove_list) {
+ for (int to_remove_idx : remove_list) {
int num_servers = active_tablet_servers.size();
LOG(INFO) << "Remove: Going from " << num_servers << " to " << num_servers - 1 << " replicas";
@@ -1913,7 +1912,7 @@ TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
LOG(INFO) << "Adding servers...";
// Add the tablet servers back, in reverse order, going from 1 to 3 servers in the configuration.
vector<int> add_list = { 1, 2 };
- BOOST_FOREACH(int to_add_idx, add_list) {
+ for (int to_add_idx : add_list) {
int num_servers = active_tablet_servers.size();
LOG(INFO) << "Add: Going from " << num_servers << " to " << num_servers + 1 << " replicas";
@@ -1929,7 +1928,7 @@ TEST_F(RaftConsensusITest, TestConfigChangeUnderLoad) {
LOG(INFO) << "Joining writer threads...";
finish.Store(true);
- BOOST_FOREACH(const scoped_refptr<Thread>& thread, threads) {
+ for (const scoped_refptr<Thread>& thread : threads) {
ASSERT_OK(ThreadJoiner(thread.get()).Join());
}
@@ -1967,7 +1966,7 @@ TEST_F(RaftConsensusITest, TestMasterNotifiedOnConfigChange) {
// Determine the server to add to the config.
string uuid_to_add;
- BOOST_FOREACH(const TabletServerMap::value_type& entry, tablet_servers_) {
+ for (const TabletServerMap::value_type& entry : tablet_servers_) {
if (!ContainsKey(active_tablet_servers, entry.second->uuid())) {
uuid_to_add = entry.second->uuid();
}
@@ -2130,7 +2129,7 @@ TEST_F(RaftConsensusITest, TestAutoCreateReplica) {
InsertOrDie(&active_tablet_servers, follower->uuid(), follower);
TServerDetails* new_node = NULL;
- BOOST_FOREACH(TServerDetails* ts, tservers) {
+ for (TServerDetails* ts : tservers) {
if (!ContainsKey(active_tablet_servers, ts->uuid())) {
new_node = ts;
break;
@@ -2251,7 +2250,7 @@ static void EnableLogLatency(server::GenericServiceProxy* proxy) {
FlagMap flags;
InsertOrDie(&flags, "log_inject_latency", "true");
InsertOrDie(&flags, "log_inject_latency_ms_mean", "1000");
- BOOST_FOREACH(const FlagMap::value_type& e, flags) {
+ for (const FlagMap::value_type& e : flags) {
SetFlagRequestPB req;
SetFlagResponsePB resp;
RpcController rpc;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/remote_bootstrap-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/remote_bootstrap-itest.cc b/src/kudu/integration-tests/remote_bootstrap-itest.cc
index 3a72353..828f03a 100644
--- a/src/kudu/integration-tests/remote_bootstrap-itest.cc
+++ b/src/kudu/integration-tests/remote_bootstrap-itest.cc
@@ -433,13 +433,13 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
ASSERT_OK(WaitForNumTabletsOnTS(target_ts, kNumTablets, timeout, &tablets));
vector<string> tablet_ids;
- BOOST_FOREACH(const ListTabletsResponsePB::StatusAndSchemaPB& t, tablets) {
+ for (const ListTabletsResponsePB::StatusAndSchemaPB& t : tablets) {
tablet_ids.push_back(t.tablet_status().tablet_id());
}
// Wait until all replicas are up and running.
for (int i = 0; i < cluster_->num_tablet_servers(); i++) {
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
ASSERT_OK(itest::WaitUntilTabletRunning(ts_map_[cluster_->tablet_server(i)->uuid()],
tablet_id, timeout));
}
@@ -448,7 +448,7 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
// Elect leaders on each tablet for term 1. All leaders will be on TS 1.
const int kLeaderIndex = 1;
const string kLeaderUuid = cluster_->tablet_server(kLeaderIndex)->uuid();
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
ASSERT_OK(itest::StartElection(ts_map_[kLeaderUuid], tablet_id, timeout));
}
@@ -464,14 +464,14 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
}
workload.StopAndJoin();
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
ASSERT_OK(WaitForServersToAgree(timeout, ts_map_, tablet_id, 1));
}
// Now pause the leader so we can tombstone the tablets.
ASSERT_OK(cluster_->tablet_server(kLeaderIndex)->Pause());
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
LOG(INFO) << "Tombstoning tablet " << tablet_id << " on TS " << target_ts->uuid();
ASSERT_OK(itest::DeleteTablet(target_ts, tablet_id, TABLET_DATA_TOMBSTONED, boost::none,
MonoDelta::FromSeconds(10)));
@@ -480,7 +480,7 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
// Unpause the leader TS and wait for it to remotely bootstrap the tombstoned
// tablets, in parallel.
ASSERT_OK(cluster_->tablet_server(kLeaderIndex)->Resume());
- BOOST_FOREACH(const string& tablet_id, tablet_ids) {
+ for (const string& tablet_id : tablet_ids) {
ASSERT_OK(itest::WaitUntilTabletRunning(target_ts, tablet_id, timeout));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/test_workload.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/test_workload.cc b/src/kudu/integration-tests/test_workload.cc
index aa6ab25..aa0588c 100644
--- a/src/kudu/integration-tests/test_workload.cc
+++ b/src/kudu/integration-tests/test_workload.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include "kudu/client/client.h"
#include "kudu/client/client-test-util.h"
@@ -138,7 +137,7 @@ void TestWorkload::WriteThread() {
bool overflow;
session->GetPendingErrors(&errors, &overflow);
CHECK(!overflow);
- BOOST_FOREACH(const client::KuduError* e, errors) {
+ for (const client::KuduError* e : errors) {
if (timeout_allowed_ && e->status().IsTimedOut()) {
continue;
}
@@ -237,7 +236,7 @@ void TestWorkload::Start() {
void TestWorkload::StopAndJoin() {
should_run_.Store(false);
start_latch_.Reset(0);
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads_) {
+ for (scoped_refptr<kudu::Thread> thr : threads_) {
CHECK_OK(ThreadJoiner(thr.get()).Join());
}
threads_.clear();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/ts_itest-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/ts_itest-base.h b/src/kudu/integration-tests/ts_itest-base.h
index 17d29c0..5a77969 100644
--- a/src/kudu/integration-tests/ts_itest-base.h
+++ b/src/kudu/integration-tests/ts_itest-base.h
@@ -17,7 +17,6 @@
#ifndef KUDU_INTEGRATION_TESTS_ITEST_UTIL_H_
#define KUDU_INTEGRATION_TESTS_ITEST_UTIL_H_
-#include <boost/foreach.hpp>
#include <glog/stl_logging.h>
#include <string>
#include <utility>
@@ -79,7 +78,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
return;
}
std::vector<std::string> split_flags = strings::Split(flags_str, " ");
- BOOST_FOREACH(const std::string& flag, split_flags) {
+ for (const std::string& flag : split_flags) {
flags->push_back(flag);
}
}
@@ -105,11 +104,11 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
opts.extra_tserver_flags.push_back(strings::Substitute("--consensus_rpc_timeout_ms=$0",
FLAGS_consensus_rpc_timeout_ms));
} else {
- BOOST_FOREACH(const std::string& flag, non_default_ts_flags) {
+ for (const std::string& flag : non_default_ts_flags) {
opts.extra_tserver_flags.push_back(flag);
}
}
- BOOST_FOREACH(const std::string& flag, non_default_master_flags) {
+ for (const std::string& flag : non_default_master_flags) {
opts.extra_master_flags.push_back(flag);
}
@@ -148,8 +147,8 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
CHECK_OK(controller.status());
CHECK(!resp.has_error()) << "Response had an error: " << resp.error().ShortDebugString();
- BOOST_FOREACH(const master::TabletLocationsPB& location, resp.tablet_locations()) {
- BOOST_FOREACH(const master::TabletLocationsPB_ReplicaPB& replica, location.replicas()) {
+ for (const master::TabletLocationsPB& location : resp.tablet_locations()) {
+ for (const master::TabletLocationsPB_ReplicaPB& replica : location.replicas()) {
TServerDetails* server = FindOrDie(tablet_servers_, replica.ts_info().permanent_uuid());
tablet_replicas.insert(pair<std::string, TServerDetails*>(location.tablet_id(), server));
}
@@ -199,7 +198,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
}
std::random_shuffle(replicas_copy.begin(), replicas_copy.end());
- BOOST_FOREACH(TServerDetails* replica, replicas_copy) {
+ for (TServerDetails* replica : replicas_copy) {
if (GetReplicaStatusAndCheckIfLeader(replica, tablet_id,
MonoDelta::FromMilliseconds(100)).ok()) {
return replica;
@@ -231,9 +230,9 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
req.mutable_table()->set_table_name(kTableId);
RETURN_NOT_OK(cluster_->master_proxy()->GetTableLocations(req, &resp, &controller));
- BOOST_FOREACH(const TabletLocationsPB& loc, resp.tablet_locations()) {
+ for (const TabletLocationsPB& loc : resp.tablet_locations()) {
if (loc.tablet_id() == tablet_id) {
- BOOST_FOREACH(const TabletLocationsPB::ReplicaPB& replica, loc.replicas()) {
+ for (const TabletLocationsPB::ReplicaPB& replica : loc.replicas()) {
if (replica.role() == RaftPeerPB::LEADER) {
*leader_uuid = replica.ts_info().permanent_uuid();
return Status::OK();
@@ -290,7 +289,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
++iter;
}
- BOOST_FOREACH(const std::string& uuid, uuids) {
+ for (const std::string& uuid : uuids) {
delete EraseKeyReturnValuePtr(&tablet_servers_, uuid);
}
}
@@ -308,7 +307,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
replicas.push_back((*range.first).second);
}
- BOOST_FOREACH(TServerDetails* replica, replicas) {
+ for (TServerDetails* replica : replicas) {
if (leader != NULL &&
replica->instance_id.permanent_uuid() == leader->instance_id.permanent_uuid()) {
continue;
@@ -374,7 +373,7 @@ class TabletServerIntegrationTestBase : public TabletServerTestBase {
std::string error = strings::Substitute("Fewer than $0 TabletServers were alive. Dead TSs: ",
num_tablet_servers);
RpcController controller;
- BOOST_FOREACH(const TabletServerMap::value_type& entry, tablet_servers_) {
+ for (const TabletServerMap::value_type& entry : tablet_servers_) {
controller.Reset();
controller.set_timeout(MonoDelta::FromSeconds(10));
PingRequestPB req;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/integration-tests/update_scan_delta_compact-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/update_scan_delta_compact-test.cc b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
index aa51e3f..82b3edd 100644
--- a/src/kudu/integration-tests/update_scan_delta_compact-test.cc
+++ b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
@@ -228,7 +228,7 @@ void UpdateScanDeltaCompactionTest::RunThreads() {
SleepFor(MonoDelta::FromSeconds(FLAGS_seconds_to_run * 1.0));
stop_latch.CountDown();
- BOOST_FOREACH(const scoped_refptr<Thread>& thread, threads) {
+ for (const scoped_refptr<Thread>& thread : threads) {
ASSERT_OK(ThreadJoiner(thread.get())
.warn_every_ms(500)
.Join());
@@ -278,7 +278,7 @@ void UpdateScanDeltaCompactionTest::CurlWebPages(CountDownLatch* stop_latch) con
EasyCurl curl;
faststring dst;
while (stop_latch->count() > 0) {
- BOOST_FOREACH(const string& url, urls) {
+ for (const string& url : urls) {
VLOG(1) << "Curling URL " << url;
Status status = curl.FetchURL(url, &dst);
if (status.ok()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/catalog_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 342580f..8a3b77b 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -36,7 +36,6 @@
#include "kudu/master/catalog_manager.h"
-#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/locks.hpp>
@@ -601,7 +600,7 @@ void CatalogManager::Shutdown() {
}
// Abort and Wait tables task completion
- BOOST_FOREACH(const TableInfoMap::value_type& e, table_ids_map_) {
+ for (const TableInfoMap::value_type& e : table_ids_map_) {
e.second->AbortTasks();
e.second->WaitTasksCompletion();
}
@@ -631,7 +630,7 @@ void CatalogManager::AbortTableCreation(TableInfo* table,
string table_id = table->id();
string table_name = table->mutable_metadata()->mutable_dirty()->pb.name();
vector<string> tablet_ids_to_erase;
- BOOST_FOREACH(TabletInfo* tablet, tablets) {
+ for (TabletInfo* tablet : tablets) {
tablet_ids_to_erase.push_back(tablet->tablet_id());
}
@@ -648,11 +647,11 @@ void CatalogManager::AbortTableCreation(TableInfo* table,
// Call AbortMutation() manually, as otherwise the lock won't be
// released.
- BOOST_FOREACH(TabletInfo* tablet, tablets) {
+ for (TabletInfo* tablet : tablets) {
tablet->mutable_metadata()->AbortMutation();
}
table->mutable_metadata()->AbortMutation();
- BOOST_FOREACH(const string& tablet_id_to_erase, tablet_ids_to_erase) {
+ for (const string& tablet_id_to_erase : tablet_ids_to_erase) {
CHECK_EQ(tablet_map_.erase(tablet_id_to_erase), 1)
<< "Unable to erase tablet " << tablet_id_to_erase << " from tablet map.";
}
@@ -715,7 +714,7 @@ Status CatalogManager::CreateTable(const CreateTableRequestPB* orig_req,
vector<DecodedRowOperation> ops;
RETURN_NOT_OK(decoder.DecodeOperations(&ops));
- BOOST_FOREACH(const DecodedRowOperation& op, ops) {
+ for (const DecodedRowOperation& op : ops) {
if (op.type != RowOperationsPB::SPLIT_ROW) {
Status s = Status::InvalidArgument(
"Split rows must be specified as RowOperationsPB::SPLIT_ROW");
@@ -779,7 +778,7 @@ Status CatalogManager::CreateTable(const CreateTableRequestPB* orig_req,
table_names_map_[req.name()] = table;
// d. Create the TabletInfo objects in state PREPARING.
- BOOST_FOREACH(const Partition& partition, partitions) {
+ for (const Partition& partition : partitions) {
PartitionPB partition_pb;
partition.ToPB(&partition_pb);
tablets.push_back(CreateTabletInfo(table.get(), partition_pb));
@@ -788,7 +787,7 @@ Status CatalogManager::CreateTable(const CreateTableRequestPB* orig_req,
// Add the table/tablets to the in-memory map for the assignment.
resp->set_table_id(table->id());
table->AddTablets(tablets);
- BOOST_FOREACH(TabletInfo* tablet, tablets) {
+ for (TabletInfo* tablet : tablets) {
InsertOrDie(&tablet_map_, tablet->tablet_id(), tablet);
}
}
@@ -799,7 +798,7 @@ Status CatalogManager::CreateTable(const CreateTableRequestPB* orig_req,
// They will get committed at the end of this function.
// Sanity check: the tables and tablets should all be in "preparing" state.
CHECK_EQ(SysTablesEntryPB::PREPARING, table->metadata().dirty().pb.state());
- BOOST_FOREACH(const TabletInfo *tablet, tablets) {
+ for (const TabletInfo *tablet : tablets) {
CHECK_EQ(SysTabletsEntryPB::PREPARING, tablet->metadata().dirty().pb.state());
}
@@ -831,7 +830,7 @@ Status CatalogManager::CreateTable(const CreateTableRequestPB* orig_req,
// g. Commit the in-memory state.
table->mutable_metadata()->CommitMutation();
- BOOST_FOREACH(TabletInfo *tablet, tablets) {
+ for (TabletInfo *tablet : tablets) {
tablet->mutable_metadata()->CommitMutation();
}
@@ -1000,7 +999,7 @@ static Status ApplyAlterSteps(const SysTablesEntryPB& current_pb,
builder.set_next_column_id(ColumnId(current_pb.next_column_id()));
}
- BOOST_FOREACH(const AlterTableRequestPB::Step& step, req->alter_schema_steps()) {
+ for (const AlterTableRequestPB::Step& step : req->alter_schema_steps()) {
switch (step.type()) {
case AlterTableRequestPB::ADD_COLUMN: {
if (!step.has_add_column()) {
@@ -1271,7 +1270,7 @@ Status CatalogManager::ListTables(const ListTablesRequestPB* req,
boost::shared_lock<LockType> l(lock_);
- BOOST_FOREACH(const TableInfoMap::value_type& entry, table_names_map_) {
+ for (const TableInfoMap::value_type& entry : table_names_map_) {
TableMetadataLock ltm(entry.second.get(), TableMetadataLock::READ);
if (!ltm.data().is_running()) continue;
@@ -1299,7 +1298,7 @@ bool CatalogManager::GetTableInfo(const string& table_id, scoped_refptr<TableInf
void CatalogManager::GetAllTables(std::vector<scoped_refptr<TableInfo> > *tables) {
tables->clear();
boost::shared_lock<LockType> l(lock_);
- BOOST_FOREACH(const TableInfoMap::value_type& e, table_ids_map_) {
+ for (const TableInfoMap::value_type& e : table_ids_map_) {
tables->push_back(e.second);
}
}
@@ -1339,7 +1338,7 @@ Status CatalogManager::ProcessTabletReport(TSDescriptor* ts_desc,
// the server should have, compare vs the ones being reported, and somehow mark
// any that have been "lost" (eg somehow the tablet metadata got corrupted or something).
- BOOST_FOREACH(const ReportedTabletPB& reported, report.updated_tablets()) {
+ for (const ReportedTabletPB& reported : report.updated_tablets()) {
ReportedTabletUpdatesPB *tablet_report = report_update->add_tablets();
tablet_report->set_tablet_id(reported.tablet_id());
RETURN_NOT_OK_PREPEND(HandleReportedTablet(ts_desc, reported, tablet_report),
@@ -1615,7 +1614,7 @@ Status CatalogManager::ResetTabletReplicasFromReportedConfig(
*tablet_lock->mutable_data()->pb.mutable_committed_consensus_state() = cstate;
TabletInfo::ReplicaMap replica_locations;
- BOOST_FOREACH(const consensus::RaftPeerPB& peer, cstate.config().peers()) {
+ for (const consensus::RaftPeerPB& peer : cstate.config().peers()) {
shared_ptr<TSDescriptor> ts_desc;
if (!peer.has_permanent_uuid()) {
return Status::InvalidArgument("Missing UUID for peer", peer.ShortDebugString());
@@ -1635,11 +1634,11 @@ Status CatalogManager::ResetTabletReplicasFromReportedConfig(
if (FLAGS_master_tombstone_evicted_tablet_replicas) {
unordered_set<string> current_member_uuids;
- BOOST_FOREACH(const consensus::RaftPeerPB& peer, cstate.config().peers()) {
+ for (const consensus::RaftPeerPB& peer : cstate.config().peers()) {
InsertOrDie(¤t_member_uuids, peer.permanent_uuid());
}
// Send a DeleteTablet() request to peers that are not in the new config.
- BOOST_FOREACH(const consensus::RaftPeerPB& prev_peer, prev_cstate.config().peers()) {
+ for (const consensus::RaftPeerPB& prev_peer : prev_cstate.config().peers()) {
const string& peer_uuid = prev_peer.permanent_uuid();
if (!ContainsKey(current_member_uuids, peer_uuid)) {
shared_ptr<TSDescriptor> ts_desc;
@@ -1755,7 +1754,7 @@ class PickLeaderReplica : public TSPicker {
virtual Status PickReplica(TSDescriptor** ts_desc) OVERRIDE {
TabletInfo::ReplicaMap replica_locations;
tablet_->GetReplicaLocations(&replica_locations);
- BOOST_FOREACH(const TabletInfo::ReplicaMap::value_type& r, replica_locations) {
+ for (const TabletInfo::ReplicaMap::value_type& r : replica_locations) {
if (r.second.role == consensus::RaftPeerPB::LEADER) {
*ts_desc = r.second.ts_desc;
return Status::OK();
@@ -2264,7 +2263,7 @@ bool SelectRandomTSForReplica(const TSDescriptorVector& ts_descs,
const unordered_set<string>& exclude_uuids,
shared_ptr<TSDescriptor>* selection) {
TSDescriptorVector tablet_servers;
- BOOST_FOREACH(const shared_ptr<TSDescriptor>& ts, ts_descs) {
+ for (const shared_ptr<TSDescriptor>& ts : ts_descs) {
if (!ContainsKey(exclude_uuids, ts->permanent_uuid())) {
tablet_servers.push_back(ts);
}
@@ -2336,7 +2335,7 @@ bool AsyncAddServerTask::SendRequest(int attempt) {
// Select the replica we wish to add to the config.
// Do not include current members of the config.
unordered_set<string> replica_uuids;
- BOOST_FOREACH(const RaftPeerPB& peer, cstate_.config().peers()) {
+ for (const RaftPeerPB& peer : cstate_.config().peers()) {
InsertOrDie(&replica_uuids, peer.permanent_uuid());
}
TSDescriptorVector ts_descs;
@@ -2403,7 +2402,7 @@ void CatalogManager::SendAlterTableRequest(const scoped_refptr<TableInfo>& table
vector<scoped_refptr<TabletInfo> > tablets;
table->GetAllTablets(&tablets);
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets) {
SendAlterTabletRequest(tablet);
}
}
@@ -2420,12 +2419,12 @@ void CatalogManager::DeleteTabletsAndSendRequests(const scoped_refptr<TableInfo>
string deletion_msg = "Table deleted at " + LocalTimeAsString();
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets) {
TabletInfo::ReplicaMap locations;
tablet->GetReplicaLocations(&locations);
LOG(INFO) << "Sending DeleteTablet for " << locations.size()
<< " replicas of tablet " << tablet->tablet_id();
- BOOST_FOREACH(const TabletInfo::ReplicaMap::value_type& r, locations) {
+ for (const TabletInfo::ReplicaMap::value_type& r : locations) {
SendDeleteTabletRequest(tablet->tablet_id(), TABLET_DATA_DELETED,
boost::none, table, r.second.ts_desc, deletion_msg);
}
@@ -2488,7 +2487,7 @@ void CatalogManager::ExtractTabletsToProcess(
// or just a counter to avoid to take the lock and loop through the tablets
// if everything is "stable".
- BOOST_FOREACH(const TabletInfoMap::value_type& entry, tablet_map_) {
+ for (const TabletInfoMap::value_type& entry : tablet_map_) {
scoped_refptr<TabletInfo> tablet = entry.second;
TabletMetadataLock tablet_lock(tablet.get(), TabletMetadataLock::READ);
@@ -2633,7 +2632,7 @@ class ScopedTabletInfoCommitter {
// This method is not thread safe. Must be called by the same thread
// that would destroy this instance.
void Abort() {
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, *tablets_) {
+ for (const scoped_refptr<TabletInfo>& tablet : *tablets_) {
tablet->mutable_metadata()->AbortMutation();
}
aborted_ = true;
@@ -2642,7 +2641,7 @@ class ScopedTabletInfoCommitter {
// Commit the transactions.
~ScopedTabletInfoCommitter() {
if (PREDICT_TRUE(!aborted_)) {
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, *tablets_) {
+ for (const scoped_refptr<TabletInfo>& tablet : *tablets_) {
tablet->mutable_metadata()->CommitMutation();
}
}
@@ -2660,7 +2659,7 @@ Status CatalogManager::ProcessPendingAssignments(
// Take write locks on all tablets to be processed, and ensure that they are
// unlocked at the end of this scope.
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets) {
tablet->mutable_metadata()->StartMutation();
}
ScopedTabletInfoCommitter unlocker_in(&tablets);
@@ -2676,7 +2675,7 @@ Status CatalogManager::ProcessPendingAssignments(
// Iterate over each of the tablets and handle it, whatever state
// it may be in. The actions required for the tablet are collected
// into 'deferred'.
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets) {
SysTabletsEntryPB::State t_state = tablet->metadata().state().pb.state();
switch (t_state) {
@@ -2707,7 +2706,7 @@ Status CatalogManager::ProcessPendingAssignments(
master_->ts_manager()->GetAllLiveDescriptors(&ts_descs);
Status s;
- BOOST_FOREACH(TabletInfo *tablet, deferred.needs_create_rpc) {
+ for (TabletInfo *tablet : deferred.needs_create_rpc) {
// NOTE: if we fail to select replicas on the first pass (due to
// insufficient Tablet Servers being online), we will still try
// again unless the tablet/table creation is cancelled.
@@ -2734,7 +2733,7 @@ Status CatalogManager::ProcessPendingAssignments(
// If there was an error, abort any mutations started by the
// current task.
vector<string> tablet_ids_to_remove;
- BOOST_FOREACH(scoped_refptr<TabletInfo>& new_tablet, new_tablets) {
+ for (scoped_refptr<TabletInfo>& new_tablet : new_tablets) {
TableInfo* table = new_tablet->table().get();
TableMetadataLock l_table(table, TableMetadataLock::WRITE);
if (table->RemoveTablet(new_tablet->tablet_id())) {
@@ -2746,7 +2745,7 @@ Status CatalogManager::ProcessPendingAssignments(
boost::lock_guard<LockType> l(lock_);
unlocker_out.Abort();
unlocker_in.Abort();
- BOOST_FOREACH(const string& tablet_id_to_remove, tablet_ids_to_remove) {
+ for (const string& tablet_id_to_remove : tablet_ids_to_remove) {
CHECK_EQ(tablet_map_.erase(tablet_id_to_remove), 1)
<< "Unable to erase " << tablet_id_to_remove << " from tablet map.";
}
@@ -2794,11 +2793,11 @@ Status CatalogManager::SelectReplicasForTablet(const TSDescriptorVector& ts_desc
}
void CatalogManager::SendCreateTabletRequests(const vector<TabletInfo*>& tablets) {
- BOOST_FOREACH(TabletInfo *tablet, tablets) {
+ for (TabletInfo *tablet : tablets) {
const consensus::RaftConfigPB& config =
tablet->metadata().dirty().pb.committed_consensus_state().config();
tablet->set_last_update_time(MonoTime::Now(MonoTime::FINE));
- BOOST_FOREACH(const RaftPeerPB& peer, config.peers()) {
+ for (const RaftPeerPB& peer : config.peers()) {
AsyncCreateReplica* task = new AsyncCreateReplica(master_, worker_pool_.get(),
peer.permanent_uuid(), tablet);
tablet->table()->AddTask(task);
@@ -2832,7 +2831,7 @@ void CatalogManager::SelectReplicas(const TSDescriptorVector& ts_descs,
peer->set_permanent_uuid(ts->permanent_uuid());
// TODO: This is temporary, we will use only UUIDs
- BOOST_FOREACH(const HostPortPB& addr, reg.rpc_addresses()) {
+ for (const HostPortPB& addr : reg.rpc_addresses()) {
peer->mutable_last_known_addr()->CopyFrom(addr);
}
}
@@ -2867,7 +2866,7 @@ Status CatalogManager::BuildLocationsForTablet(const scoped_refptr<TabletInfo>&
// If the locations are cached.
if (!locs.empty()) {
- BOOST_FOREACH(const TabletInfo::ReplicaMap::value_type& replica, locs) {
+ for (const TabletInfo::ReplicaMap::value_type& replica : locs) {
TabletLocationsPB_ReplicaPB* replica_pb = locs_pb->add_replicas();
replica_pb->set_role(replica.second.role);
@@ -2883,7 +2882,7 @@ Status CatalogManager::BuildLocationsForTablet(const scoped_refptr<TabletInfo>&
// If the locations were not cached.
// TODO: Why would this ever happen? See KUDU-759.
if (cstate.IsInitialized()) {
- BOOST_FOREACH(const consensus::RaftPeerPB& peer, cstate.config().peers()) {
+ for (const consensus::RaftPeerPB& peer : cstate.config().peers()) {
TabletLocationsPB_ReplicaPB* replica_pb = locs_pb->add_replicas();
CHECK(peer.has_permanent_uuid()) << "Missing UUID: " << peer.ShortDebugString();
replica_pb->set_role(GetConsensusRole(peer.permanent_uuid(), cstate));
@@ -2956,7 +2955,7 @@ Status CatalogManager::GetTableLocations(const GetTableLocationsRequestPB* req,
TSRegistrationPB reg;
vector<TabletReplica> locs;
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets_in_range) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets_in_range) {
if (!BuildLocationsForTablet(tablet, resp->add_tablet_locations()).ok()) {
// Not running.
resp->mutable_tablet_locations()->RemoveLast();
@@ -2979,7 +2978,7 @@ void CatalogManager::DumpState(std::ostream* out) const {
}
*out << "Tables:\n";
- BOOST_FOREACH(const TableInfoMap::value_type& e, ids_copy) {
+ for (const TableInfoMap::value_type& e : ids_copy) {
TableInfo* t = e.second.get();
TableMetadataLock l(t, TableMetadataLock::READ);
const string& name = l.data().name();
@@ -2998,7 +2997,7 @@ void CatalogManager::DumpState(std::ostream* out) const {
vector<scoped_refptr<TabletInfo> > table_tablets;
t->GetAllTablets(&table_tablets);
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, table_tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : table_tablets) {
TabletMetadataLock l_tablet(tablet.get(), TabletMetadataLock::READ);
*out << " " << tablet->tablet_id() << ": "
<< l_tablet.data().pb.ShortDebugString() << "\n";
@@ -3011,7 +3010,7 @@ void CatalogManager::DumpState(std::ostream* out) const {
if (!tablets_copy.empty()) {
*out << "Orphaned tablets (not referenced by any table):\n";
- BOOST_FOREACH(const TabletInfoMap::value_type& entry, tablets_copy) {
+ for (const TabletInfoMap::value_type& entry : tablets_copy) {
const scoped_refptr<TabletInfo>& tablet = entry.second;
TabletMetadataLock l_tablet(tablet.get(), TabletMetadataLock::READ);
*out << " " << tablet->tablet_id() << ": "
@@ -3021,7 +3020,7 @@ void CatalogManager::DumpState(std::ostream* out) const {
if (!names_copy.empty()) {
*out << "Orphaned tables (in by-name map, but not id map):\n";
- BOOST_FOREACH(const TableInfoMap::value_type& e, names_copy) {
+ for (const TableInfoMap::value_type& e : names_copy) {
*out << e.second->id() << ":\n";
*out << " name: \"" << CHexEscape(e.first) << "\"\n";
}
@@ -3131,7 +3130,7 @@ void TableInfo::AddTablet(TabletInfo *tablet) {
void TableInfo::AddTablets(const vector<TabletInfo*>& tablets) {
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(TabletInfo *tablet, tablets) {
+ for (TabletInfo *tablet : tablets) {
AddTabletUnlocked(tablet);
}
}
@@ -3176,7 +3175,7 @@ void TableInfo::GetTabletsInRange(const GetTableLocationsRequestPB* req,
bool TableInfo::IsAlterInProgress(uint32_t version) const {
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(const TableInfo::TabletInfoMap::value_type& e, tablet_map_) {
+ for (const TableInfo::TabletInfoMap::value_type& e : tablet_map_) {
if (e.second->reported_schema_version() < version) {
VLOG(3) << "Table " << table_id_ << " ALTER in progress due to tablet "
<< e.second->ToString() << " because reported schema "
@@ -3189,7 +3188,7 @@ bool TableInfo::IsAlterInProgress(uint32_t version) const {
bool TableInfo::IsCreateInProgress() const {
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(const TableInfo::TabletInfoMap::value_type& e, tablet_map_) {
+ for (const TableInfo::TabletInfoMap::value_type& e : tablet_map_) {
TabletMetadataLock tablet_lock(e.second, TabletMetadataLock::READ);
if (!tablet_lock.data().is_running()) {
return true;
@@ -3212,7 +3211,7 @@ void TableInfo::RemoveTask(MonitoredTask* task) {
void TableInfo::AbortTasks() {
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(MonitoredTask* task, pending_tasks_) {
+ for (MonitoredTask* task : pending_tasks_) {
task->Abort();
}
}
@@ -3233,7 +3232,7 @@ void TableInfo::WaitTasksCompletion() {
void TableInfo::GetTaskList(std::vector<scoped_refptr<MonitoredTask> > *ret) {
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(MonitoredTask* task, pending_tasks_) {
+ for (MonitoredTask* task : pending_tasks_) {
ret->push_back(make_scoped_refptr(task));
}
}
@@ -3241,7 +3240,7 @@ void TableInfo::GetTaskList(std::vector<scoped_refptr<MonitoredTask> > *ret) {
void TableInfo::GetAllTablets(vector<scoped_refptr<TabletInfo> > *ret) const {
ret->clear();
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(const TableInfo::TabletInfoMap::value_type& e, tablet_map_) {
+ for (const TableInfo::TabletInfoMap::value_type& e : tablet_map_) {
ret->push_back(make_scoped_refptr(e.second));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master-path-handlers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-path-handlers.cc b/src/kudu/master/master-path-handlers.cc
index e44f89d..e71c5ce 100644
--- a/src/kudu/master/master-path-handlers.cc
+++ b/src/kudu/master/master-path-handlers.cc
@@ -19,7 +19,6 @@
#include <algorithm>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <map>
#include <string>
#include <vector>
@@ -64,7 +63,7 @@ void MasterPathHandlers::HandleTabletServers(const Webserver::WebRequest& req,
*output << "<table class='table table-striped'>\n";
*output << " <tr><th>UUID</th><th>Time since heartbeat</th><th>Registration</th></tr>\n";
- BOOST_FOREACH(const std::shared_ptr<TSDescriptor>& desc, descs) {
+ for (const std::shared_ptr<TSDescriptor>& desc : descs) {
const string time_since_hb = StringPrintf("%.1fs", desc->TimeSinceHeartbeat().ToSeconds());
TSRegistrationPB reg;
desc->GetRegistration(®);
@@ -87,7 +86,7 @@ void MasterPathHandlers::HandleCatalogManager(const Webserver::WebRequest& req,
*output << " <tr><th>Table Name</th><th>Table Id</th><th>State</th></tr>\n";
typedef std::map<string, string> StringMap;
StringMap ordered_tables;
- BOOST_FOREACH(const scoped_refptr<TableInfo>& table, tables) {
+ for (const scoped_refptr<TableInfo>& table : tables) {
TableMetadataLock l(table.get(), TableMetadataLock::READ);
if (!l.data().is_running()) {
continue;
@@ -101,7 +100,7 @@ void MasterPathHandlers::HandleCatalogManager(const Webserver::WebRequest& req,
state,
EscapeForHtmlToString(l.data().pb.state_msg()));
}
- BOOST_FOREACH(const StringMap::value_type& table, ordered_tables) {
+ for (const StringMap::value_type& table : ordered_tables) {
*output << table.second;
}
*output << "</table>\n";
@@ -167,7 +166,7 @@ void MasterPathHandlers::HandleTablePage(const Webserver::WebRequest& req,
*output << "<table class='table table-striped'>\n";
*output << " <tr><th>Tablet ID</th><th>Partition</th><th>State</th>"
"<th>Message</th><th>RaftConfig</th></tr>\n";
- BOOST_FOREACH(const scoped_refptr<TabletInfo>& tablet, tablets) {
+ for (const scoped_refptr<TabletInfo>& tablet : tablets) {
TabletInfo::ReplicaMap locations;
tablet->GetReplicaLocations(&locations);
vector<TabletReplica> sorted_locations;
@@ -196,7 +195,7 @@ void MasterPathHandlers::HandleTablePage(const Webserver::WebRequest& req,
string master_addresses;
if (master_->opts().IsDistributed()) {
vector<string> all_addresses;
- BOOST_FOREACH(const HostPort& hp, master_->opts().master_addresses) {
+ for (const HostPort& hp : master_->opts().master_addresses) {
master_addresses.append(hp.ToString());
}
master_addresses = JoinElements(all_addresses, ",");
@@ -232,7 +231,7 @@ void MasterPathHandlers::HandleMasters(const Webserver::WebRequest& req,
*output << "<table class='table table-striped'>\n";
*output << " <tr><th>Registration</th><th>Role</th></tr>\n";
- BOOST_FOREACH(const ServerEntryPB& master, masters) {
+ for (const ServerEntryPB& master : masters) {
if (master.has_error()) {
Status error = StatusFromPB(master.error());
*output << Substitute(" <tr><td colspan=2><font color='red'><b>$0</b></font></td></tr>\n",
@@ -316,7 +315,7 @@ class JsonDumper : public TableVisitor, public TabletVisitor {
const consensus::ConsensusStatePB& cs = metadata.committed_consensus_state();
jw_->String("replicas");
jw_->StartArray();
- BOOST_FOREACH(const RaftPeerPB& peer, cs.config().peers()) {
+ for (const RaftPeerPB& peer : cs.config().peers()) {
jw_->StartObject();
jw_->String("type");
jw_->String(RaftPeerPB::MemberType_Name(peer.member_type()));
@@ -410,7 +409,7 @@ string MasterPathHandlers::RaftConfigToHtml(const std::vector<TabletReplica>& lo
stringstream html;
html << "<ul>\n";
- BOOST_FOREACH(const TabletReplica& location, locations) {
+ for (const TabletReplica& location : locations) {
string location_html = TSDescriptorToHtml(*location.ts_desc, tablet_id);
if (location.role == RaftPeerPB::LEADER) {
html << Substitute(" <li><b>LEADER: $0</b></li>\n", location_html);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-test-util.h b/src/kudu/master/master-test-util.h
index 044df60..d74bbb9 100644
--- a/src/kudu/master/master-test-util.h
+++ b/src/kudu/master/master-test-util.h
@@ -49,7 +49,7 @@ Status WaitForRunningTabletCount(MiniMaster* mini_master,
RETURN_NOT_OK(mini_master->master()->catalog_manager()->GetTableLocations(&req, resp));
if (resp->tablet_locations_size() >= expected_count) {
bool is_stale = false;
- BOOST_FOREACH(const TabletLocationsPB& loc, resp->tablet_locations()) {
+ for (const TabletLocationsPB& loc : resp->tablet_locations()) {
is_stale |= loc.stale();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc
index 334e4fd..9abf32f 100644
--- a/src/kudu/master/master-test.cc
+++ b/src/kudu/master/master-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <algorithm>
@@ -234,7 +233,7 @@ Status MasterTest::CreateTable(const string& table_name,
req.set_name(table_name);
RETURN_NOT_OK(SchemaToPB(schema, req.mutable_schema()));
RowOperationsPBEncoder encoder(req.mutable_split_rows());
- BOOST_FOREACH(const KuduPartialRow& row, split_rows) {
+ for (const KuduPartialRow& row : split_rows) {
encoder.Add(RowOperationsPB::SPLIT_ROW, row);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master.cc b/src/kudu/master/master.cc
index 45e553f..6efa1ff 100644
--- a/src/kudu/master/master.cc
+++ b/src/kudu/master/master.cc
@@ -19,7 +19,6 @@
#include <algorithm>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <list>
#include <memory>
@@ -226,7 +225,7 @@ Status Master::ListMasters(std::vector<ServerEntryPB>* masters) const {
return Status::OK();
}
- BOOST_FOREACH(const HostPort& peer_addr, opts_.master_addresses) {
+ for (const HostPort& peer_addr : opts_.master_addresses) {
ServerEntryPB peer_entry;
Status s = GetMasterEntryForHost(messenger_, peer_addr, &peer_entry);
if (!s.ok()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master_rpc.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_rpc.cc b/src/kudu/master/master_rpc.cc
index 0b41dd2..8e71608 100644
--- a/src/kudu/master/master_rpc.cc
+++ b/src/kudu/master/master_rpc.cc
@@ -20,7 +20,6 @@
#include "kudu/master/master_rpc.h"
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include "kudu/common/wire_protocol.h"
#include "kudu/common/wire_protocol.pb.h"
@@ -128,7 +127,7 @@ GetLeaderMasterRpc::~GetLeaderMasterRpc() {
string GetLeaderMasterRpc::ToString() const {
vector<string> sockaddr_str;
- BOOST_FOREACH(const Sockaddr& addr, addrs_) {
+ for (const Sockaddr& addr : addrs_) {
sockaddr_str.push_back(addr.ToString());
}
return strings::Substitute("GetLeaderMasterRpc(addrs: $0, num_attempts: $1)",
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/master_service.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master_service.cc b/src/kudu/master/master_service.cc
index 127641c..329a786 100644
--- a/src/kudu/master/master_service.cc
+++ b/src/kudu/master/master_service.cc
@@ -17,7 +17,6 @@
#include "kudu/master/master_service.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <memory>
#include <string>
@@ -217,7 +216,7 @@ void MasterServiceImpl::GetTabletLocations(const GetTabletLocationsRequestPB* re
TSRegistrationPB reg;
vector<TSDescriptor*> locs;
- BOOST_FOREACH(const string& tablet_id, req->tablet_ids()) {
+ for (const string& tablet_id : req->tablet_ids()) {
// TODO: once we have catalog data. ACL checks would also go here, probably.
TabletLocationsPB* locs_pb = resp->add_tablet_locations();
Status s = server_->catalog_manager()->GetTabletLocations(tablet_id, locs_pb);
@@ -340,7 +339,7 @@ void MasterServiceImpl::ListTabletServers(const ListTabletServersRequestPB* req,
vector<std::shared_ptr<TSDescriptor> > descs;
server_->ts_manager()->GetAllDescriptors(&descs);
- BOOST_FOREACH(const std::shared_ptr<TSDescriptor>& desc, descs) {
+ for (const std::shared_ptr<TSDescriptor>& desc : descs) {
ListTabletServersResponsePB::Entry* entry = resp->add_servers();
desc->GetNodeInstancePB(entry->mutable_instance_id());
desc->GetRegistration(entry->mutable_registration());
@@ -358,7 +357,7 @@ void MasterServiceImpl::ListMasters(const ListMastersRequestPB* req,
StatusToPB(s, resp->mutable_error());
resp->mutable_error()->set_code(AppStatusPB::UNKNOWN_ERROR);
} else {
- BOOST_FOREACH(const ServerEntryPB& master, masters) {
+ for (const ServerEntryPB& master : masters) {
resp->add_masters()->CopyFrom(master);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/mini_master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/mini_master.cc b/src/kudu/master/mini_master.cc
index f8f5630..7881135 100644
--- a/src/kudu/master/mini_master.cc
+++ b/src/kudu/master/mini_master.cc
@@ -101,7 +101,7 @@ Status MiniMaster::StartDistributedMasterOnPorts(uint16_t rpc_port, uint16_t web
MasterOptions opts;
vector<HostPort> peer_addresses;
- BOOST_FOREACH(uint16_t peer_port, peer_ports) {
+ for (uint16_t peer_port : peer_ports) {
HostPort peer_address("127.0.0.1", peer_port);
peer_addresses.push_back(peer_address);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/sys_catalog-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/sys_catalog-test.cc b/src/kudu/master/sys_catalog-test.cc
index 51eb737..165a328 100644
--- a/src/kudu/master/sys_catalog-test.cc
+++ b/src/kudu/master/sys_catalog-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <algorithm>
@@ -78,7 +77,7 @@ class TableLoader : public TableVisitor {
~TableLoader() { Reset(); }
void Reset() {
- BOOST_FOREACH(TableInfo* ti, tables) {
+ for (TableInfo* ti : tables) {
ti->Release();
}
tables.clear();
@@ -201,7 +200,7 @@ class TabletLoader : public TabletVisitor {
~TabletLoader() { Reset(); }
void Reset() {
- BOOST_FOREACH(TabletInfo* ti, tablets) {
+ for (TabletInfo* ti : tablets) {
ti->Release();
}
tablets.clear();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/sys_catalog.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/sys_catalog.cc b/src/kudu/master/sys_catalog.cc
index 6db9c67..c8b6d55 100644
--- a/src/kudu/master/sys_catalog.cc
+++ b/src/kudu/master/sys_catalog.cc
@@ -175,7 +175,7 @@ Status SysCatalogTable::SetupDistributedConfig(const MasterOptions& options,
new_config.set_opid_index(consensus::kInvalidOpIdIndex);
// Build the set of followers from our server options.
- BOOST_FOREACH(const HostPort& host_port, options.master_addresses) {
+ for (const HostPort& host_port : options.master_addresses) {
RaftPeerPB peer;
HostPortPB peer_host_port_pb;
RETURN_NOT_OK(HostPortToPB(host_port, &peer_host_port_pb));
@@ -190,7 +190,7 @@ Status SysCatalogTable::SetupDistributedConfig(const MasterOptions& options,
DCHECK(master_->messenger());
RaftConfigPB resolved_config = new_config;
resolved_config.clear_peers();
- BOOST_FOREACH(const RaftPeerPB& peer, new_config.peers()) {
+ for (const RaftPeerPB& peer : new_config.peers()) {
if (peer.has_permanent_uuid()) {
resolved_config.add_peers()->CopyFrom(peer);
} else {
@@ -326,7 +326,7 @@ Status SysCatalogTable::SyncWrite(const WriteRequestPB *req, WriteResponsePB *re
return StatusFromPB(resp->error().status());
}
if (resp->per_row_errors_size() > 0) {
- BOOST_FOREACH(const WriteResponsePB::PerRowErrorPB& error, resp->per_row_errors()) {
+ for (const WriteResponsePB::PerRowErrorPB& error : resp->per_row_errors()) {
LOG(WARNING) << "row " << error.row_index() << ": " << StatusFromPB(error.error()).ToString();
}
return Status::Corruption("One or more rows failed to write");
@@ -484,7 +484,7 @@ Status SysCatalogTable::AddTabletsToPB(const vector<TabletInfo*>& tablets,
faststring metadata_buf;
KuduPartialRow row(&schema_);
RowOperationsPBEncoder enc(ops);
- BOOST_FOREACH(const TabletInfo *tablet, tablets) {
+ for (const TabletInfo *tablet : tablets) {
if (!pb_util::SerializeToString(tablet->metadata().dirty().pb, &metadata_buf)) {
return Status::Corruption("Unable to serialize SysCatalogTabletsEntryPB for tablet",
tablet->tablet_id());
@@ -545,7 +545,7 @@ Status SysCatalogTable::DeleteTablets(const vector<TabletInfo*>& tablets) {
RowOperationsPBEncoder enc(req.mutable_row_operations());
KuduPartialRow row(&schema_);
- BOOST_FOREACH(const TabletInfo* tablet, tablets) {
+ for (const TabletInfo* tablet : tablets) {
CHECK_OK(row.SetInt8(kSysCatalogTableColType, TABLETS_ENTRY));
CHECK_OK(row.SetString(kSysCatalogTableColId, tablet->tablet_id()));
enc.Add(RowOperationsPB::DELETE, row);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/ts_descriptor.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_descriptor.cc b/src/kudu/master/ts_descriptor.cc
index ba8a274..a4d315e 100644
--- a/src/kudu/master/ts_descriptor.cc
+++ b/src/kudu/master/ts_descriptor.cc
@@ -23,7 +23,6 @@
#include "kudu/tserver/tserver_admin.proxy.h"
#include "kudu/util/net/net_util.h"
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
@@ -124,7 +123,7 @@ Status TSDescriptor::ResolveSockaddr(Sockaddr* addr) const {
vector<HostPort> hostports;
{
boost::lock_guard<simple_spinlock> l(lock_);
- BOOST_FOREACH(const HostPortPB& addr, registration_->rpc_addresses()) {
+ for (const HostPortPB& addr : registration_->rpc_addresses()) {
hostports.push_back(HostPort(addr.host(), addr.port()));
}
}
@@ -132,7 +131,7 @@ Status TSDescriptor::ResolveSockaddr(Sockaddr* addr) const {
// Resolve DNS outside the lock.
HostPort last_hostport;
vector<Sockaddr> addrs;
- BOOST_FOREACH(const HostPort& hostport, hostports) {
+ for (const HostPort& hostport : hostports) {
RETURN_NOT_OK(hostport.ResolveAddresses(&addrs));
if (!addrs.empty()) {
last_hostport = hostport;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/master/ts_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/ts_manager.cc b/src/kudu/master/ts_manager.cc
index 150cae2..1b5e140 100644
--- a/src/kudu/master/ts_manager.cc
+++ b/src/kudu/master/ts_manager.cc
@@ -17,7 +17,6 @@
#include "kudu/master/ts_manager.h"
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
#include <vector>
@@ -103,7 +102,7 @@ void TSManager::GetAllLiveDescriptors(vector<shared_ptr<TSDescriptor> > *descs)
boost::shared_lock<rw_spinlock> l(lock_);
descs->reserve(servers_by_id_.size());
- BOOST_FOREACH(const TSDescriptorMap::value_type& entry, servers_by_id_) {
+ for (const TSDescriptorMap::value_type& entry : servers_by_id_) {
const shared_ptr<TSDescriptor>& ts = entry.second;
if (ts->TimeSinceHeartbeat().ToMilliseconds() < FLAGS_tserver_unresponsive_timeout_ms) {
descs->push_back(ts);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/acceptor_pool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/acceptor_pool.cc b/src/kudu/rpc/acceptor_pool.cc
index a144152..6ceb7fe 100644
--- a/src/kudu/rpc/acceptor_pool.cc
+++ b/src/kudu/rpc/acceptor_pool.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/acceptor_pool.h"
-#include <boost/foreach.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <inttypes.h>
@@ -104,12 +103,12 @@ void AcceptorPool::Shutdown() {
// Calling shutdown on an accepting (non-connected) socket is illegal on most
// platforms (but not Linux). Instead, the accepting threads are interrupted
// forcefully.
- BOOST_FOREACH(const scoped_refptr<kudu::Thread>& thread, threads_) {
+ for (const scoped_refptr<kudu::Thread>& thread : threads_) {
pthread_cancel(thread.get()->pthread_id());
}
#endif
- BOOST_FOREACH(const scoped_refptr<kudu::Thread>& thread, threads_) {
+ for (const scoped_refptr<kudu::Thread>& thread : threads_) {
CHECK_OK(ThreadJoiner(thread.get()).Join());
}
threads_.clear();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/rpc/connection.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/connection.cc b/src/kudu/rpc/connection.cc
index 738f501..6478029 100644
--- a/src/kudu/rpc/connection.cc
+++ b/src/kudu/rpc/connection.cc
@@ -17,7 +17,6 @@
#include "kudu/rpc/connection.h"
-#include <boost/foreach.hpp>
#include <boost/intrusive/list.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
@@ -142,7 +141,7 @@ void Connection::Shutdown(const Status &status) {
}
// Clear any calls which have been sent and were awaiting a response.
- BOOST_FOREACH(const car_map_t::value_type &v, awaiting_response_) {
+ for (const car_map_t::value_type &v : awaiting_response_) {
CallAwaitingResponse *c = v.second;
if (c->call) {
c->call->SetFailed(status);
@@ -602,14 +601,14 @@ Status Connection::DumpPB(const DumpRunningRpcsRequestPB& req,
}
if (direction_ == CLIENT) {
- BOOST_FOREACH(const car_map_t::value_type& entry, awaiting_response_) {
+ for (const car_map_t::value_type& entry : awaiting_response_) {
CallAwaitingResponse *c = entry.second;
if (c->call) {
c->call->DumpPB(req, resp->add_calls_in_flight());
}
}
} else if (direction_ == SERVER) {
- BOOST_FOREACH(const inbound_call_map_t::value_type& entry, calls_being_handled_) {
+ for (const inbound_call_map_t::value_type& entry : calls_being_handled_) {
InboundCall* c = entry.second;
c->DumpPB(req, resp->add_calls_in_flight());
}
[6/6] incubator-kudu git commit: Replace BOOST_FOREACH with c++11
range syntax
Posted by da...@apache.org.
Replace BOOST_FOREACH with c++11 range syntax
This was created using some scripts that Mike put together, along with some
manual tweaks.
Change-Id: I635ba6e83b65eec4427c10175c203c4864b2a22f
Reviewed-on: http://gerrit.cloudera.org:8080/1786
Reviewed-by: Adar Dembo <ad...@cloudera.com>
Tested-by: Internal Jenkins
Project: http://git-wip-us.apache.org/repos/asf/incubator-kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-kudu/commit/9daafa5e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-kudu/tree/9daafa5e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-kudu/diff/9daafa5e
Branch: refs/heads/master
Commit: 9daafa5e795f1a2fc0cf571285caddc06ffbc5da
Parents: 3eafca5
Author: Dan Burkert <da...@cloudera.com>
Authored: Fri Nov 20 17:40:13 2015 -0800
Committer: Dan Burkert <da...@cloudera.com>
Committed: Fri Jan 15 19:59:28 2016 +0000
----------------------------------------------------------------------
docs/contributing.adoc | 5 +-
.../benchmarks/tpch/rpc_line_item_dao-test.cc | 5 +-
src/kudu/benchmarks/tpch/rpc_line_item_dao.cc | 5 +-
src/kudu/benchmarks/tpch/tpch1.cc | 3 +-
src/kudu/benchmarks/tpch/tpch_real_world.cc | 3 +-
src/kudu/benchmarks/wal_hiccup.cc | 5 +-
src/kudu/cfile/binary_prefix_block.cc | 3 +-
src/kudu/cfile/block_compression.cc | 3 +-
src/kudu/cfile/cfile_reader.cc | 13 ++-
src/kudu/cfile/cfile_writer.cc | 7 +-
src/kudu/cfile/compression_codec.cc | 5 +-
src/kudu/cfile/encoding-test.cc | 1 -
src/kudu/cfile/index_block.cc | 3 +-
src/kudu/cfile/mt-bloomfile-test.cc | 2 +-
src/kudu/client/batcher.cc | 18 ++--
src/kudu/client/client-internal.cc | 13 ++-
src/kudu/client/client-test-util.cc | 5 +-
src/kudu/client/client-test.cc | 29 +++---
src/kudu/client/client.cc | 16 ++--
src/kudu/client/meta_cache.cc | 25 +++---
src/kudu/client/scanner-internal.cc | 2 +-
src/kudu/client/schema.cc | 9 +-
src/kudu/client/table_alterer-internal.cc | 5 +-
src/kudu/client/table_creator-internal.cc | 1 -
src/kudu/codegen/codegen-test.cc | 3 +-
src/kudu/codegen/module_builder.cc | 7 +-
src/kudu/codegen/row_projector.cc | 15 ++--
src/kudu/common/generic_iterators.cc | 35 ++++----
src/kudu/common/partition-test.cc | 4 +-
src/kudu/common/partition.cc | 56 ++++++------
src/kudu/common/predicate_encoder.cc | 2 +-
src/kudu/common/rowblock.cc | 4 +-
src/kudu/common/scan_spec.cc | 2 +-
src/kudu/common/schema-test.cc | 2 +-
src/kudu/common/schema.cc | 20 ++---
src/kudu/common/schema.h | 1 -
src/kudu/common/wire_protocol.cc | 8 +-
src/kudu/consensus/consensus-test-util.h | 1 -
src/kudu/consensus/consensus.cc | 1 -
src/kudu/consensus/consensus_meta-test.cc | 3 +-
src/kudu/consensus/consensus_queue.cc | 25 +++---
src/kudu/consensus/leader_election-test.cc | 7 +-
src/kudu/consensus/leader_election.cc | 5 +-
src/kudu/consensus/local_consensus.cc | 2 +-
src/kudu/consensus/log-dump.cc | 7 +-
src/kudu/consensus/log-test-base.h | 7 +-
src/kudu/consensus/log-test.cc | 11 ++-
src/kudu/consensus/log.cc | 16 ++--
src/kudu/consensus/log_anchor_registry.cc | 3 +-
src/kudu/consensus/log_cache.cc | 9 +-
src/kudu/consensus/log_index.cc | 3 +-
src/kudu/consensus/log_reader.cc | 13 ++-
src/kudu/consensus/log_util.cc | 5 +-
src/kudu/consensus/mt-log-test.cc | 6 +-
src/kudu/consensus/peer_manager.cc | 4 +-
src/kudu/consensus/quorum_util.cc | 15 ++--
src/kudu/consensus/raft_consensus-test.cc | 2 +-
src/kudu/consensus/raft_consensus.cc | 4 +-
.../consensus/raft_consensus_quorum-test.cc | 23 +++--
src/kudu/consensus/raft_consensus_state-test.cc | 1 -
src/kudu/consensus/raft_consensus_state.cc | 3 +-
src/kudu/experiments/merge-test.cc | 5 +-
src/kudu/experiments/rwlock-perf.cc | 3 +-
src/kudu/fs/block_id.cc | 3 +-
src/kudu/fs/block_manager-stress-test.cc | 9 +-
src/kudu/fs/block_manager-test.cc | 15 ++--
src/kudu/fs/block_manager.h | 3 +-
src/kudu/fs/block_manager_util-test.cc | 5 +-
src/kudu/fs/block_manager_util.cc | 5 +-
src/kudu/fs/file_block_manager.cc | 23 +++--
src/kudu/fs/fs_manager-test.cc | 2 +-
src/kudu/fs/fs_manager.cc | 31 ++++---
src/kudu/fs/log_block_manager.cc | 31 ++++---
src/kudu/integration-tests/all_types-itest.cc | 10 +--
.../alter_table-randomized-test.cc | 9 +-
src/kudu/integration-tests/alter_table-test.cc | 5 +-
.../integration-tests/client-stress-test.cc | 3 +-
.../integration-tests/cluster_itest_util.cc | 17 ++--
.../create-table-stress-test.cc | 4 +-
src/kudu/integration-tests/delete_table-test.cc | 7 +-
.../external_mini_cluster-test.cc | 1 -
.../integration-tests/external_mini_cluster.cc | 33 ++++---
.../external_mini_cluster_fs_inspector.cc | 11 ++-
.../flex_partitioning-itest.cc | 9 +-
.../full_stack-insert-scan-test.cc | 5 +-
.../integration-tests/linked_list-test-util.h | 17 ++--
src/kudu/integration-tests/linked_list-test.cc | 2 +-
src/kudu/integration-tests/mini_cluster.cc | 17 ++--
.../integration-tests/raft_consensus-itest.cc | 45 +++++-----
.../integration-tests/remote_bootstrap-itest.cc | 12 +--
src/kudu/integration-tests/test_workload.cc | 5 +-
src/kudu/integration-tests/ts_itest-base.h | 23 +++--
.../update_scan_delta_compact-test.cc | 4 +-
src/kudu/master/catalog_manager.cc | 93 ++++++++++----------
src/kudu/master/master-path-handlers.cc | 17 ++--
src/kudu/master/master-test-util.h | 2 +-
src/kudu/master/master-test.cc | 3 +-
src/kudu/master/master.cc | 3 +-
src/kudu/master/master_rpc.cc | 3 +-
src/kudu/master/master_service.cc | 7 +-
src/kudu/master/mini_master.cc | 2 +-
src/kudu/master/sys_catalog-test.cc | 5 +-
src/kudu/master/sys_catalog.cc | 10 +--
src/kudu/master/ts_descriptor.cc | 5 +-
src/kudu/master/ts_manager.cc | 3 +-
src/kudu/rpc/acceptor_pool.cc | 5 +-
src/kudu/rpc/connection.cc | 7 +-
src/kudu/rpc/inbound_call.cc | 5 +-
src/kudu/rpc/messenger.cc | 11 ++-
src/kudu/rpc/mt-rpc-test.cc | 2 +-
src/kudu/rpc/protoc-gen-krpc.cc | 11 ++-
src/kudu/rpc/reactor.cc | 9 +-
src/kudu/rpc/rpc-bench.cc | 3 +-
src/kudu/rpc/rpc-test.cc | 5 +-
src/kudu/rpc/rpc_stub-test.cc | 5 +-
src/kudu/rpc/sasl_client.cc | 3 +-
src/kudu/rpc/sasl_helper.cc | 1 -
src/kudu/rpc/sasl_server.cc | 3 +-
src/kudu/rpc/service_pool.cc | 3 +-
src/kudu/rpc/transfer.cc | 1 -
src/kudu/server/default-path-handlers.cc | 3 +-
src/kudu/server/hybrid_clock-test.cc | 3 +-
src/kudu/server/pprof-path-handlers.cc | 3 +-
src/kudu/server/rpc_server.cc | 13 ++-
src/kudu/server/server_base.cc | 5 +-
src/kudu/server/tracing-path-handlers.cc | 5 +-
src/kudu/server/webserver.cc | 13 ++-
src/kudu/server/webui_util.cc | 2 +-
src/kudu/tablet/cbtree-test.cc | 9 +-
src/kudu/tablet/cfile_set-test.cc | 4 +-
src/kudu/tablet/cfile_set.cc | 6 +-
src/kudu/tablet/compaction-test.cc | 10 +--
src/kudu/tablet/compaction.cc | 20 ++---
src/kudu/tablet/compaction_policy.cc | 9 +-
src/kudu/tablet/composite-pushdown-test.cc | 2 +-
src/kudu/tablet/delta_compaction-test.cc | 4 +-
src/kudu/tablet/delta_compaction.cc | 10 +--
src/kudu/tablet/delta_iterator_merger.cc | 20 ++---
src/kudu/tablet/delta_stats.cc | 8 +-
src/kudu/tablet/delta_store.cc | 4 +-
src/kudu/tablet/delta_tracker.cc | 20 ++---
src/kudu/tablet/deltafile-test.cc | 4 +-
src/kudu/tablet/deltafile.cc | 2 +-
src/kudu/tablet/deltamemstore-test.cc | 3 +-
src/kudu/tablet/deltamemstore.cc | 8 +-
src/kudu/tablet/diskrowset-test-base.h | 2 +-
src/kudu/tablet/diskrowset-test.cc | 6 +-
src/kudu/tablet/local_tablet_writer.h | 5 +-
src/kudu/tablet/lock_manager-test.cc | 11 ++-
src/kudu/tablet/maintenance_manager.cc | 7 +-
src/kudu/tablet/memrowset.cc | 3 +-
src/kudu/tablet/metadata-test.cc | 1 -
src/kudu/tablet/mt-diskrowset-test.cc | 3 +-
.../tablet/mt-rowset_delta_compaction-test.cc | 1 -
src/kudu/tablet/mt-tablet-test.cc | 3 +-
src/kudu/tablet/multi_column_writer.cc | 2 +-
src/kudu/tablet/mvcc.cc | 13 ++-
src/kudu/tablet/rowset.cc | 18 ++--
src/kudu/tablet/rowset_info.cc | 12 +--
src/kudu/tablet/rowset_metadata.cc | 22 ++---
src/kudu/tablet/rowset_tree-test.cc | 2 +-
src/kudu/tablet/rowset_tree.cc | 10 +--
src/kudu/tablet/svg_dump.cc | 9 +-
src/kudu/tablet/tablet-pushdown-test.cc | 6 +-
src/kudu/tablet/tablet-schema-test.cc | 4 +-
src/kudu/tablet/tablet-test-util.h | 4 +-
src/kudu/tablet/tablet.cc | 57 ++++++------
src/kudu/tablet/tablet_bootstrap-test.cc | 2 +-
src/kudu/tablet/tablet_bootstrap.cc | 27 +++---
src/kudu/tablet/tablet_metadata.cc | 28 +++---
src/kudu/tablet/tablet_mm_ops-test.cc | 2 +-
src/kudu/tablet/tablet_peer.cc | 6 +-
src/kudu/tablet/tablet_random_access-test.cc | 10 +--
.../transactions/transaction_tracker-test.cc | 6 +-
.../tablet/transactions/transaction_tracker.cc | 5 +-
.../tablet/transactions/write_transaction.cc | 6 +-
src/kudu/tools/fs_dump-tool.cc | 5 +-
src/kudu/tools/fs_list-tool.cc | 5 +-
src/kudu/tools/fs_tool.cc | 31 ++++---
src/kudu/tools/insert-generated-rows.cc | 3 +-
src/kudu/tools/ksck-test.cc | 3 +-
src/kudu/tools/ksck.cc | 27 +++---
src/kudu/tools/ksck_remote-test.cc | 2 +-
src/kudu/tools/ksck_remote.cc | 8 +-
src/kudu/tools/kudu-admin-test.cc | 3 +-
src/kudu/tools/kudu-admin.cc | 7 +-
src/kudu/tools/kudu-ksck.cc | 2 +-
src/kudu/tools/kudu-ts-cli-test.cc | 3 +-
src/kudu/tools/ts-cli.cc | 9 +-
src/kudu/tserver/heartbeater.cc | 3 +-
.../tserver/remote_bootstrap_client-test.cc | 12 +--
src/kudu/tserver/remote_bootstrap_client.cc | 12 +--
.../tserver/remote_bootstrap_service-test.cc | 5 +-
src/kudu/tserver/remote_bootstrap_service.cc | 11 ++-
.../tserver/remote_bootstrap_session-test.cc | 13 ++-
src/kudu/tserver/remote_bootstrap_session.cc | 4 +-
src/kudu/tserver/scanners.cc | 8 +-
src/kudu/tserver/tablet_server-stress-test.cc | 2 +-
src/kudu/tserver/tablet_server-test-base.h | 3 +-
src/kudu/tserver/tablet_server-test.cc | 6 +-
src/kudu/tserver/tablet_server.cc | 3 +-
src/kudu/tserver/tablet_service.cc | 10 +--
src/kudu/tserver/ts_tablet_manager-test.cc | 4 +-
src/kudu/tserver/ts_tablet_manager.cc | 12 +--
src/kudu/tserver/tserver-path-handlers.cc | 12 +--
src/kudu/twitter-demo/insert_consumer.cc | 3 +-
src/kudu/twitter-demo/oauth.cc | 5 +-
src/kudu/twitter-demo/parser-test.cc | 3 +-
src/kudu/util/atomic-test.cc | 11 ++-
src/kudu/util/blocking_queue.h | 5 +-
src/kudu/util/cache.cc | 3 +-
src/kudu/util/debug-util-test.cc | 3 +-
src/kudu/util/debug/trace_event_impl.cc | 7 +-
src/kudu/util/env-test.cc | 5 +-
src/kudu/util/env_posix.cc | 1 -
src/kudu/util/failure_detector.cc | 7 +-
src/kudu/util/flags.cc | 3 +-
src/kudu/util/interval_tree-inl.h | 12 +--
src/kudu/util/interval_tree-test.cc | 6 +-
src/kudu/util/interval_tree.h | 1 -
src/kudu/util/jsonreader-test.cc | 3 +-
src/kudu/util/jsonwriter.cc | 3 +-
src/kudu/util/kernel_stack_watchdog.cc | 3 +-
src/kudu/util/knapsack_solver-test.cc | 2 +-
src/kudu/util/knapsack_solver.h | 1 -
src/kudu/util/mem_tracker-test.cc | 3 +-
src/kudu/util/mem_tracker.cc | 9 +-
src/kudu/util/mem_tracker.h | 2 +-
src/kudu/util/memcmpable_varint-test.cc | 9 +-
src/kudu/util/memenv/memenv-test.cc | 3 +-
src/kudu/util/memenv/memenv.cc | 7 +-
src/kudu/util/memory/arena-test.cc | 5 +-
src/kudu/util/metrics.cc | 17 ++--
src/kudu/util/mt-metrics-test.cc | 1 -
src/kudu/util/mt-threadlocal-test.cc | 8 +-
src/kudu/util/net/dns_resolver-test.cc | 3 +-
src/kudu/util/net/net_util-test.cc | 5 +-
src/kudu/util/net/net_util.cc | 9 +-
src/kudu/util/nvm_cache.cc | 5 +-
src/kudu/util/once-test.cc | 3 +-
src/kudu/util/pb_util-test.cc | 3 +-
src/kudu/util/pb_util.cc | 3 +-
src/kudu/util/rolling_log-test.cc | 3 +-
src/kudu/util/rw_semaphore-test.cc | 3 +-
src/kudu/util/rwc_lock-test.cc | 3 +-
src/kudu/util/slice-test.cc | 3 +-
src/kudu/util/striped64-test.cc | 5 +-
src/kudu/util/subprocess.cc | 3 +-
src/kudu/util/sync_point.cc | 6 +-
src/kudu/util/test_graph.cc | 3 +-
src/kudu/util/thread.cc | 11 ++-
src/kudu/util/threadpool.cc | 3 +-
src/kudu/util/trace-test.cc | 5 +-
src/kudu/util/trace.cc | 5 +-
src/kudu/util/url-coding.cc | 3 +-
255 files changed, 944 insertions(+), 1127 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/docs/contributing.adoc
----------------------------------------------------------------------
diff --git a/docs/contributing.adoc b/docs/contributing.adoc
index d8b069c..4d8c96f 100644
--- a/docs/contributing.adoc
+++ b/docs/contributing.adoc
@@ -156,10 +156,9 @@ implementations.
.Approved `boost` Libraries
-- `BOOST_FOREACH`
- `boost::assign` (container literals)
-- `boost::mutex` and `boost::shared_mutex` (but prefer Kudu's
- spin lock implementation for short critical sections)
+- `boost::shared_mutex` (but prefer Kudu's spin lock implementation for short
+ critical sections)
Check that any features from `boost` you use are present in *`boost` 1.46*
or earlier, for compatibility with RHEL 6.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc b/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
index 9a03b22..b6a2f8e 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao-test.cc
@@ -17,7 +17,6 @@
#include <algorithm>
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <gflags/gflags.h>
#include <string>
@@ -116,7 +115,7 @@ class RpcLineItemDAOTest : public KuduTest {
vector<KuduRowResult> rows;
while (scanner->HasMore()) {
scanner->GetNext(&rows);
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
str_rows->push_back(row.ToString());
}
}
@@ -155,7 +154,7 @@ TEST_F(RpcLineItemDAOTest, TestUpdate) {
vector<KuduRowResult> rows;
while (scanner->HasMore()) {
scanner->GetNext(&rows);
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
int32_t l_quantity;
ASSERT_OK(row.GetInt32(0, &l_quantity));
ASSERT_EQ(12345, l_quantity);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
index b6dec1e..55e7d58 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/thread/locks.hpp>
#include <glog/logging.h>
#include <vector>
@@ -85,7 +84,7 @@ class FlushCallback : public KuduStatusCallback {
if (overflow) {
LOG(WARNING) << "Error overflow occured";
}
- BOOST_FOREACH(KuduError* error, errors) {
+ for (KuduError* error : errors) {
LOG(WARNING) << "FAILED: " << error->failed_op().ToString();
}
}
@@ -169,7 +168,7 @@ void RpcLineItemDAO::OpenScanner(const vector<string>& columns,
ret->scanner_.reset(new KuduScanner(client_table_.get()));
ret->scanner_->SetCacheBlocks(FLAGS_tpch_cache_blocks_when_scanning);
CHECK_OK(ret->scanner_->SetProjectedColumns(columns));
- BOOST_FOREACH(KuduPredicate* pred, preds) {
+ for (KuduPredicate* pred : preds) {
CHECK_OK(ret->scanner_->AddConjunctPredicate(pred));
}
CHECK_OK(ret->scanner_->Open());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/benchmarks/tpch/tpch1.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/tpch1.cc b/src/kudu/benchmarks/tpch/tpch1.cc
index 9188a32..b9675c9 100644
--- a/src/kudu/benchmarks/tpch/tpch1.cc
+++ b/src/kudu/benchmarks/tpch/tpch1.cc
@@ -57,7 +57,6 @@
// 'R','F',37719753,56568041380.90,53741292684.6,55889619119.8,25.5,38250.9,0.1,1478870
// ====
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <unordered_map>
#include <stdlib.h>
@@ -164,7 +163,7 @@ void Tpch1(RpcLineItemDAO *dao) {
vector<KuduRowResult> rows;
while (scanner->HasMore()) {
scanner->GetNext(&rows);
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
matching_rows++;
SliceMapKey l_returnflag;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/benchmarks/tpch/tpch_real_world.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/tpch_real_world.cc b/src/kudu/benchmarks/tpch/tpch_real_world.cc
index a2d0bf3..4e6a2e5 100644
--- a/src/kudu/benchmarks/tpch/tpch_real_world.cc
+++ b/src/kudu/benchmarks/tpch/tpch_real_world.cc
@@ -39,7 +39,6 @@
//
// TODO Make the inserts multi-threaded. See Kudu-629 for the technique.
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <stdlib.h>
@@ -370,7 +369,7 @@ Status TpchRealWorld::Run() {
stop_threads_.Store(true);
- BOOST_FOREACH(scoped_refptr<kudu::Thread> thr, threads) {
+ for (scoped_refptr<kudu::Thread> thr : threads) {
RETURN_NOT_OK(ThreadJoiner(thr.get()).Join());
}
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/benchmarks/wal_hiccup.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/wal_hiccup.cc b/src/kudu/benchmarks/wal_hiccup.cc
index 1f4e35c..e1525c8 100644
--- a/src/kudu/benchmarks/wal_hiccup.cc
+++ b/src/kudu/benchmarks/wal_hiccup.cc
@@ -16,7 +16,6 @@
// under the License.
#include <algorithm>
-#include <boost/foreach.hpp>
#include <vector>
#include <fcntl.h>
@@ -168,7 +167,7 @@ void WalHiccupBenchmarker::Run() {
// Randomize the order of setups in each round.
std::random_shuffle(setups.begin(), setups.end());
- BOOST_FOREACH(uint32_t setup, setups) {
+ for (uint32_t setup : setups) {
SetFlags(setup);
if (!FLAGS_fdatasync_each_file && !FLAGS_fdatasync_at_end) {
// Skip non-durable configuration
@@ -197,7 +196,7 @@ void WalHiccupBenchmarker::Run() {
LOG(INFO) << "----------------------------------------------------------------------";
}
- BOOST_FOREACH(uint32_t setup, setups) {
+ for (uint32_t setup : setups) {
SetFlags(setup);
if (!FLAGS_fdatasync_each_file && !FLAGS_fdatasync_at_end) {
// Skip non-durable configuration
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/binary_prefix_block.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/binary_prefix_block.cc b/src/kudu/cfile/binary_prefix_block.cc
index 8b06d59..a9e8da2 100644
--- a/src/kudu/cfile/binary_prefix_block.cc
+++ b/src/kudu/cfile/binary_prefix_block.cc
@@ -17,7 +17,6 @@
#include "kudu/cfile/binary_prefix_block.h"
-#include <boost/foreach.hpp>
#include <algorithm>
#include <string>
@@ -110,7 +109,7 @@ Slice BinaryPrefixBlockBuilder::Finish(rowid_t ordinal_pos) {
buffer_.reserve(buffer_.size()
+ restarts_.size() * sizeof(uint32_t) // the data
+ sizeof(uint32_t)); // the restart count);
- BOOST_FOREACH(uint32_t restart, restarts_) {
+ for (uint32_t restart : restarts_) {
DCHECK_GE(static_cast<int>(restart), header_offset);
uint32_t relative_to_block = restart - header_offset;
VLOG(2) << "appending restart " << relative_to_block;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/block_compression.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/block_compression.cc b/src/kudu/cfile/block_compression.cc
index ae7c275..61792b7 100644
--- a/src/kudu/cfile/block_compression.cc
+++ b/src/kudu/cfile/block_compression.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <algorithm>
@@ -44,7 +43,7 @@ Status CompressedBlockBuilder::Compress(const Slice& data, Slice *result) {
Status CompressedBlockBuilder::Compress(const vector<Slice> &data_slices, Slice *result) {
size_t data_size = 0;
- BOOST_FOREACH(const Slice& data, data_slices) {
+ for (const Slice& data : data_slices) {
data_size += data.size();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/cfile_reader.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile_reader.cc b/src/kudu/cfile/cfile_reader.cc
index 440b9cd..3378382 100644
--- a/src/kudu/cfile/cfile_reader.cc
+++ b/src/kudu/cfile/cfile_reader.cc
@@ -17,7 +17,6 @@
#include "kudu/cfile/cfile_reader.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <algorithm>
@@ -423,13 +422,13 @@ Status CFileReader::CountRows(rowid_t *count) const {
}
bool CFileReader::GetMetadataEntry(const string &key, string *val) {
- BOOST_FOREACH(const FileMetadataPairPB &pair, header().metadata()) {
+ for (const FileMetadataPairPB &pair : header().metadata()) {
if (pair.key() == key) {
*val = pair.value();
return true;
}
}
- BOOST_FOREACH(const FileMetadataPairPB &pair, footer().metadata()) {
+ for (const FileMetadataPairPB &pair : footer().metadata()) {
if (pair.key() == key) {
*val = pair.value();
return true;
@@ -708,7 +707,7 @@ Status CFileIterator::PrepareForNewSeek() {
}
seeked_ = NULL;
- BOOST_FOREACH(PreparedBlock *pb, prepared_blocks_) {
+ for (PreparedBlock *pb : prepared_blocks_) {
prepared_block_pool_.Destroy(pb);
}
prepared_blocks_.clear();
@@ -839,7 +838,7 @@ Status CFileIterator::PrepareBatch(size_t *n) {
if (PREDICT_FALSE(VLOG_IS_ON(1))) {
VLOG(1) << "Prepared for " << (*n) << " rows"
<< " (" << start_idx << "-" << (start_idx + *n - 1) << ")";
- BOOST_FOREACH(PreparedBlock *b, prepared_blocks_) {
+ for (PreparedBlock *b : prepared_blocks_) {
VLOG(1) << " " << b->ToString();
}
VLOG(1) << "-------------";
@@ -878,7 +877,7 @@ Status CFileIterator::FinishBatch() {
#ifndef NDEBUG
if (VLOG_IS_ON(1)) {
VLOG(1) << "Left around following blocks:";
- BOOST_FOREACH(PreparedBlock *b, prepared_blocks_) {
+ for (PreparedBlock *b : prepared_blocks_) {
VLOG(1) << " " << b->ToString();
}
VLOG(1) << "-------------";
@@ -900,7 +899,7 @@ Status CFileIterator::Scan(ColumnBlock *dst) {
uint32_t rem = last_prepare_count_;
DCHECK_LE(rem, dst->nrows());
- BOOST_FOREACH(PreparedBlock *pb, prepared_blocks_) {
+ for (PreparedBlock *pb : prepared_blocks_) {
if (pb->needs_rewind_) {
// Seek back to the saved position.
SeekToPositionInBlock(pb, pb->rewind_idx_);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/cfile_writer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile_writer.cc b/src/kudu/cfile/cfile_writer.cc
index 5acfdd0..caeda21 100644
--- a/src/kudu/cfile/cfile_writer.cc
+++ b/src/kudu/cfile/cfile_writer.cc
@@ -17,7 +17,6 @@
#include "kudu/cfile/cfile_writer.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <string>
#include <utility>
@@ -264,7 +263,7 @@ void CFileWriter::AddMetadataPair(const Slice &key, const Slice &value) {
string CFileWriter::GetMetaValueOrDie(Slice key) const {
typedef pair<string, string> ss_pair;
- BOOST_FOREACH(const ss_pair& entry, unflushed_metadata_) {
+ for (const ss_pair& entry : unflushed_metadata_) {
if (Slice(entry.first) == key) {
return entry.second;
}
@@ -274,7 +273,7 @@ string CFileWriter::GetMetaValueOrDie(Slice key) const {
void CFileWriter::FlushMetadataToPB(RepeatedPtrField<FileMetadataPairPB> *field) {
typedef pair<string, string> ss_pair;
- BOOST_FOREACH(const ss_pair &entry, unflushed_metadata_) {
+ for (const ss_pair &entry : unflushed_metadata_) {
FileMetadataPairPB *pb = field->Add();
pb->set_key(entry.first);
pb->set_value(entry.second);
@@ -457,7 +456,7 @@ Status CFileWriter::AddBlock(const vector<Slice> &data_slices,
RETURN_NOT_OK(WriteRawData(cdata));
} else {
// Write uncompressed block
- BOOST_FOREACH(const Slice &data, data_slices) {
+ for (const Slice &data : data_slices) {
RETURN_NOT_OK(WriteRawData(data));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/compression_codec.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/compression_codec.cc b/src/kudu/cfile/compression_codec.cc
index cb29802..2a66a79 100644
--- a/src/kudu/cfile/compression_codec.cc
+++ b/src/kudu/cfile/compression_codec.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <snappy-sinksource.h>
#include <snappy.h>
@@ -82,7 +81,7 @@ class SlicesSource : public snappy::Source {
void Dump(faststring *buffer) {
buffer->reserve(buffer->size() + TotalSize());
- BOOST_FOREACH(const Slice& block, slices_) {
+ for (const Slice& block : slices_) {
buffer->append(block.data(), block.size());
}
}
@@ -90,7 +89,7 @@ class SlicesSource : public snappy::Source {
private:
size_t TotalSize(void) const {
size_t size = 0;
- BOOST_FOREACH(const Slice& data, slices_) {
+ for (const Slice& data : slices_) {
size += data.size();
}
return size;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/encoding-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/encoding-test.cc b/src/kudu/cfile/encoding-test.cc
index 064fda2..051dc58 100644
--- a/src/kudu/cfile/encoding-test.cc
+++ b/src/kudu/cfile/encoding-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/utility/binary.hpp>
#include <glog/logging.h>
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/index_block.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/index_block.cc b/src/kudu/cfile/index_block.cc
index cdf0886..fb01834 100644
--- a/src/kudu/cfile/index_block.cc
+++ b/src/kudu/cfile/index_block.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include "kudu/cfile/cfile_writer.h"
#include "kudu/cfile/index_block.h"
@@ -70,7 +69,7 @@ void IndexBlockBuilder::Add(const Slice &keyptr,
Slice IndexBlockBuilder::Finish() {
CHECK(!finished_) << "already called Finish()";
- BOOST_FOREACH(uint32_t off, entry_offsets_) {
+ for (uint32_t off : entry_offsets_) {
InlinePutFixed32(&buffer_, off);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/cfile/mt-bloomfile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/mt-bloomfile-test.cc b/src/kudu/cfile/mt-bloomfile-test.cc
index e5c13b5..aafbd70 100644
--- a/src/kudu/cfile/mt-bloomfile-test.cc
+++ b/src/kudu/cfile/mt-bloomfile-test.cc
@@ -43,7 +43,7 @@ TEST_F(MTBloomFileTest, Benchmark) {
&new_thread));
threads.push_back(new_thread);
}
- BOOST_FOREACH(scoped_refptr<kudu::Thread>& t, threads) {
+ for (scoped_refptr<kudu::Thread>& t : threads) {
t->Join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/batcher.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/batcher.cc b/src/kudu/client/batcher.cc
index 9b0bdf0..5b5d2bf 100644
--- a/src/kudu/client/batcher.cc
+++ b/src/kudu/client/batcher.cc
@@ -273,7 +273,7 @@ WriteRpc::WriteRpc(const scoped_refptr<Batcher>& batcher,
// Add the rows
int ctr = 0;
RowOperationsPBEncoder enc(requested);
- BOOST_FOREACH(InFlightOp* op, ops_) {
+ for (InFlightOp* op : ops_) {
const Partition& partition = op->tablet->partition();
const PartitionSchema& partition_schema = table()->partition_schema();
const KuduPartialRow& row = op->write_op->row();
@@ -343,7 +343,7 @@ void WriteRpc::SendRpc() {
// Try to "guess" the next leader.
vector<RemoteTabletServer*> replicas;
tablet_->GetRemoteTabletServers(&replicas);
- BOOST_FOREACH(RemoteTabletServer* ts, replicas) {
+ for (RemoteTabletServer* ts : replicas) {
if (!ContainsKey(followers_, ts)) {
current_ts_ = ts;
break;
@@ -501,14 +501,14 @@ void Batcher::Abort() {
state_ = kAborted;
vector<InFlightOp*> to_abort;
- BOOST_FOREACH(InFlightOp* op, ops_) {
+ for (InFlightOp* op : ops_) {
lock_guard<simple_spinlock> l(&op->lock_);
if (op->state == InFlightOp::kBufferedToTabletServer) {
to_abort.push_back(op);
}
}
- BOOST_FOREACH(InFlightOp* op, to_abort) {
+ for (InFlightOp* op : to_abort) {
VLOG(1) << "Aborting op: " << op->ToString();
MarkInFlightOpFailedUnlocked(op, Status::Aborted("Batch aborted"));
}
@@ -522,7 +522,7 @@ void Batcher::Abort() {
Batcher::~Batcher() {
if (PREDICT_FALSE(!ops_.empty())) {
- BOOST_FOREACH(InFlightOp* op, ops_) {
+ for (InFlightOp* op : ops_) {
LOG(ERROR) << "Orphaned op: " << op->ToString();
}
LOG(FATAL) << "ops_ not empty";
@@ -782,7 +782,7 @@ void Batcher::FlushBuffersIfReady() {
}
// Now flush the ops for each tablet.
- BOOST_FOREACH(const OpsMap::value_type& e, ops_copy) {
+ for (const OpsMap::value_type& e : ops_copy) {
RemoteTablet* tablet = e.first;
const vector<InFlightOp*>& ops = e.second;
@@ -821,7 +821,7 @@ void Batcher::ProcessWriteResponse(const WriteRpc& rpc,
}
} else {
// Mark each of the rows in the write op as failed, since the whole RPC failed.
- BOOST_FOREACH(InFlightOp* op, rpc.ops()) {
+ for (InFlightOp* op : rpc.ops()) {
gscoped_ptr<KuduError> error(new KuduError(op->write_op.release(), s));
error_collector_->AddError(error.Pass());
}
@@ -833,7 +833,7 @@ void Batcher::ProcessWriteResponse(const WriteRpc& rpc,
// Remove all the ops from the "in-flight" list.
{
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(InFlightOp* op, rpc.ops()) {
+ for (InFlightOp* op : rpc.ops()) {
CHECK_EQ(1, ops_.erase(op))
<< "Could not remove op " << op->ToString()
<< " from in-flight list";
@@ -841,7 +841,7 @@ void Batcher::ProcessWriteResponse(const WriteRpc& rpc,
}
// Check individual row errors.
- BOOST_FOREACH(const WriteResponsePB_PerRowErrorPB& err_pb, rpc.resp().per_row_errors()) {
+ for (const WriteResponsePB_PerRowErrorPB& err_pb : rpc.resp().per_row_errors()) {
// TODO: handle case where we get one of the more specific TS errors
// like the tablet not being hosted?
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/client-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-internal.cc b/src/kudu/client/client-internal.cc
index 948d7c6..ff98037 100644
--- a/src/kudu/client/client-internal.cc
+++ b/src/kudu/client/client-internal.cc
@@ -18,7 +18,6 @@
#include "kudu/client/client-internal.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <limits>
#include <string>
#include <vector>
@@ -260,7 +259,7 @@ RemoteTabletServer* KuduClient::Data::SelectTServer(const scoped_refptr<RemoteTa
rt->GetRemoteTabletServers(candidates);
// Filter out all the blacklisted candidates.
vector<RemoteTabletServer*> filtered;
- BOOST_FOREACH(RemoteTabletServer* rts, *candidates) {
+ for (RemoteTabletServer* rts : *candidates) {
if (!ContainsKey(blacklist, rts->permanent_uuid())) {
filtered.push_back(rts);
} else {
@@ -273,7 +272,7 @@ RemoteTabletServer* KuduClient::Data::SelectTServer(const scoped_refptr<RemoteTa
}
} else if (selection == CLOSEST_REPLICA) {
// Choose a local replica.
- BOOST_FOREACH(RemoteTabletServer* rts, filtered) {
+ for (RemoteTabletServer* rts : filtered) {
if (IsTabletServerLocal(*rts)) {
ret = rts;
break;
@@ -520,7 +519,7 @@ Status KuduClient::Data::InitLocalHostNames() {
RETURN_NOT_OK_PREPEND(HostPort(hostname, 0).ResolveAddresses(&addresses),
Substitute("Could not resolve local host name '$0'", hostname));
- BOOST_FOREACH(const Sockaddr& addr, addresses) {
+ for (const Sockaddr& addr : addresses) {
// Similar to above, ignore local or wildcard addresses.
if (addr.IsWildcard()) continue;
if (addr.IsAnyLocalAddress()) continue;
@@ -539,7 +538,7 @@ bool KuduClient::Data::IsLocalHostPort(const HostPort& hp) const {
bool KuduClient::Data::IsTabletServerLocal(const RemoteTabletServer& rts) const {
vector<HostPort> host_ports;
rts.GetHostPorts(&host_ports);
- BOOST_FOREACH(const HostPort& hp, host_ports) {
+ for (const HostPort& hp : host_ports) {
if (IsLocalHostPort(hp)) return true;
}
return false;
@@ -747,7 +746,7 @@ void KuduClient::Data::LeaderMasterDetermined(const Status& status,
}
}
- BOOST_FOREACH(const StatusCallback& cb, cbs) {
+ for (const StatusCallback& cb : cbs) {
cb.Run(new_status);
}
}
@@ -765,7 +764,7 @@ void KuduClient::Data::SetMasterServerProxyAsync(KuduClient* client,
DCHECK(deadline.Initialized());
vector<Sockaddr> master_sockaddrs;
- BOOST_FOREACH(const string& master_server_addr, master_server_addrs_) {
+ for (const string& master_server_addr : master_server_addrs_) {
vector<Sockaddr> addrs;
Status s;
// TODO: Do address resolution asynchronously as well.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/client-test-util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test-util.cc b/src/kudu/client/client-test-util.cc
index 898ae14..7015c8b 100644
--- a/src/kudu/client/client-test-util.cc
+++ b/src/kudu/client/client-test-util.cc
@@ -18,7 +18,6 @@
#include "kudu/client/client-test-util.h"
#include "kudu/client/row_result.h"
-#include <boost/foreach.hpp>
#include <vector>
#include "kudu/gutil/stl_util.h"
@@ -39,7 +38,7 @@ void LogSessionErrorsAndDie(const sp::shared_ptr<KuduSession>& session,
// Log only the first 10 errors.
LOG(INFO) << errors.size() << " failed ops. First 10 errors follow";
int i = 0;
- BOOST_FOREACH(const KuduError* e, errors) {
+ for (const KuduError* e : errors) {
if (i == 10) {
break;
}
@@ -63,7 +62,7 @@ void ScanToStrings(KuduScanner* scanner, vector<string>* row_strings) {
vector<KuduRowResult> rows;
while (scanner->HasMoreRows()) {
ASSERT_OK(scanner->NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
row_strings->push_back(row.ToString());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/client-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index 505c167..29ea8a8 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <gflags/gflags.h>
#include <glog/stl_logging.h>
@@ -261,7 +260,7 @@ class ClientTest : public KuduTest {
while (scanner.HasMoreRows()) {
ASSERT_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
int32_t value;
ASSERT_OK(row.GetInt32(0, &value));
sum += value;
@@ -292,7 +291,7 @@ class ClientTest : public KuduTest {
while (scanner.HasMoreRows()) {
ASSERT_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
Slice s;
ASSERT_OK(row.GetString(2, &s));
if (!s.starts_with("hello 2") && !s.starts_with("hello 3")) {
@@ -320,7 +319,7 @@ class ClientTest : public KuduTest {
while (scanner.HasMoreRows()) {
ASSERT_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
int32_t k;
ASSERT_OK(row.GetInt32(0, &k));
if (k < 5 || k > 10) {
@@ -782,7 +781,7 @@ TEST_F(ClientTest, TestScanPredicateKeyColNotProjected) {
while (scanner.HasMoreRows()) {
ASSERT_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
int32_t val;
ASSERT_OK(row.GetInt32(0, &val));
ASSERT_EQ(curr_key * 2, val);
@@ -820,7 +819,7 @@ TEST_F(ClientTest, TestScanPredicateNonKeyColNotProjected) {
while (scanner.HasMoreRows()) {
ASSERT_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
int32_t val;
ASSERT_OK(row.GetInt32(0, &val));
ASSERT_EQ(curr_key / 2, val);
@@ -915,7 +914,7 @@ static void DoScanWithCallback(KuduTable* table,
vector<KuduRowResult> result_rows;
ASSERT_OK(scanner.NextBatch(&result_rows));
ASSERT_GT(result_rows.size(), 0);
- BOOST_FOREACH(KuduRowResult& r, result_rows) {
+ for (KuduRowResult& r : result_rows) {
rows.push_back(r.ToString());
}
ASSERT_TRUE(scanner.HasMoreRows());
@@ -937,7 +936,7 @@ static void DoScanWithCallback(KuduTable* table,
while (scanner.HasMoreRows()) {
vector<KuduRowResult> result_rows;
ASSERT_OK(scanner.NextBatch(&result_rows));
- BOOST_FOREACH(KuduRowResult& r, result_rows) {
+ for (KuduRowResult& r : result_rows) {
rows.push_back(r.ToString());
}
}
@@ -1076,18 +1075,18 @@ TEST_F(ClientTest, TestGetTabletServerBlacklist) {
selections.push_back(KuduClient::LEADER_ONLY);
selections.push_back(KuduClient::CLOSEST_REPLICA);
selections.push_back(KuduClient::FIRST_REPLICA);
- BOOST_FOREACH(KuduClient::ReplicaSelection selection, selections) {
+ for (KuduClient::ReplicaSelection selection : selections) {
Status s = client_->data_->GetTabletServer(client_.get(), rt->tablet_id(), selection,
blacklist, &candidates, &rts);
ASSERT_TRUE(s.IsServiceUnavailable());
}
// Make sure none of the modes work when all nodes are dead.
- BOOST_FOREACH(internal::RemoteTabletServer* rt, tservers) {
+ for (internal::RemoteTabletServer* rt : tservers) {
client_->data_->meta_cache_->MarkTSFailed(rt, Status::NetworkError("test"));
}
blacklist.clear();
- BOOST_FOREACH(KuduClient::ReplicaSelection selection, selections) {
+ for (KuduClient::ReplicaSelection selection : selections) {
Status s = client_->data_->GetTabletServer(client_.get(), rt->tablet_id(),
selection,
blacklist, &candidates, &rts);
@@ -1209,7 +1208,7 @@ namespace {
int64_t SumResults(const vector<KuduRowResult>& results) {
int64_t sum = 0;
- BOOST_FOREACH(const KuduRowResult row, results) {
+ for (const KuduRowResult row : results) {
int32_t val;
CHECK_OK(row.GetInt32(0, &val));
sum += val;
@@ -2239,7 +2238,7 @@ void CheckCorrectness(KuduScanner* scanner, int expected[], int nrows) {
while (scanner->HasMoreRows()) {
ASSERT_OK(scanner->NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& r, rows) {
+ for (const KuduRowResult& r : rows) {
int32_t key;
int32_t val;
Slice strval;
@@ -2431,7 +2430,7 @@ namespace {
int cnt = 0;
while (scanner.HasMoreRows()) {
CHECK_OK(scanner.NextBatch(&rows));
- BOOST_FOREACH(const KuduRowResult& row, rows) {
+ for (const KuduRowResult& row : rows) {
// Check that for every key:
// 1. Column 1 int32_t value == expected
// 2. Column 2 string value is empty
@@ -2688,7 +2687,7 @@ TEST_F(ClientTest, TestServerTooBusyRetry) {
}
}
- BOOST_FOREACH(const scoped_refptr<kudu::Thread>& thread, threads) {
+ for (const scoped_refptr<kudu::Thread>& thread : threads) {
thread->Join();
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/client.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client.cc b/src/kudu/client/client.cc
index c1964c4..82f5a77 100644
--- a/src/kudu/client/client.cc
+++ b/src/kudu/client/client.cc
@@ -177,7 +177,7 @@ KuduClientBuilder& KuduClientBuilder::clear_master_server_addrs() {
}
KuduClientBuilder& KuduClientBuilder::master_server_addrs(const vector<string>& addrs) {
- BOOST_FOREACH(const string& addr, addrs) {
+ for (const string& addr : addrs) {
data_->master_server_addrs_.push_back(addr);
}
return *this;
@@ -338,7 +338,7 @@ Status KuduClient::ListTables(vector<string>* tables,
Status KuduClient::TableExists(const string& table_name, bool* exists) {
std::vector<std::string> tables;
RETURN_NOT_OK(ListTables(&tables, table_name));
- BOOST_FOREACH(const string& table, tables) {
+ for (const string& table : tables) {
if (table == table_name) {
*exists = true;
return Status::OK();
@@ -431,7 +431,7 @@ KuduTableCreator& KuduTableCreator::add_hash_partitions(const std::vector<std::s
int32_t num_buckets, int32_t seed) {
PartitionSchemaPB::HashBucketSchemaPB* bucket_schema =
data_->partition_schema_.add_hash_bucket_schemas();
- BOOST_FOREACH(const string& col_name, columns) {
+ for (const string& col_name : columns) {
bucket_schema->add_columns()->set_name(col_name);
}
bucket_schema->set_num_buckets(num_buckets);
@@ -444,7 +444,7 @@ KuduTableCreator& KuduTableCreator::set_range_partition_columns(
PartitionSchemaPB::RangeSchemaPB* range_schema =
data_->partition_schema_.mutable_range_schema();
range_schema->Clear();
- BOOST_FOREACH(const string& col_name, columns) {
+ for (const string& col_name : columns) {
range_schema->add_columns()->set_name(col_name);
}
@@ -490,7 +490,7 @@ Status KuduTableCreator::Create() {
RowOperationsPBEncoder encoder(req.mutable_split_rows());
- BOOST_FOREACH(const KuduPartialRow* row, data_->split_rows_) {
+ for (const KuduPartialRow* row : data_->split_rows_) {
encoder.Add(RowOperationsPB::SPLIT_ROW, *row);
}
req.mutable_partition_schema()->CopyFrom(data_->partition_schema_);
@@ -704,7 +704,7 @@ bool KuduSession::HasPendingOperations() const {
if (data_->batcher_->HasPendingOperations()) {
return true;
}
- BOOST_FOREACH(Batcher* b, data_->flushed_batchers_) {
+ for (Batcher* b : data_->flushed_batchers_) {
if (b->HasPendingOperations()) {
return true;
}
@@ -844,7 +844,7 @@ Status KuduScanner::SetProjectedColumnNames(const vector<string>& col_names) {
const Schema* table_schema = data_->table_->schema().schema_;
vector<int> col_indexes;
col_indexes.reserve(col_names.size());
- BOOST_FOREACH(const string& col_name, col_names) {
+ for (const string& col_name : col_names) {
int idx = table_schema->find_column(col_name);
if (idx == Schema::kColumnNotFound) {
return Status::NotFound(strings::Substitute("Column: \"$0\" was not found in the "
@@ -864,7 +864,7 @@ Status KuduScanner::SetProjectedColumnIndexes(const vector<int>& col_indexes) {
const Schema* table_schema = data_->table_->schema().schema_;
vector<ColumnSchema> cols;
cols.reserve(col_indexes.size());
- BOOST_FOREACH(const int col_index, col_indexes) {
+ for (const int col_index : col_indexes) {
if (col_index >= table_schema->columns().size()) {
return Status::NotFound(strings::Substitute("Column: \"$0\" was not found in the "
"table schema.", col_index));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/meta_cache.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
index 527c3b7..038af91 100644
--- a/src/kudu/client/meta_cache.cc
+++ b/src/kudu/client/meta_cache.cc
@@ -18,7 +18,6 @@
#include "kudu/client/meta_cache.h"
#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include "kudu/client/client.h"
@@ -127,7 +126,7 @@ void RemoteTabletServer::Update(const master::TSInfoPB& pb) {
lock_guard<simple_spinlock> l(&lock_);
rpc_hostports_.clear();
- BOOST_FOREACH(const HostPortPB& hostport_pb, pb.rpc_addresses()) {
+ for (const HostPortPB& hostport_pb : pb.rpc_addresses()) {
rpc_hostports_.push_back(HostPort(hostport_pb.host(), hostport_pb.port()));
}
}
@@ -165,7 +164,7 @@ void RemoteTablet::Refresh(const TabletServerMap& tservers,
// Adopt the data from the successful response.
lock_guard<simple_spinlock> l(&lock_);
replicas_.clear();
- BOOST_FOREACH(const TabletLocationsPB_ReplicaPB& r, replicas) {
+ for (const TabletLocationsPB_ReplicaPB& r : replicas) {
RemoteReplica rep;
rep.ts = FindOrDie(tservers, r.ts_info().permanent_uuid());
rep.role = r.role();
@@ -187,7 +186,7 @@ bool RemoteTablet::MarkReplicaFailed(RemoteTabletServer *ts,
<< ReplicasAsStringUnlocked();
LOG(WARNING) << "Tablet " << tablet_id_ << ": Replica " << ts->ToString()
<< " has failed: " << status.ToString();
- BOOST_FOREACH(RemoteReplica& rep, replicas_) {
+ for (RemoteReplica& rep : replicas_) {
if (rep.ts == ts) {
rep.failed = true;
found = true;
@@ -199,7 +198,7 @@ bool RemoteTablet::MarkReplicaFailed(RemoteTabletServer *ts,
int RemoteTablet::GetNumFailedReplicas() const {
int failed = 0;
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const RemoteReplica& rep, replicas_) {
+ for (const RemoteReplica& rep : replicas_) {
if (rep.failed) {
failed++;
}
@@ -209,7 +208,7 @@ int RemoteTablet::GetNumFailedReplicas() const {
RemoteTabletServer* RemoteTablet::LeaderTServer() const {
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const RemoteReplica& replica, replicas_) {
+ for (const RemoteReplica& replica : replicas_) {
if (!replica.failed && replica.role == RaftPeerPB::LEADER) {
return replica.ts;
}
@@ -223,7 +222,7 @@ bool RemoteTablet::HasLeader() const {
void RemoteTablet::GetRemoteTabletServers(vector<RemoteTabletServer*>* servers) const {
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(const RemoteReplica& replica, replicas_) {
+ for (const RemoteReplica& replica : replicas_) {
if (replica.failed) {
continue;
}
@@ -234,7 +233,7 @@ void RemoteTablet::GetRemoteTabletServers(vector<RemoteTabletServer*>* servers)
void RemoteTablet::MarkTServerAsLeader(const RemoteTabletServer* server) {
bool found = false;
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(RemoteReplica& replica, replicas_) {
+ for (RemoteReplica& replica : replicas_) {
if (replica.ts == server) {
replica.role = RaftPeerPB::LEADER;
found = true;
@@ -250,7 +249,7 @@ void RemoteTablet::MarkTServerAsLeader(const RemoteTabletServer* server) {
void RemoteTablet::MarkTServerAsFollower(const RemoteTabletServer* server) {
bool found = false;
lock_guard<simple_spinlock> l(&lock_);
- BOOST_FOREACH(RemoteReplica& replica, replicas_) {
+ for (RemoteReplica& replica : replicas_) {
if (replica.ts == server) {
replica.role = RaftPeerPB::FOLLOWER;
found = true;
@@ -269,7 +268,7 @@ std::string RemoteTablet::ReplicasAsString() const {
std::string RemoteTablet::ReplicasAsStringUnlocked() const {
DCHECK(lock_.is_locked());
string replicas_str;
- BOOST_FOREACH(const RemoteReplica& rep, replicas_) {
+ for (const RemoteReplica& rep : replicas_) {
if (!replicas_str.empty()) replicas_str += ", ";
strings::SubstituteAndAppend(&replicas_str, "$0 ($1, $2)",
rep.ts->permanent_uuid(),
@@ -536,9 +535,9 @@ const scoped_refptr<RemoteTablet>& MetaCache::ProcessLookupResponse(const Lookup
lock_guard<rw_spinlock> l(&lock_);
TabletMap& tablets_by_key = LookupOrInsert(&tablets_by_table_and_key_,
rpc.table_id(), TabletMap());
- BOOST_FOREACH(const TabletLocationsPB& loc, rpc.resp().tablet_locations()) {
+ for (const TabletLocationsPB& loc : rpc.resp().tablet_locations()) {
// First, update the tserver cache, needed for the Refresh calls below.
- BOOST_FOREACH(const TabletLocationsPB_ReplicaPB& r, loc.replicas()) {
+ for (const TabletLocationsPB_ReplicaPB& r : loc.replicas()) {
UpdateTabletServer(r.ts_info());
}
@@ -627,7 +626,7 @@ void MetaCache::MarkTSFailed(RemoteTabletServer* ts,
Status ts_status = status.CloneAndPrepend("TS failed");
// TODO: replace with a ts->tablet multimap for faster lookup?
- BOOST_FOREACH(const TabletMap::value_type& tablet, tablets_by_id_) {
+ for (const TabletMap::value_type& tablet : tablets_by_id_) {
// We just loop on all tablets; if a tablet does not have a replica on this
// TS, MarkReplicaFailed() returns false and we ignore the return value.
tablet.second->MarkReplicaFailed(ts, ts_status);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/scanner-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/scanner-internal.cc b/src/kudu/client/scanner-internal.cc
index afe893d..9b158fd 100644
--- a/src/kudu/client/scanner-internal.cc
+++ b/src/kudu/client/scanner-internal.cc
@@ -221,7 +221,7 @@ Status KuduScanner::Data::OpenTablet(const string& partition_key,
// Set up the predicates.
scan->clear_range_predicates();
- BOOST_FOREACH(const ColumnRangePredicate& pred, spec_.predicates()) {
+ for (const ColumnRangePredicate& pred : spec_.predicates()) {
const ColumnSchema& col = pred.column();
const ValueRange& range = pred.range();
ColumnRangePredicatePB* pb = scan->add_range_predicates();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/schema.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/schema.cc b/src/kudu/client/schema.cc
index aa574c0..5614356 100644
--- a/src/kudu/client/schema.cc
+++ b/src/kudu/client/schema.cc
@@ -17,7 +17,6 @@
#include "kudu/client/schema.h"
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <unordered_map>
@@ -282,7 +281,7 @@ KuduSchemaBuilder::KuduSchemaBuilder()
}
KuduSchemaBuilder::~KuduSchemaBuilder() {
- BOOST_FOREACH(KuduColumnSpec* spec, data_->specs) {
+ for (KuduColumnSpec* spec : data_->specs) {
// Can't use STLDeleteElements because KuduSchemaBuilder
// is a friend of KuduColumnSpec in order to access its destructor.
// STLDeleteElements is a free function and therefore can't access it.
@@ -343,7 +342,7 @@ Status KuduSchemaBuilder::Build(KuduSchema* schema) {
// Build a map from name to index of all of the columns.
unordered_map<string, int> name_to_idx_map;
int i = 0;
- BOOST_FOREACH(KuduColumnSpec* spec, data_->specs) {
+ for (KuduColumnSpec* spec : data_->specs) {
// If they did pass the key column names, then we should not have explicitly
// set it on any columns.
if (spec->data_->primary_key) {
@@ -357,7 +356,7 @@ Status KuduSchemaBuilder::Build(KuduSchema* schema) {
// Convert the key column names to a set of indexes.
vector<int> key_col_indexes;
- BOOST_FOREACH(const string& key_col_name, data_->key_col_names) {
+ for (const string& key_col_name : data_->key_col_names) {
int idx;
if (!FindCopy(name_to_idx_map, key_col_name, &idx)) {
return Status::InvalidArgument("primary key column not defined", key_col_name);
@@ -486,7 +485,7 @@ void KuduSchema::CopyFrom(const KuduSchema& other) {
Status KuduSchema::Reset(const vector<KuduColumnSchema>& columns, int key_columns) {
vector<ColumnSchema> cols_private;
- BOOST_FOREACH(const KuduColumnSchema& col, columns) {
+ for (const KuduColumnSchema& col : columns) {
cols_private.push_back(*col.col_);
}
gscoped_ptr<Schema> new_schema(new Schema());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/table_alterer-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/table_alterer-internal.cc b/src/kudu/client/table_alterer-internal.cc
index 6ee0d28..d9594bb 100644
--- a/src/kudu/client/table_alterer-internal.cc
+++ b/src/kudu/client/table_alterer-internal.cc
@@ -17,7 +17,6 @@
#include "kudu/client/table_alterer-internal.h"
-#include <boost/foreach.hpp>
#include <string>
#include "kudu/client/schema.h"
@@ -41,7 +40,7 @@ KuduTableAlterer::Data::Data(
}
KuduTableAlterer::Data::~Data() {
- BOOST_FOREACH(Step& s, steps_) {
+ for (Step& s : steps_) {
delete s.spec;
}
}
@@ -62,7 +61,7 @@ Status KuduTableAlterer::Data::ToRequest(AlterTableRequestPB* req) {
req->set_new_table_name(rename_to_.get());
}
- BOOST_FOREACH(const Step& s, steps_) {
+ for (const Step& s : steps_) {
AlterTableRequestPB::Step* pb_step = req->add_alter_schema_steps();
pb_step->set_type(s.step_type);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/client/table_creator-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/table_creator-internal.cc b/src/kudu/client/table_creator-internal.cc
index 2189018..e5774b2 100644
--- a/src/kudu/client/table_creator-internal.cc
+++ b/src/kudu/client/table_creator-internal.cc
@@ -17,7 +17,6 @@
#include "kudu/client/table_creator-internal.h"
-#include <boost/foreach.hpp>
#include "kudu/gutil/stl_util.h"
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/codegen/codegen-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/codegen/codegen-test.cc b/src/kudu/codegen/codegen-test.cc
index f9ff013..0c209fe 100644
--- a/src/kudu/codegen/codegen-test.cc
+++ b/src/kudu/codegen/codegen-test.cc
@@ -18,7 +18,6 @@
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <gmock/gmock.h>
@@ -224,7 +223,7 @@ Status CodegenTest::Generate(const Schema* proj, gscoped_ptr<CodegenRP>* out) {
Status CodegenTest::CreatePartialSchema(const vector<size_t>& col_indexes,
Schema* out) {
vector<ColumnId> col_ids;
- BOOST_FOREACH(size_t col_idx, col_indexes) {
+ for (size_t col_idx : col_indexes) {
col_ids.push_back(defaults_.column_id(col_idx));
}
return defaults_.CreateProjectionByIdsIgnoreMissing(col_ids, out);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/codegen/module_builder.cc
----------------------------------------------------------------------
diff --git a/src/kudu/codegen/module_builder.cc b/src/kudu/codegen/module_builder.cc
index 538f6bd..ad0fe1f 100644
--- a/src/kudu/codegen/module_builder.cc
+++ b/src/kudu/codegen/module_builder.cc
@@ -22,7 +22,6 @@
#include <string>
#include <vector>
-#include <boost/foreach.hpp>
#include <glog/logging.h>
#include <llvm/ADT/StringRef.h>
#include <llvm/Analysis/Passes.h>
@@ -222,7 +221,7 @@ void DoOptimizations(ExecutionEngine* engine,
fpm.doInitialization();
// For each function in the module, optimize it
- BOOST_FOREACH(Function& f, *module) {
+ for (Function& f : *module) {
// The bool return value here just indicates whether the passes did anything.
// We can safely expect that many functions are too small to do any optimization.
ignore_result(fpm.run(f));
@@ -275,7 +274,7 @@ Status ModuleBuilder::Compile(unique_ptr<ExecutionEngine>* out) {
local_engine->finalizeObject();
// Satisfy the promises
- BOOST_FOREACH(JITFuture& fut, futures_) {
+ for (JITFuture& fut : futures_) {
*fut.actual_f_ = local_engine->getPointerToFunction(fut.llvm_f_);
if (*fut.actual_f_ == NULL) {
return Status::NotFound(
@@ -304,7 +303,7 @@ TargetMachine* ModuleBuilder::GetTargetMachine() const {
vector<const char*> ModuleBuilder::GetFunctionNames() const {
vector<const char*> ret;
- BOOST_FOREACH(const JITFuture& fut, futures_) {
+ for (const JITFuture& fut : futures_) {
const char* name = CHECK_NOTNULL(fut.llvm_f_)->getName().data();
ret.push_back(name);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/codegen/row_projector.cc
----------------------------------------------------------------------
diff --git a/src/kudu/codegen/row_projector.cc b/src/kudu/codegen/row_projector.cc
index 3b18e16..3ba4ad9 100644
--- a/src/kudu/codegen/row_projector.cc
+++ b/src/kudu/codegen/row_projector.cc
@@ -23,7 +23,6 @@
#include <utility>
#include <vector>
-#include <boost/foreach.hpp>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/IR/Argument.h>
#include <llvm/IR/BasicBlock.h>
@@ -175,8 +174,7 @@ llvm::Function* MakeProjection(const string& name,
int success_update_number = 0;
// Copy base data
- BOOST_FOREACH(const kudu::RowProjector::ProjectionIdxMapping& pmap,
- proj.base_cols_mapping()) {
+ for (const kudu::RowProjector::ProjectionIdxMapping& pmap : proj.base_cols_mapping()) {
// Retrieve information regarding this column-to-column transformation
size_t proj_idx = pmap.first;
size_t base_idx = pmap.second;
@@ -211,7 +209,7 @@ llvm::Function* MakeProjection(const string& name,
<< "Value Adapter not supported yet";
// Fill defaults
- BOOST_FOREACH(size_t dfl_idx, proj.projection_defaults()) {
+ for (size_t dfl_idx : proj.projection_defaults()) {
// Retrieve mapping information
const ColumnSchema& col = projection.column(dfl_idx);
const void* dfl = READ ? col.read_default_value() :
@@ -345,21 +343,20 @@ Status RowProjectorFunctions::EncodeKey(const Schema& base, const Schema& proj,
AddNext(out, JITWrapper::ROW_PROJECTOR);
AddNext(out, base.num_columns());
- BOOST_FOREACH(const ColumnSchema& col, base.columns()) {
+ for (const ColumnSchema& col : base.columns()) {
AddNext(out, col.type_info()->physical_type());
AddNext(out, col.is_nullable());
}
AddNext(out, proj.num_columns());
- BOOST_FOREACH(const ColumnSchema& col, proj.columns()) {
+ for (const ColumnSchema& col : proj.columns()) {
AddNext(out, col.type_info()->physical_type());
AddNext(out, col.is_nullable());
}
AddNext(out, projector.base_cols_mapping().size());
- BOOST_FOREACH(const kudu::RowProjector::ProjectionIdxMapping& map,
- projector.base_cols_mapping()) {
+ for (const kudu::RowProjector::ProjectionIdxMapping& map : projector.base_cols_mapping()) {
AddNext(out, map);
}
- BOOST_FOREACH(size_t dfl_idx, projector.projection_defaults()) {
+ for (size_t dfl_idx : projector.projection_defaults()) {
const ColumnSchema& col = proj.column(dfl_idx);
AddNext(out, dfl_idx);
AddNext(out, col.read_default_value());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/generic_iterators.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/generic_iterators.cc b/src/kudu/common/generic_iterators.cc
index 5ffd0cf..d6a876f 100644
--- a/src/kudu/common/generic_iterators.cc
+++ b/src/kudu/common/generic_iterators.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/foreach.hpp>
#include <algorithm>
#include <memory>
@@ -159,7 +158,7 @@ Status MergeIterator::Init(ScanSpec *spec) {
RETURN_NOT_OK(InitSubIterators(spec));
- BOOST_FOREACH(shared_ptr<MergeIterState> &state, iters_) {
+ for (shared_ptr<MergeIterState> &state : iters_) {
RETURN_NOT_OK(state->PullNextBlock());
}
@@ -185,7 +184,7 @@ bool MergeIterator::HasNext() const {
Status MergeIterator::InitSubIterators(ScanSpec *spec) {
// Initialize all the sub iterators.
- BOOST_FOREACH(shared_ptr<RowwiseIterator> &iter, orig_iters_) {
+ for (shared_ptr<RowwiseIterator> &iter : orig_iters_) {
ScanSpec *spec_copy = spec != NULL ? scan_spec_copies_.Construct(*spec) : NULL;
RETURN_NOT_OK(PredicateEvaluatingIterator::InitAndMaybeWrap(&iter, spec_copy));
iters_.push_back(shared_ptr<MergeIterState>(new MergeIterState(iter)));
@@ -217,7 +216,7 @@ void MergeIterator::PrepareBatch(RowBlock* dst) {
// We can always provide at least as many rows as are remaining
// in the currently queued up blocks.
size_t available = 0;
- BOOST_FOREACH(shared_ptr<MergeIterState> &iter, iters_) {
+ for (shared_ptr<MergeIterState> &iter : iters_) {
available += iter->remaining_in_block();
}
@@ -269,7 +268,7 @@ string MergeIterator::ToString() const {
string s;
s.append("Merge(");
bool first = true;
- BOOST_FOREACH(const shared_ptr<RowwiseIterator> &iter, orig_iters_) {
+ for (const shared_ptr<RowwiseIterator> &iter : orig_iters_) {
s.append(iter->ToString());
if (!first) {
s.append(", ");
@@ -288,14 +287,14 @@ const Schema& MergeIterator::schema() const {
void MergeIterator::GetIteratorStats(vector<IteratorStats>* stats) const {
CHECK(initted_);
vector<vector<IteratorStats> > stats_by_iter;
- BOOST_FOREACH(const shared_ptr<RowwiseIterator>& iter, orig_iters_) {
+ for (const shared_ptr<RowwiseIterator>& iter : orig_iters_) {
vector<IteratorStats> stats_for_iter;
iter->GetIteratorStats(&stats_for_iter);
stats_by_iter.push_back(stats_for_iter);
}
for (size_t idx = 0; idx < schema_.num_columns(); ++idx) {
IteratorStats stats_for_col;
- BOOST_FOREACH(const vector<IteratorStats>& stats_for_iter, stats_by_iter) {
+ for (const vector<IteratorStats>& stats_for_iter : stats_by_iter) {
stats_for_col.AddStats(stats_for_iter[idx]);
}
stats->push_back(stats_for_col);
@@ -326,7 +325,7 @@ Status UnionIterator::Init(ScanSpec *spec) {
// sub-iterators, since they may not know their own schemas
// until they've been initialized (in the case of a union of unions)
schema_.reset(new Schema(iters_.front()->schema()));
- BOOST_FOREACH(const shared_ptr<RowwiseIterator> &iter, iters_) {
+ for (const shared_ptr<RowwiseIterator> &iter : iters_) {
if (!iter->schema().Equals(*schema_)) {
return Status::InvalidArgument(
string("Schemas do not match: ") + schema_->ToString()
@@ -340,7 +339,7 @@ Status UnionIterator::Init(ScanSpec *spec) {
Status UnionIterator::InitSubIterators(ScanSpec *spec) {
- BOOST_FOREACH(shared_ptr<RowwiseIterator> &iter, iters_) {
+ for (shared_ptr<RowwiseIterator> &iter : iters_) {
ScanSpec *spec_copy = spec != NULL ? scan_spec_copies_.Construct(*spec) : NULL;
RETURN_NOT_OK(PredicateEvaluatingIterator::InitAndMaybeWrap(&iter, spec_copy));
}
@@ -354,7 +353,7 @@ Status UnionIterator::InitSubIterators(ScanSpec *spec) {
bool UnionIterator::HasNext() const {
CHECK(initted_);
- BOOST_FOREACH(const shared_ptr<RowwiseIterator> &iter, iters_) {
+ for (const shared_ptr<RowwiseIterator> &iter : iters_) {
if (iter->HasNext()) return true;
}
@@ -394,7 +393,7 @@ string UnionIterator::ToString() const {
string s;
s.append("Union(");
bool first = true;
- BOOST_FOREACH(const shared_ptr<RowwiseIterator> &iter, iters_) {
+ for (const shared_ptr<RowwiseIterator> &iter : iters_) {
if (!first) {
s.append(", ");
}
@@ -408,14 +407,14 @@ string UnionIterator::ToString() const {
void UnionIterator::GetIteratorStats(std::vector<IteratorStats>* stats) const {
CHECK(initted_);
vector<vector<IteratorStats> > stats_by_iter;
- BOOST_FOREACH(const shared_ptr<RowwiseIterator>& iter, all_iters_) {
+ for (const shared_ptr<RowwiseIterator>& iter : all_iters_) {
vector<IteratorStats> stats_for_iter;
iter->GetIteratorStats(&stats_for_iter);
stats_by_iter.push_back(stats_for_iter);
}
for (size_t idx = 0; idx < schema_->num_columns(); ++idx) {
IteratorStats stats_for_col;
- BOOST_FOREACH(const vector<IteratorStats>& stats_for_iter, stats_by_iter) {
+ for (const vector<IteratorStats>& stats_for_iter : stats_by_iter) {
stats_for_col.AddStats(stats_for_iter[idx]);
}
stats->push_back(stats_for_col);
@@ -504,15 +503,15 @@ Status MaterializingIterator::MaterializeBlock(RowBlock *dst) {
bool short_circuit = false;
- BOOST_FOREACH(size_t col_idx, materialization_order_) {
+ for (size_t col_idx : materialization_order_) {
// Materialize the column itself into the row block.
ColumnBlock dst_col(dst->column_block(col_idx));
RETURN_NOT_OK(iter_->MaterializeColumn(col_idx, &dst_col));
// Evaluate any predicates that apply to this column.
- typedef std::pair<size_t, ColumnRangePredicate> MapEntry;
- BOOST_FOREACH(const MapEntry &entry, preds_by_column_.equal_range(col_idx)) {
- const ColumnRangePredicate &pred = entry.second;
+ auto range = preds_by_column_.equal_range(col_idx);
+ for (auto it = range.first; it != range.second; ++it) {
+ const ColumnRangePredicate &pred = it->second;
pred.Evaluate(dst, dst->selection_vector());
@@ -579,7 +578,7 @@ bool PredicateEvaluatingIterator::HasNext() const {
Status PredicateEvaluatingIterator::NextBlock(RowBlock *dst) {
RETURN_NOT_OK(base_iter_->NextBlock(dst));
- BOOST_FOREACH(ColumnRangePredicate &pred, predicates_) {
+ for (ColumnRangePredicate &pred : predicates_) {
pred.Evaluate(dst, dst->selection_vector());
// If after evaluating this predicate, the entire row block has now been
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/partition-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/partition-test.cc b/src/kudu/common/partition-test.cc
index bf24a4a..4af83c4 100644
--- a/src/kudu/common/partition-test.cc
+++ b/src/kudu/common/partition-test.cc
@@ -39,7 +39,7 @@ void AddHashBucketComponent(PartitionSchemaPB* partition_schema_pb,
uint32_t num_buckets, int32_t seed) {
PartitionSchemaPB::HashBucketSchemaPB* hash_bucket_schema =
partition_schema_pb->add_hash_bucket_schemas();
- BOOST_FOREACH(const string& column, columns) {
+ for (const string& column : columns) {
hash_bucket_schema->add_columns()->set_name(column);
}
hash_bucket_schema->set_num_buckets(num_buckets);
@@ -50,7 +50,7 @@ void SetRangePartitionComponent(PartitionSchemaPB* partition_schema_pb,
const vector<string>& columns) {
PartitionSchemaPB::RangeSchemaPB* range_schema = partition_schema_pb->mutable_range_schema();
range_schema->Clear();
- BOOST_FOREACH(const string& column, columns) {
+ for (const string& column : columns) {
range_schema->add_columns()->set_name(column);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/partition.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/partition.cc b/src/kudu/common/partition.cc
index 8a30640..14de73e 100644
--- a/src/kudu/common/partition.cc
+++ b/src/kudu/common/partition.cc
@@ -18,7 +18,6 @@
#include "kudu/common/partition.h"
#include <algorithm>
-#include <boost/foreach.hpp>
#include <set>
#include "kudu/common/partial_row.h"
@@ -64,7 +63,7 @@ Slice Partition::range_key(const string& partition_key) const {
void Partition::ToPB(PartitionPB* pb) const {
pb->Clear();
pb->mutable_hash_buckets()->Reserve(hash_buckets_.size());
- BOOST_FOREACH(int32_t bucket, hash_buckets()) {
+ for (int32_t bucket : hash_buckets()) {
pb->add_hash_buckets(bucket);
}
pb->set_partition_key_start(partition_key_start());
@@ -74,7 +73,7 @@ void Partition::ToPB(PartitionPB* pb) const {
void Partition::FromPB(const PartitionPB& pb, Partition* partition) {
partition->hash_buckets_.clear();
partition->hash_buckets_.reserve(pb.hash_buckets_size());
- BOOST_FOREACH(int32_t hash_bucket, pb.hash_buckets()) {
+ for (int32_t hash_bucket : pb.hash_buckets()) {
partition->hash_buckets_.push_back(hash_bucket);
}
@@ -88,7 +87,7 @@ Status ExtractColumnIds(const RepeatedPtrField<PartitionSchemaPB_ColumnIdentifie
const Schema& schema,
vector<ColumnId>* column_ids) {
column_ids->reserve(identifiers.size());
- BOOST_FOREACH(PartitionSchemaPB_ColumnIdentifierPB identifier, identifiers) {
+ for (PartitionSchemaPB_ColumnIdentifierPB identifier : identifiers) {
switch (identifier.identifier_case()) {
case PartitionSchemaPB_ColumnIdentifierPB::kId: {
ColumnId column_id(identifier.id());
@@ -115,7 +114,7 @@ Status ExtractColumnIds(const RepeatedPtrField<PartitionSchemaPB_ColumnIdentifie
void SetColumnIdentifiers(const vector<ColumnId>& column_ids,
RepeatedPtrField<PartitionSchemaPB_ColumnIdentifierPB>* identifiers) {
identifiers->Reserve(column_ids.size());
- BOOST_FOREACH(ColumnId column_id, column_ids) {
+ for (ColumnId column_id : column_ids) {
identifiers->Add()->set_id(column_id);
}
}
@@ -126,8 +125,7 @@ Status PartitionSchema::FromPB(const PartitionSchemaPB& pb,
PartitionSchema* partition_schema) {
partition_schema->Clear();
- BOOST_FOREACH(const PartitionSchemaPB_HashBucketSchemaPB& hash_bucket_pb,
- pb.hash_bucket_schemas()) {
+ for (const PartitionSchemaPB_HashBucketSchemaPB& hash_bucket_pb : pb.hash_bucket_schemas()) {
HashBucketSchema hash_bucket;
RETURN_NOT_OK(ExtractColumnIds(hash_bucket_pb.columns(), schema, &hash_bucket.column_ids));
@@ -161,7 +159,7 @@ Status PartitionSchema::FromPB(const PartitionSchemaPB& pb,
void PartitionSchema::ToPB(PartitionSchemaPB* pb) const {
pb->Clear();
pb->mutable_hash_bucket_schemas()->Reserve(hash_bucket_schemas_.size());
- BOOST_FOREACH(const HashBucketSchema& hash_bucket, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket : hash_bucket_schemas_) {
PartitionSchemaPB_HashBucketSchemaPB* hash_bucket_pb = pb->add_hash_bucket_schemas();
SetColumnIdentifiers(hash_bucket.column_ids, hash_bucket_pb->mutable_columns());
hash_bucket_pb->set_num_buckets(hash_bucket.num_buckets);
@@ -174,7 +172,7 @@ void PartitionSchema::ToPB(PartitionSchemaPB* pb) const {
Status PartitionSchema::EncodeKey(const KuduPartialRow& row, string* buf) const {
const KeyEncoder<string>& hash_encoder = GetKeyEncoder<string>(GetTypeInfo(UINT32));
- BOOST_FOREACH(const HashBucketSchema& hash_bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket_schema : hash_bucket_schemas_) {
int32_t bucket;
RETURN_NOT_OK(BucketForRow(row, hash_bucket_schema, &bucket));
hash_encoder.Encode(&bucket, buf);
@@ -186,7 +184,7 @@ Status PartitionSchema::EncodeKey(const KuduPartialRow& row, string* buf) const
Status PartitionSchema::EncodeKey(const ConstContiguousRow& row, string* buf) const {
const KeyEncoder<string>& hash_encoder = GetKeyEncoder<string>(GetTypeInfo(UINT32));
- BOOST_FOREACH(const HashBucketSchema& hash_bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket_schema : hash_bucket_schemas_) {
int32_t bucket;
RETURN_NOT_OK(BucketForRow(row, hash_bucket_schema, &bucket));
hash_encoder.Encode(&bucket, buf);
@@ -202,11 +200,11 @@ Status PartitionSchema::CreatePartitions(const vector<KuduPartialRow>& split_row
// Create a partition per hash bucket combination.
*partitions = vector<Partition>(1);
- BOOST_FOREACH(const HashBucketSchema& bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& bucket_schema : hash_bucket_schemas_) {
vector<Partition> new_partitions;
// For each of the partitions created so far, replicate it
// by the number of buckets in the next hash bucketing component
- BOOST_FOREACH(const Partition& base_partition, *partitions) {
+ for (const Partition& base_partition : *partitions) {
for (int32_t bucket = 0; bucket < bucket_schema.num_buckets; bucket++) {
Partition partition = base_partition;
partition.hash_buckets_.push_back(bucket);
@@ -219,7 +217,7 @@ Status PartitionSchema::CreatePartitions(const vector<KuduPartialRow>& split_row
}
unordered_set<int> range_column_idxs;
- BOOST_FOREACH(ColumnId column_id, range_schema_.column_ids) {
+ for (ColumnId column_id : range_schema_.column_ids) {
int column_idx = schema.find_column_by_id(column_id);
if (column_idx == Schema::kColumnNotFound) {
return Status::InvalidArgument(Substitute("Range partition column ID $0 "
@@ -234,7 +232,7 @@ Status PartitionSchema::CreatePartitions(const vector<KuduPartialRow>& split_row
// Create the start range keys.
set<string> start_keys;
string start_key;
- BOOST_FOREACH(const KuduPartialRow& row, split_rows) {
+ for (const KuduPartialRow& row : split_rows) {
int column_count = 0;
for (int column_idx = 0; column_idx < schema.num_columns(); column_idx++) {
const ColumnSchema& column = schema.column(column_idx);
@@ -265,10 +263,10 @@ Status PartitionSchema::CreatePartitions(const vector<KuduPartialRow>& split_row
// Create a partition per range and hash bucket combination.
vector<Partition> new_partitions;
- BOOST_FOREACH(const Partition& base_partition, *partitions) {
+ for (const Partition& base_partition : *partitions) {
start_key.clear();
- BOOST_FOREACH(const string& end_key, start_keys) {
+ for (const string& end_key : start_keys) {
Partition partition = base_partition;
partition.partition_key_start_.append(start_key);
partition.partition_key_end_.append(end_key);
@@ -300,7 +298,7 @@ Status PartitionSchema::CreatePartitions(const vector<KuduPartialRow>& split_row
// the absolute start and end case, these holes are filled by clearing the
// partition key beginning at the hash component. For a concrete example,
// see PartitionTest::TestCreatePartitions.
- BOOST_FOREACH(Partition& partition, *partitions) {
+ for (Partition& partition : *partitions) {
if (partition.range_key_start().empty()) {
for (int i = partition.hash_buckets().size() - 1; i >= 0; i--) {
if (partition.hash_buckets()[i] != 0) {
@@ -425,7 +423,7 @@ string PartitionSchema::PartitionDebugString(const Partition& partition,
if (!partition.hash_buckets().empty()) {
vector<string> components;
- BOOST_FOREACH(int32_t bucket, partition.hash_buckets()) {
+ for (int32_t bucket : partition.hash_buckets()) {
components.push_back(Substitute("$0", bucket));
}
s.append("hash buckets: (");
@@ -476,7 +474,7 @@ void PartitionSchema::AppendRangeDebugStringComponentsOrString(const KuduPartial
vector<string>* components) const {
ConstContiguousRow const_row(row.schema(), row.row_data_);
- BOOST_FOREACH(ColumnId column_id, range_schema_.column_ids) {
+ for (ColumnId column_id : range_schema_.column_ids) {
string column;
int32_t column_idx = row.schema()->find_column_by_id(column_id);
if (column_idx == Schema::kColumnNotFound) {
@@ -500,7 +498,7 @@ void PartitionSchema::AppendRangeDebugStringComponentsOrMin(const KuduPartialRow
vector<string>* components) const {
ConstContiguousRow const_row(row.schema(), row.row_data_);
- BOOST_FOREACH(ColumnId column_id, range_schema_.column_ids) {
+ for (ColumnId column_id : range_schema_.column_ids) {
string column;
int32_t column_idx = row.schema()->find_column_by_id(column_id);
if (column_idx == Schema::kColumnNotFound) {
@@ -525,7 +523,7 @@ void PartitionSchema::AppendRangeDebugStringComponentsOrMin(const KuduPartialRow
string PartitionSchema::RowDebugString(const ConstContiguousRow& row) const {
vector<string> components;
- BOOST_FOREACH(const HashBucketSchema& hash_bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket_schema : hash_bucket_schemas_) {
int32_t bucket;
Status s = BucketForRow(row, hash_bucket_schema, &bucket);
if (s.ok()) {
@@ -535,7 +533,7 @@ string PartitionSchema::RowDebugString(const ConstContiguousRow& row) const {
}
}
- BOOST_FOREACH(ColumnId column_id, range_schema_.column_ids) {
+ for (ColumnId column_id : range_schema_.column_ids) {
string column;
int32_t column_idx = row.schema()->find_column_by_id(column_id);
if (column_idx == Schema::kColumnNotFound) {
@@ -552,7 +550,7 @@ string PartitionSchema::RowDebugString(const ConstContiguousRow& row) const {
string PartitionSchema::RowDebugString(const KuduPartialRow& row) const {
vector<string> components;
- BOOST_FOREACH(const HashBucketSchema& hash_bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket_schema : hash_bucket_schemas_) {
int32_t bucket;
Status s = BucketForRow(row, hash_bucket_schema, &bucket);
if (s.ok()) {
@@ -578,7 +576,7 @@ string PartitionSchema::PartitionKeyDebugString(const string& key, const Schema&
if (!s.ok()) {
return Substitute("<hash-decode-error: $0>", s.ToString());
}
- BOOST_FOREACH(int32_t bucket, buckets) {
+ for (int32_t bucket : buckets) {
components.push_back(Substitute("bucket=$0", bucket));
}
}
@@ -604,7 +602,7 @@ namespace {
string ColumnIdsToColumnNames(const Schema& schema,
const vector<ColumnId> column_ids) {
vector<string> names;
- BOOST_FOREACH(ColumnId column_id, column_ids) {
+ for (ColumnId column_id : column_ids) {
names.push_back(schema.column(schema.find_column_by_id(column_id)).name());
}
@@ -617,7 +615,7 @@ string PartitionSchema::DebugString(const Schema& schema) const {
if (!hash_bucket_schemas_.empty()) {
vector<string> hash_components;
- BOOST_FOREACH(const HashBucketSchema& hash_bucket_schema, hash_bucket_schemas_) {
+ for (const HashBucketSchema& hash_bucket_schema : hash_bucket_schemas_) {
string component;
component.append(Substitute("(bucket count: $0", hash_bucket_schema.num_buckets));
if (hash_bucket_schema.seed != 0) {
@@ -743,7 +741,7 @@ void PartitionSchema::Clear() {
Status PartitionSchema::Validate(const Schema& schema) const {
set<ColumnId> hash_columns;
- BOOST_FOREACH(const PartitionSchema::HashBucketSchema& hash_schema, hash_bucket_schemas_) {
+ for (const PartitionSchema::HashBucketSchema& hash_schema : hash_bucket_schemas_) {
if (hash_schema.num_buckets < 2) {
return Status::InvalidArgument("must have at least two hash buckets");
}
@@ -752,7 +750,7 @@ Status PartitionSchema::Validate(const Schema& schema) const {
return Status::InvalidArgument("must have at least one hash column");
}
- BOOST_FOREACH(ColumnId hash_column, hash_schema.column_ids) {
+ for (ColumnId hash_column : hash_schema.column_ids) {
if (!hash_columns.insert(hash_column).second) {
return Status::InvalidArgument("hash bucket schema components must not "
"contain columns in common");
@@ -768,7 +766,7 @@ Status PartitionSchema::Validate(const Schema& schema) const {
}
}
- BOOST_FOREACH(ColumnId column_id, range_schema_.column_ids) {
+ for (ColumnId column_id : range_schema_.column_ids) {
int32_t column_idx = schema.find_column_by_id(column_id);
if (column_idx == Schema::kColumnNotFound) {
return Status::InvalidArgument("must specify existing columns for range "
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/predicate_encoder.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/predicate_encoder.cc b/src/kudu/common/predicate_encoder.cc
index c693fa9..436cfe3 100644
--- a/src/kudu/common/predicate_encoder.cc
+++ b/src/kudu/common/predicate_encoder.cc
@@ -111,7 +111,7 @@ void RangePredicateEncoder::EncodeRangePredicates(ScanSpec *spec, bool erase_pus
memcpy(upper_key.mutable_cell_ptr(n_pushed), key_bounds[n_pushed].upper, size);
upper_len++;
}
- BOOST_FOREACH(int pred_idx, key_bounds[n_pushed].orig_predicate_indexes) {
+ for (int pred_idx : key_bounds[n_pushed].orig_predicate_indexes) {
was_pushed[pred_idx] = true;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/rowblock.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/rowblock.cc b/src/kudu/common/rowblock.cc
index 21111ca..13ec37b 100644
--- a/src/kudu/common/rowblock.cc
+++ b/src/kudu/common/rowblock.cc
@@ -98,10 +98,10 @@ RowBlock::RowBlock(const Schema &schema,
}
RowBlock::~RowBlock() {
- BOOST_FOREACH(uint8_t *column_data, columns_data_) {
+ for (uint8_t *column_data : columns_data_) {
delete[] column_data;
}
- BOOST_FOREACH(uint8_t *bitmap_data, column_null_bitmaps_) {
+ for (uint8_t *bitmap_data : column_null_bitmaps_) {
delete[] bitmap_data;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/scan_spec.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/scan_spec.cc b/src/kudu/common/scan_spec.cc
index 3e953d0..9a24328 100644
--- a/src/kudu/common/scan_spec.cc
+++ b/src/kudu/common/scan_spec.cc
@@ -82,7 +82,7 @@ string ScanSpec::ToStringWithOptionalSchema(const Schema* s) const {
}
}
- BOOST_FOREACH(const ColumnRangePredicate& pred, predicates_) {
+ for (const ColumnRangePredicate& pred : predicates_) {
preds.push_back(pred.ToString());
}
return JoinStrings(preds, "\n");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9daafa5e/src/kudu/common/schema-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema-test.cc b/src/kudu/common/schema-test.cc
index cb63ffa..b29f04d 100644
--- a/src/kudu/common/schema-test.cc
+++ b/src/kudu/common/schema-test.cc
@@ -293,7 +293,7 @@ TEST(TestKeyEncoder, TestKeyEncoder) {
Slice("xxx" "\x00\x01" "yyy" "\x00\x00" "bar", 13)));
int i = 0;
- BOOST_FOREACH(const test_pair &t, pairs) {
+ for (const test_pair &t : pairs) {
const vector<Slice> &in = std::get<0>(t);
Slice expected = std::get<1>(t);