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/13 18:18:19 UTC
[4/9] incubator-kudu git commit: Enable C++11
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/rpcz-path-handler.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpcz-path-handler.cc b/src/kudu/server/rpcz-path-handler.cc
index fbe4863..9df2132 100644
--- a/src/kudu/server/rpcz-path-handler.cc
+++ b/src/kudu/server/rpcz-path-handler.cc
@@ -18,8 +18,8 @@
#include "kudu/server/rpcz-path-handler.h"
#include <boost/bind.hpp>
-#include <tr1/memory>
#include <fstream>
+#include <memory>
#include <string>
#include "kudu/gutil/map-util.h"
@@ -28,16 +28,17 @@
#include "kudu/rpc/rpc_introspection.pb.h"
#include "kudu/server/webserver.h"
-using kudu::rpc::Messenger;
using kudu::rpc::DumpRunningRpcsRequestPB;
using kudu::rpc::DumpRunningRpcsResponsePB;
+using kudu::rpc::Messenger;
+using std::shared_ptr;
using std::stringstream;
namespace kudu {
namespace {
-void RpczPathHandler(const std::tr1::shared_ptr<Messenger>& messenger,
+void RpczPathHandler(const shared_ptr<Messenger>& messenger,
const Webserver::WebRequest& req, stringstream* output) {
DumpRunningRpcsRequestPB dump_req;
DumpRunningRpcsResponsePB dump_resp;
@@ -53,7 +54,7 @@ void RpczPathHandler(const std::tr1::shared_ptr<Messenger>& messenger,
} // anonymous namespace
-void AddRpczPathHandlers(const std::tr1::shared_ptr<Messenger>& messenger, Webserver* webserver) {
+void AddRpczPathHandlers(const shared_ptr<Messenger>& messenger, Webserver* webserver) {
webserver->RegisterPathHandler("/rpcz", "RPCs",
boost::bind(RpczPathHandler, messenger, _1, _2),
false, true);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/rpcz-path-handler.h
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpcz-path-handler.h b/src/kudu/server/rpcz-path-handler.h
index 9cfb70c..388c78c 100644
--- a/src/kudu/server/rpcz-path-handler.h
+++ b/src/kudu/server/rpcz-path-handler.h
@@ -17,7 +17,7 @@
#ifndef KUDU_SERVER_RPCZ_PATH_HANDLER_H
#define KUDU_SERVER_RPCZ_PATH_HANDLER_H
-#include <tr1/memory>
+#include <memory>
namespace kudu {
@@ -27,7 +27,7 @@ class Messenger;
class Webserver;
-void AddRpczPathHandlers(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+void AddRpczPathHandlers(const std::shared_ptr<rpc::Messenger>& messenger,
Webserver* webserver);
} // namespace kudu
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/server_base.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/server_base.cc b/src/kudu/server/server_base.cc
index 79024cf..4ad42ed 100644
--- a/src/kudu/server/server_base.cc
+++ b/src/kudu/server/server_base.cc
@@ -60,9 +60,9 @@ TAG_FLAG(num_reactor_threads, advanced);
DECLARE_bool(use_hybrid_clock);
+using std::shared_ptr;
using std::string;
using std::stringstream;
-using std::tr1::shared_ptr;
using std::vector;
using strings::Substitute;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/server/server_base.h
----------------------------------------------------------------------
diff --git a/src/kudu/server/server_base.h b/src/kudu/server/server_base.h
index cfb15b3..af4ca63 100644
--- a/src/kudu/server/server_base.h
+++ b/src/kudu/server/server_base.h
@@ -17,8 +17,8 @@
#ifndef KUDU_SERVER_SERVER_BASE_H
#define KUDU_SERVER_SERVER_BASE_H
+#include <memory>
#include <string>
-#include <tr1/memory>
#include "kudu/gutil/gscoped_ptr.h"
#include "kudu/gutil/macros.h"
@@ -59,7 +59,7 @@ class ServerBase {
public:
const RpcServer *rpc_server() const { return rpc_server_.get(); }
const Webserver *web_server() const { return web_server_.get(); }
- const std::tr1::shared_ptr<rpc::Messenger>& messenger() const { return messenger_; }
+ const std::shared_ptr<rpc::Messenger>& messenger() const { return messenger_; }
// Return the first RPC address that this server has bound to.
// FATALs if the server is not started.
@@ -75,7 +75,7 @@ class ServerBase {
// This may not be called until after the server is Initted.
const NodeInstancePB& instance_pb() const;
- const std::tr1::shared_ptr<MemTracker>& mem_tracker() const { return mem_tracker_; }
+ const std::shared_ptr<MemTracker>& mem_tracker() const { return mem_tracker_; }
const scoped_refptr<MetricEntity>& metric_entity() const { return metric_entity_; }
@@ -100,13 +100,13 @@ class ServerBase {
const std::string name_;
- std::tr1::shared_ptr<MemTracker> mem_tracker_;
+ std::shared_ptr<MemTracker> mem_tracker_;
gscoped_ptr<MetricRegistry> metric_registry_;
scoped_refptr<MetricEntity> metric_entity_;
gscoped_ptr<FsManager> fs_manager_;
gscoped_ptr<RpcServer> rpc_server_;
gscoped_ptr<Webserver> web_server_;
- std::tr1::shared_ptr<rpc::Messenger> messenger_;
+ std::shared_ptr<rpc::Messenger> messenger_;
bool is_first_run_;
scoped_refptr<Clock> clock_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 4a0064e..bfc593a 100644
--- a/src/kudu/server/tracing-path-handlers.cc
+++ b/src/kudu/server/tracing-path-handlers.cc
@@ -21,7 +21,6 @@
#include <utility>
#include <vector>
-#include <boost/assign/list_of.hpp>
#include <boost/bind.hpp>
#include <boost/foreach.hpp>
#include <rapidjson/document.h>
@@ -244,16 +243,16 @@ void HandleRequest(Handler handler,
void TracingPathHandlers::RegisterHandlers(Webserver* server) {
// All of the tracing-related hand
- std::map<string, Handler> handlers = boost::assign::map_list_of
- ("/tracing/json/begin_monitoring", kBeginMonitoring)
- ("/tracing/json/end_monitoring", kEndMonitoring)
- ("/tracing/json/capture_monitoring", kCaptureMonitoring)
- ("/tracing/json/get_monitoring_status", kGetMonitoringStatus)
- ("/tracing/json/categories", kCategories)
- ("/tracing/json/begin_recording", kBeginRecording)
- ("/tracing/json/get_buffer_percent_full", kGetBufferPercentFull)
- ("/tracing/json/end_recording", kEndRecording)
- ("/tracing/json/simple_dump", kSimpleDump);
+ std::map<string, Handler> handlers = {
+ { "/tracing/json/begin_monitoring", kBeginMonitoring },
+ { "/tracing/json/end_monitoring", kEndMonitoring },
+ { "/tracing/json/capture_monitoring", kCaptureMonitoring },
+ { "/tracing/json/get_monitoring_status", kGetMonitoringStatus },
+ { "/tracing/json/categories", kCategories },
+ { "/tracing/json/begin_recording", kBeginRecording },
+ { "/tracing/json/get_buffer_percent_full", kGetBufferPercentFull },
+ { "/tracing/json/end_recording", kEndRecording },
+ { "/tracing/json/simple_dump", kSimpleDump } };
typedef pair<string, Handler> HandlerPair;
BOOST_FOREACH(const HandlerPair& e, handlers) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 7f8782a..cdda87b 100644
--- a/src/kudu/tablet/cfile_set-test.cc
+++ b/src/kudu/tablet/cfile_set-test.cc
@@ -15,9 +15,9 @@
// specific language governing permissions and limitations
// under the License.
+#include <memory>
#include <gtest/gtest.h>
#include <glog/logging.h>
-#include <tr1/memory>
#include "kudu/common/generic_iterators.h"
#include "kudu/tablet/cfile_set.h"
@@ -27,7 +27,7 @@
DECLARE_int32(cfile_default_block_size);
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
namespace tablet {
@@ -35,10 +35,9 @@ namespace tablet {
class TestCFileSet : public KuduRowSetTest {
public:
TestCFileSet() :
- KuduRowSetTest(Schema(boost::assign::list_of
- (ColumnSchema("c0", UINT32))
- (ColumnSchema("c1", UINT32, false, NULL, NULL, GetRLEStorage()))
- (ColumnSchema("c2", UINT32)), 1))
+ KuduRowSetTest(Schema({ ColumnSchema("c0", UINT32),
+ ColumnSchema("c1", UINT32, false, NULL, NULL, GetRLEStorage()),
+ ColumnSchema("c2", UINT32) }, 1))
{}
virtual void SetUp() OVERRIDE {
@@ -209,7 +208,7 @@ TEST_F(TestCFileSet, TestIteratePartialSchema) {
ASSERT_OK(fileset->Open());
Schema new_schema;
- ASSERT_OK(schema_.CreateProjectionByNames(list_of("c0")("c2"), &new_schema));
+ ASSERT_OK(schema_.CreateProjectionByNames({ "c0", "c2" }, &new_schema));
shared_ptr<CFileSet::Iterator> cfile_iter(fileset->NewIterator(&new_schema));
gscoped_ptr<RowwiseIterator> iter(new MaterializingIterator(cfile_iter));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/cfile_set.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cfile_set.cc b/src/kudu/tablet/cfile_set.cc
index f5ada33..789077e 100644
--- a/src/kudu/tablet/cfile_set.cc
+++ b/src/kudu/tablet/cfile_set.cc
@@ -15,11 +15,9 @@
// specific language governing permissions and limitations
// under the License.
+#include <algorithm>
#include <gflags/gflags.h>
#include <glog/logging.h>
-#include <tr1/memory>
-#include <algorithm>
-#include <vector>
#include "kudu/cfile/bloomfile.h"
#include "kudu/cfile/cfile_util.h"
@@ -42,7 +40,7 @@ namespace tablet {
using cfile::ReaderOptions;
using cfile::DefaultColumnValueIterator;
using fs::ReadableBlock;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
using strings::Substitute;
////////////////////////////////////////////////////////////
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/cfile_set.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cfile_set.h b/src/kudu/tablet/cfile_set.h
index ad62990..348edd3 100644
--- a/src/kudu/tablet/cfile_set.h
+++ b/src/kudu/tablet/cfile_set.h
@@ -18,9 +18,9 @@
#define KUDU_TABLET_LAYER_BASEDATA_H
#include <gtest/gtest_prod.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <memory>
#include <string>
+#include <unordered_map>
#include <vector>
#include "kudu/cfile/bloomfile.h"
@@ -53,11 +53,11 @@ using kudu::cfile::ColumnIterator;
//
// All of these files have the same number of rows, and thus the positional
// indexes can be used to seek to corresponding entries in each.
-class CFileSet : public std::tr1::enable_shared_from_this<CFileSet> {
+class CFileSet : public std::enable_shared_from_this<CFileSet> {
public:
class Iterator;
- explicit CFileSet(const std::tr1::shared_ptr<RowSetMetadata>& rowset_metadata);
+ explicit CFileSet(const std::shared_ptr<RowSetMetadata>& rowset_metadata);
Status Open();
@@ -112,13 +112,13 @@ class CFileSet : public std::tr1::enable_shared_from_this<CFileSet> {
const Schema &tablet_schema() const { return rowset_metadata_->tablet_schema(); }
- std::tr1::shared_ptr<RowSetMetadata> rowset_metadata_;
+ std::shared_ptr<RowSetMetadata> rowset_metadata_;
std::string min_encoded_key_;
std::string max_encoded_key_;
// Map of column ID to reader. These are lazily initialized as needed.
- typedef std::tr1::unordered_map<int, std::tr1::shared_ptr<CFileReader> > ReaderMap;
+ typedef std::unordered_map<int, std::shared_ptr<CFileReader> > ReaderMap;
ReaderMap readers_by_col_id_;
// A file reader for an ad-hoc index, i.e. an index that sits in its own file
@@ -177,7 +177,7 @@ class CFileSet::Iterator : public ColumnwiseIterator {
friend class CFileSet;
// 'projection' must remain valid for the lifetime of this object.
- Iterator(const std::tr1::shared_ptr<CFileSet const> &base_data,
+ Iterator(const std::shared_ptr<CFileSet const> &base_data,
const Schema *projection)
: base_data_(base_data),
projection_(projection),
@@ -200,7 +200,7 @@ class CFileSet::Iterator : public ColumnwiseIterator {
// Prepare the given column if not already prepared.
Status PrepareColumn(size_t col_idx);
- const std::tr1::shared_ptr<CFileSet const> base_data_;
+ const std::shared_ptr<CFileSet const> base_data_;
const Schema* projection_;
// Iterator for the key column in the underlying data.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction-test.cc b/src/kudu/tablet/compaction-test.cc
index d211abd..a3446b8 100644
--- a/src/kudu/tablet/compaction-test.cc
+++ b/src/kudu/tablet/compaction-test.cc
@@ -16,11 +16,10 @@
// under the License.
#include <algorithm>
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
-#include <tr1/memory>
+#include <memory>
#include "kudu/common/partial_row.h"
#include "kudu/consensus/log_anchor_registry.h"
@@ -50,7 +49,7 @@ DEFINE_int32(merge_benchmark_num_rows_per_rowset, 500000,
DECLARE_string(block_manager);
DECLARE_bool(enable_data_block_fsync);
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
namespace tablet {
@@ -605,11 +604,7 @@ TEST_F(TestCompaction, TestOneToOne) {
string dummy_name = "";
- ASSERT_OK(ReupdateMissedDeltas(dummy_name,
- input.get(),
- snap,
- snap2,
- boost::assign::list_of(rs)));
+ ASSERT_OK(ReupdateMissedDeltas(dummy_name, input.get(), snap, snap2, { rs }));
// If we look at the contents of the DiskRowSet now, we should see the "re-updated" data.
vector<string> out;
@@ -662,11 +657,7 @@ TEST_F(TestCompaction, TestKUDU102) {
string dummy_name = "";
// This would fail without KUDU-102
- ASSERT_OK(ReupdateMissedDeltas(dummy_name,
- input.get(),
- snap,
- snap2,
- boost::assign::list_of(rs) (rs_b)));
+ ASSERT_OK(ReupdateMissedDeltas(dummy_name, input.get(), snap, snap2, { rs, rs_b }));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction.cc b/src/kudu/tablet/compaction.cc
index a262415..52b2be2 100644
--- a/src/kudu/tablet/compaction.cc
+++ b/src/kudu/tablet/compaction.cc
@@ -17,11 +17,11 @@
#include "kudu/tablet/compaction.h"
-#include <glog/logging.h>
#include <deque>
+#include <glog/logging.h>
+#include <memory>
#include <string>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <unordered_set>
#include <vector>
#include "kudu/common/wire_protocol.h"
@@ -38,8 +38,8 @@
#include "kudu/tablet/transactions/write_transaction.h"
#include "kudu/util/debug/trace_event.h"
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
+using std::unordered_set;
using strings::Substitute;
namespace kudu {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/compaction.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction.h b/src/kudu/tablet/compaction.h
index 58ce8ce..99a6dda 100644
--- a/src/kudu/tablet/compaction.h
+++ b/src/kudu/tablet/compaction.h
@@ -17,8 +17,8 @@
#ifndef KUDU_TABLET_COMPACTION_H
#define KUDU_TABLET_COMPACTION_H
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/common/generic_iterators.h"
@@ -56,7 +56,7 @@ class CompactionInput {
// Create an input which merges several other compaction inputs. The inputs are merged
// in key-order according to the given schema. All inputs must have matching schemas.
- static CompactionInput *Merge(const vector<std::tr1::shared_ptr<CompactionInput> > &inputs,
+ static CompactionInput *Merge(const vector<std::shared_ptr<CompactionInput> > &inputs,
const Schema *schema);
virtual Status Init() = 0;
@@ -77,8 +77,8 @@ class CompactionInput {
// The set of rowsets which are taking part in a given compaction.
class RowSetsInCompaction {
public:
- void AddRowSet(const std::tr1::shared_ptr<RowSet> &rowset,
- const std::tr1::shared_ptr<boost::mutex::scoped_try_lock> &lock) {
+ void AddRowSet(const std::shared_ptr<RowSet> &rowset,
+ const std::shared_ptr<boost::mutex::scoped_try_lock> &lock) {
CHECK(lock->owns_lock());
locks_.push_back(lock);
@@ -92,7 +92,7 @@ class RowSetsInCompaction {
// for the lifetime of the returned CompactionInput.
Status CreateCompactionInput(const MvccSnapshot &snap,
const Schema* schema,
- std::tr1::shared_ptr<CompactionInput> *out) const;
+ std::shared_ptr<CompactionInput> *out) const;
// Dump a log message indicating the chosen rowsets.
void DumpToLog() const;
@@ -104,7 +104,7 @@ class RowSetsInCompaction {
}
private:
- typedef vector<std::tr1::shared_ptr<boost::mutex::scoped_try_lock> > LockVector;
+ typedef vector<std::shared_ptr<boost::mutex::scoped_try_lock> > LockVector;
RowSetVector rowsets_;
LockVector locks_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/compaction_policy-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction_policy-test.cc b/src/kudu/tablet/compaction_policy-test.cc
index bb745a8..1d8075c 100644
--- a/src/kudu/tablet/compaction_policy-test.cc
+++ b/src/kudu/tablet/compaction_policy-test.cc
@@ -16,8 +16,8 @@
// under the License.
#include <gtest/gtest.h>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <memory>
+#include <unordered_set>
#include "kudu/util/test_util.h"
#include "kudu/tablet/mock-rowsets.h"
@@ -25,8 +25,8 @@
#include "kudu/tablet/rowset_tree.h"
#include "kudu/tablet/compaction_policy.h"
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
+using std::unordered_set;
namespace kudu {
namespace tablet {
@@ -45,7 +45,7 @@ TEST(TestCompactionPolicy, TestBudgetedSelection) {
const int kBudgetMb = 1000; // enough to select all
BudgetedCompactionPolicy policy(kBudgetMb);
- std::tr1::unordered_set<RowSet*> picked;
+ unordered_set<RowSet*> picked;
double quality = 0;
ASSERT_OK(policy.PickRowSets(tree, &picked, &quality, NULL));
ASSERT_EQ(3, picked.size());
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/compaction_policy.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction_policy.h b/src/kudu/tablet/compaction_policy.h
index d72b507..7f660ee 100644
--- a/src/kudu/tablet/compaction_policy.h
+++ b/src/kudu/tablet/compaction_policy.h
@@ -17,14 +17,14 @@
#ifndef KUDU_TABLET_COMPACTION_POLICY_H
#define KUDU_TABLET_COMPACTION_POLICY_H
+#include <string>
+#include <unordered_set>
+#include <vector>
+
#include "kudu/gutil/macros.h"
#include "kudu/util/slice.h"
#include "kudu/util/status.h"
-#include <string>
-#include <vector>
-#include <tr1/unordered_set>
-
namespace kudu {
namespace tablet {
@@ -54,7 +54,7 @@ class CompactionPolicy {
// If 'log' is not NULL, then a verbose log of the compaction selection
// process will be appended to it.
virtual Status PickRowSets(const RowSetTree &tree,
- std::tr1::unordered_set<RowSet*>* picked,
+ std::unordered_set<RowSet*>* picked,
double* quality,
std::vector<std::string>* log) = 0;
@@ -79,7 +79,7 @@ class BudgetedCompactionPolicy : public CompactionPolicy {
explicit BudgetedCompactionPolicy(int size_budget_mb);
virtual Status PickRowSets(const RowSetTree &tree,
- std::tr1::unordered_set<RowSet*>* picked,
+ std::unordered_set<RowSet*>* picked,
double* quality,
std::vector<std::string>* log) OVERRIDE;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 ebf3a58..8502cd2 100644
--- a/src/kudu/tablet/composite-pushdown-test.cc
+++ b/src/kudu/tablet/composite-pushdown-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -33,12 +32,11 @@ const char* const kTestHostnames[] = { "foo", "foobar", "baz", NULL };
class CompositePushdownTest : public KuduTabletTest {
public:
CompositePushdownTest()
- : KuduTabletTest(Schema(boost::assign::list_of
- (ColumnSchema("year", INT16))
- (ColumnSchema("month", INT8))
- (ColumnSchema("day", INT8))
- (ColumnSchema("hostname", STRING))
- (ColumnSchema("data", STRING)),
+ : KuduTabletTest(Schema({ ColumnSchema("year", INT16),
+ ColumnSchema("month", INT8),
+ ColumnSchema("day", INT8),
+ ColumnSchema("hostname", STRING),
+ ColumnSchema("data", STRING) },
4)) {
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/concurrent_btree.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/concurrent_btree.h b/src/kudu/tablet/concurrent_btree.h
index 9a90b4c..84a260a 100644
--- a/src/kudu/tablet/concurrent_btree.h
+++ b/src/kudu/tablet/concurrent_btree.h
@@ -38,10 +38,12 @@
#ifndef KUDU_TABLET_CONCURRENT_BTREE_H
#define KUDU_TABLET_CONCURRENT_BTREE_H
+#include <algorithm>
#include <boost/smart_ptr/detail/yield_k.hpp>
#include <boost/utility/binary.hpp>
-#include <algorithm>
+#include <memory>
#include <string>
+
#include "kudu/util/inline_slice.h"
#include "kudu/util/memory/arena.h"
#include "kudu/util/status.h"
@@ -938,7 +940,7 @@ class CBTree {
frozen_(false) {
}
- explicit CBTree(const std::tr1::shared_ptr<typename Traits::ArenaType>& arena)
+ explicit CBTree(const std::shared_ptr<typename Traits::ArenaType>& arena)
: arena_(arena),
root_(NewLeaf(false)),
frozen_(false) {
@@ -1579,7 +1581,7 @@ class CBTree {
// No need to actually free, since it came from the arena
}
- std::tr1::shared_ptr<typename Traits::ArenaType> arena_;
+ std::shared_ptr<typename Traits::ArenaType> arena_;
// marked 'mutable' because readers will lazy-update the root
// when they encounter a stale root pointer.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_applier.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_applier.cc b/src/kudu/tablet/delta_applier.cc
index bc27ada..f809f21 100644
--- a/src/kudu/tablet/delta_applier.cc
+++ b/src/kudu/tablet/delta_applier.cc
@@ -24,8 +24,8 @@
#include "kudu/tablet/delta_store.h"
#include "kudu/util/status.h"
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
namespace kudu {
namespace tablet {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_applier.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_applier.h b/src/kudu/tablet/delta_applier.h
index f636071..da37458 100644
--- a/src/kudu/tablet/delta_applier.h
+++ b/src/kudu/tablet/delta_applier.h
@@ -18,7 +18,7 @@
#define KUDU_TABLET_DELTA_APPLIER_H
#include <string>
-#include <tr1/memory>
+#include <memory>
#include <vector>
#include <gtest/gtest_prod.h>
@@ -70,12 +70,12 @@ class DeltaApplier : public ColumnwiseIterator {
DISALLOW_COPY_AND_ASSIGN(DeltaApplier);
// Construct. The base_iter and delta_iter should not be Initted.
- DeltaApplier(const std::tr1::shared_ptr<CFileSet::Iterator>& base_iter,
- const std::tr1::shared_ptr<DeltaIterator>& delta_iter);
+ DeltaApplier(const std::shared_ptr<CFileSet::Iterator>& base_iter,
+ const std::shared_ptr<DeltaIterator>& delta_iter);
virtual ~DeltaApplier();
- std::tr1::shared_ptr<CFileSet::Iterator> base_iter_;
- std::tr1::shared_ptr<DeltaIterator> delta_iter_;
+ std::shared_ptr<CFileSet::Iterator> base_iter_;
+ std::shared_ptr<DeltaIterator> delta_iter_;
bool first_prepare_;
};
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 987b610..3900692 100644
--- a/src/kudu/tablet/delta_compaction-test.cc
+++ b/src/kudu/tablet/delta_compaction-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -41,8 +40,9 @@
DEFINE_int32(num_rows, 2100, "the first row to update");
DEFINE_int32(num_delta_files, 3, "number of delta files");
+using std::is_sorted;
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
using std::vector;
namespace kudu {
@@ -50,7 +50,6 @@ namespace tablet {
using fs::ReadableBlock;
using fs::WritableBlock;
-using util::gtl::is_sorted;
class TestDeltaCompaction : public KuduTest {
public:
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction.cc b/src/kudu/tablet/delta_compaction.cc
index c948bdc..9093248 100644
--- a/src/kudu/tablet/delta_compaction.cc
+++ b/src/kudu/tablet/delta_compaction.cc
@@ -17,11 +17,9 @@
#include "kudu/tablet/delta_compaction.h"
+#include <algorithm>
#include <string>
#include <vector>
-#include <algorithm>
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
#include "kudu/common/generic_iterators.h"
#include "kudu/gutil/stl_util.h"
@@ -37,14 +35,15 @@
#include "kudu/tablet/multi_column_writer.h"
#include "kudu/tablet/mvcc.h"
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
+using cfile::CFileIterator;
using cfile::CFileReader;
using cfile::IndexTreeIterator;
-using cfile::CFileIterator;
using fs::WritableBlock;
+using std::vector;
using strings::Substitute;
namespace tablet {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_compaction.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction.h b/src/kudu/tablet/delta_compaction.h
index 42269e4..048a5dc 100644
--- a/src/kudu/tablet/delta_compaction.h
+++ b/src/kudu/tablet/delta_compaction.h
@@ -17,9 +17,9 @@
#ifndef KUDU_TABLET_DELTA_COMPACTION_H
#define KUDU_TABLET_DELTA_COMPACTION_H
+#include <memory>
#include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
#include <utility>
#include <vector>
@@ -55,8 +55,8 @@ class MajorDeltaCompaction {
MajorDeltaCompaction(FsManager* fs_manager,
const Schema& base_schema,
CFileSet* base_data,
- const std::tr1::shared_ptr<DeltaIterator>& delta_iter,
- const std::vector<std::tr1::shared_ptr<DeltaStore> >& included_stores,
+ const std::shared_ptr<DeltaIterator>& delta_iter,
+ const std::vector<std::shared_ptr<DeltaStore> >& included_stores,
const std::vector<ColumnId>& col_ids);
~MajorDeltaCompaction();
@@ -114,7 +114,7 @@ class MajorDeltaCompaction {
const SharedDeltaStoreVector included_stores_;
// The merged view of the deltas from included_stores_.
- const std::tr1::shared_ptr<DeltaIterator> delta_iter_;
+ const std::shared_ptr<DeltaIterator> delta_iter_;
// Outputs:
gscoped_ptr<MultiColumnWriter> base_data_writer_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 c033bb0..5e0f08c 100644
--- a/src/kudu/tablet/delta_iterator_merger.cc
+++ b/src/kudu/tablet/delta_iterator_merger.cc
@@ -27,8 +27,8 @@
namespace kudu {
namespace tablet {
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
using std::vector;
using strings::Substitute;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_iterator_merger.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_iterator_merger.h b/src/kudu/tablet/delta_iterator_merger.h
index 8127542..0021791 100644
--- a/src/kudu/tablet/delta_iterator_merger.h
+++ b/src/kudu/tablet/delta_iterator_merger.h
@@ -18,7 +18,7 @@
#define KUDU_TABLET_DELTA_ITERATOR_MERGER_H
#include <string>
-#include <tr1/memory>
+#include <memory>
#include <vector>
#include "kudu/tablet/delta_store.h"
@@ -39,10 +39,10 @@ class DeltaIteratorMerger : public DeltaIterator {
// If only one store is input, this will automatically return an unwrapped
// iterator for greater efficiency.
static Status Create(
- const std::vector<std::tr1::shared_ptr<DeltaStore> > &stores,
+ const std::vector<std::shared_ptr<DeltaStore> > &stores,
const Schema* projection,
const MvccSnapshot &snapshot,
- std::tr1::shared_ptr<DeltaIterator>* out);
+ std::shared_ptr<DeltaIterator>* out);
////////////////////////////////////////////////////////////
// Implementations of DeltaIterator
@@ -60,9 +60,9 @@ class DeltaIteratorMerger : public DeltaIterator {
virtual std::string ToString() const OVERRIDE;
private:
- explicit DeltaIteratorMerger(const vector<std::tr1::shared_ptr<DeltaIterator> > &iters);
+ explicit DeltaIteratorMerger(const vector<std::shared_ptr<DeltaIterator> > &iters);
- std::vector<std::tr1::shared_ptr<DeltaIterator> > iters_;
+ std::vector<std::shared_ptr<DeltaIterator> > iters_;
};
} // namespace tablet
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_stats.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_stats.h b/src/kudu/tablet/delta_stats.h
index b0aec2a..d10f4b2 100644
--- a/src/kudu/tablet/delta_stats.h
+++ b/src/kudu/tablet/delta_stats.h
@@ -23,7 +23,7 @@
#include <set>
#include <stdint.h>
#include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
#include "kudu/gutil/atomicops.h"
#include "kudu/gutil/map-util.h"
@@ -93,7 +93,7 @@ class DeltaStats {
void AddColumnIdsWithUpdates(std::set<ColumnId>* col_ids) const;
private:
- std::tr1::unordered_map<ColumnId, int64_t> update_counts_by_col_id_;
+ std::unordered_map<ColumnId, int64_t> update_counts_by_col_id_;
uint64_t delete_count_;
Timestamp max_timestamp_;
Timestamp min_timestamp_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_store.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_store.cc b/src/kudu/tablet/delta_store.cc
index 47cfdf0..057579f 100644
--- a/src/kudu/tablet/delta_store.cc
+++ b/src/kudu/tablet/delta_store.cc
@@ -19,15 +19,15 @@
#include <algorithm>
-#include "kudu/gutil/strings/substitute.h"
#include "kudu/gutil/strings/strcat.h"
+#include "kudu/gutil/strings/substitute.h"
#include "kudu/tablet/deltafile.h"
namespace kudu {
namespace tablet {
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
using strings::Substitute;
string DeltaKeyAndUpdate::Stringify(DeltaType type, const Schema& schema) const {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_store.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_store.h b/src/kudu/tablet/delta_store.h
index 4ab56ae..e4dafe6 100644
--- a/src/kudu/tablet/delta_store.h
+++ b/src/kudu/tablet/delta_store.h
@@ -17,9 +17,9 @@
#ifndef KUDU_TABLET_DELTA_STORE_H
#define KUDU_TABLET_DELTA_STORE_H
+#include <memory>
#include <string>
#include <vector>
-#include <tr1/memory>
#include "kudu/common/columnblock.h"
#include "kudu/common/schema.h"
@@ -82,7 +82,7 @@ class DeltaStore {
virtual ~DeltaStore() {}
};
-typedef std::vector<std::tr1::shared_ptr<DeltaStore> > SharedDeltaStoreVector;
+typedef std::vector<std::shared_ptr<DeltaStore> > SharedDeltaStoreVector;
// Iterator over deltas.
// For each rowset, this iterator is constructed alongside the base data iterator,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_tracker.cc b/src/kudu/tablet/delta_tracker.cc
index f8adf50..9d64c9b 100644
--- a/src/kudu/tablet/delta_tracker.cc
+++ b/src/kudu/tablet/delta_tracker.cc
@@ -15,31 +15,27 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <boost/foreach.hpp>
-#include <tr1/memory>
-#include <string>
#include "kudu/gutil/strings/join.h"
#include "kudu/gutil/strings/strip.h"
#include "kudu/gutil/strings/substitute.h"
-#include "kudu/util/status.h"
-#include "kudu/tablet/deltafile.h"
#include "kudu/tablet/delta_applier.h"
#include "kudu/tablet/delta_compaction.h"
#include "kudu/tablet/delta_iterator_merger.h"
#include "kudu/tablet/delta_store.h"
+#include "kudu/tablet/deltafile.h"
#include "kudu/tablet/diskrowset.h"
#include "kudu/tablet/tablet.pb.h"
+#include "kudu/util/status.h"
namespace kudu {
namespace tablet {
-using boost::assign::list_of;
using fs::ReadableBlock;
using fs::WritableBlock;
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
using strings::Substitute;
DeltaTracker::DeltaTracker(const shared_ptr<RowSetMetadata>& rowset_metadata,
@@ -110,7 +106,7 @@ Status DeltaTracker::MakeDeltaIteratorMergerUnlocked(size_t start_idx, size_t en
const Schema* projection,
vector<shared_ptr<DeltaStore> > *target_stores,
vector<BlockId> *target_blocks,
- std::tr1::shared_ptr<DeltaIterator> *out) {
+ std::shared_ptr<DeltaIterator> *out) {
CHECK(open_);
CHECK_LE(start_idx, end_idx);
CHECK_LT(end_idx, redo_delta_stores_.size());
@@ -121,7 +117,7 @@ Status DeltaTracker::MakeDeltaIteratorMergerUnlocked(size_t start_idx, size_t en
// In DEBUG mode, the following asserts that the object is of the right type
// (using RTTI)
ignore_result(down_cast<DeltaFileReader*>(delta_store.get()));
- shared_ptr<DeltaFileReader> dfr = std::tr1::static_pointer_cast<DeltaFileReader>(delta_store);
+ shared_ptr<DeltaFileReader> dfr = std::static_pointer_cast<DeltaFileReader>(delta_store);
LOG(INFO) << "Preparing to minor compact delta file: " << dfr->ToString();
@@ -224,12 +220,12 @@ Status DeltaTracker::CompactStores(int start_idx, int end_idx) {
&compacted_stores, &compacted_blocks));
// Update delta_stores_, removing the compacted delta files and inserted the new
- RETURN_NOT_OK(AtomicUpdateStores(compacted_stores, list_of(new_block_id), REDO));
+ RETURN_NOT_OK(AtomicUpdateStores(compacted_stores, { new_block_id }, REDO));
LOG(INFO) << "Opened delta block for read: " << new_block_id.ToString();
// Update the metadata accordingly
RowSetMetadataUpdate update;
- update.ReplaceRedoDeltaBlocks(compacted_blocks, list_of(new_block_id));
+ update.ReplaceRedoDeltaBlocks(compacted_blocks, { new_block_id });
// TODO: need to have some error handling here -- if we somehow can't persist the
// metadata, do we end up losing data on recovery?
CHECK_OK(rowset_metadata_->CommitUpdate(update));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/delta_tracker.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_tracker.h b/src/kudu/tablet/delta_tracker.h
index 38e4141..e3f6b08 100644
--- a/src/kudu/tablet/delta_tracker.h
+++ b/src/kudu/tablet/delta_tracker.h
@@ -18,6 +18,7 @@
#define KUDU_TABLET_DELTATRACKER_H
#include <gtest/gtest_prod.h>
+#include <memory>
#include <string>
#include <vector>
@@ -66,12 +67,12 @@ class DeltaTracker {
NO_FLUSH_METADATA
};
- DeltaTracker(const std::tr1::shared_ptr<RowSetMetadata>& rowset_metadata,
+ DeltaTracker(const std::shared_ptr<RowSetMetadata>& rowset_metadata,
rowid_t num_rows,
log::LogAnchorRegistry* log_anchor_registry,
- const std::tr1::shared_ptr<MemTracker>& parent_tracker);
+ const std::shared_ptr<MemTracker>& parent_tracker);
- Status WrapIterator(const std::tr1::shared_ptr<CFileSet::Iterator> &base,
+ Status WrapIterator(const std::shared_ptr<CFileSet::Iterator> &base,
const MvccSnapshot &mvcc_snap,
gscoped_ptr<ColumnwiseIterator>* out) const;
@@ -82,7 +83,7 @@ class DeltaTracker {
// It must remain valid for the lifetime of the returned iterator.
Status NewDeltaIterator(const Schema* schema,
const MvccSnapshot& snap,
- std::tr1::shared_ptr<DeltaIterator>* out) const;
+ std::shared_ptr<DeltaIterator>* out) const;
// Like NewDeltaIterator() but only includes file based stores, does not include
// the DMS.
@@ -91,8 +92,8 @@ class DeltaTracker {
const Schema* schema,
const MvccSnapshot &snap,
DeltaType type,
- std::vector<std::tr1::shared_ptr<DeltaStore> >* included_stores,
- std::tr1::shared_ptr<DeltaIterator>* out) const;
+ std::vector<std::shared_ptr<DeltaStore> >* included_stores,
+ std::shared_ptr<DeltaIterator>* out) const;
// CHECKs that the given snapshot includes all of the UNDO stores in this
// delta tracker. If this is not the case, crashes the process. This is
@@ -187,15 +188,15 @@ class DeltaTracker {
FRIEND_TEST(TestMajorDeltaCompaction, TestCompact);
Status OpenDeltaReaders(const std::vector<BlockId>& blocks,
- std::vector<std::tr1::shared_ptr<DeltaStore> >* stores,
+ std::vector<std::shared_ptr<DeltaStore> >* stores,
DeltaType type);
Status FlushDMS(DeltaMemStore* dms,
- std::tr1::shared_ptr<DeltaFileReader>* dfr,
+ std::shared_ptr<DeltaFileReader>* dfr,
MetadataFlushType flush_type);
// This collects all undo and redo stores.
- void CollectStores(vector<std::tr1::shared_ptr<DeltaStore> > *stores) const;
+ void CollectStores(vector<std::shared_ptr<DeltaStore> > *stores) const;
// Performs the actual compaction. Results of compaction are written to "block",
// while delta stores that underwent compaction are appended to "compacted_stores", while
@@ -206,7 +207,7 @@ class DeltaTracker {
// method in order to protect 'redo_delta_stores_'.
Status DoCompactStores(size_t start_idx, size_t end_idx,
gscoped_ptr<fs::WritableBlock> block,
- vector<std::tr1::shared_ptr<DeltaStore> > *compacted_stores,
+ vector<std::shared_ptr<DeltaStore> > *compacted_stores,
std::vector<BlockId>* compacted_blocks);
// Creates a merge delta iterator and captures the delta stores and
@@ -220,11 +221,11 @@ class DeltaTracker {
// race on 'redo_delta_stores_'.
Status MakeDeltaIteratorMergerUnlocked(size_t start_idx, size_t end_idx,
const Schema* schema,
- vector<std::tr1::shared_ptr<DeltaStore > > *target_stores,
+ vector<std::shared_ptr<DeltaStore > > *target_stores,
vector<BlockId> *target_blocks,
- std::tr1::shared_ptr<DeltaIterator> *out);
+ std::shared_ptr<DeltaIterator> *out);
- std::tr1::shared_ptr<RowSetMetadata> rowset_metadata_;
+ std::shared_ptr<RowSetMetadata> rowset_metadata_;
// The number of rows in the DiskRowSet that this tracker is associated with.
// This is just used for assertions to make sure that we don't update a row
@@ -235,10 +236,10 @@ class DeltaTracker {
log::LogAnchorRegistry* log_anchor_registry_;
- std::tr1::shared_ptr<MemTracker> parent_tracker_;
+ std::shared_ptr<MemTracker> parent_tracker_;
// The current DeltaMemStore into which updates should be written.
- std::tr1::shared_ptr<DeltaMemStore> dms_;
+ std::shared_ptr<DeltaMemStore> dms_;
// The set of tracked REDO delta stores, in increasing timestamp order.
SharedDeltaStoreVector redo_delta_stores_;
// The set of tracked UNDO delta stores, in decreasing timestamp order.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltafile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltafile-test.cc b/src/kudu/tablet/deltafile-test.cc
index c043390..e5de159 100644
--- a/src/kudu/tablet/deltafile-test.cc
+++ b/src/kudu/tablet/deltafile-test.cc
@@ -15,10 +15,9 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
-#include <tr1/memory>
+#include <memory>
#include "kudu/common/schema.h"
#include "kudu/fs/fs-test-util.h"
@@ -37,14 +36,15 @@ DEFINE_int32(last_row_to_update, 100000, "the last row to update");
DEFINE_int32(n_verify, 1, "number of times to verify the updates"
"(useful for benchmarks");
+using std::is_sorted;
+using std::shared_ptr;
+
namespace kudu {
namespace tablet {
using fs::CountingReadableBlock;
using fs::ReadableBlock;
using fs::WritableBlock;
-using std::tr1::shared_ptr;
-using util::gtl::is_sorted;
// Test path to write delta file to (in in-memory environment)
const char kTestPath[] = "/tmp/test";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltafile.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltafile.cc b/src/kudu/tablet/deltafile.cc
index 0954961..0c07ce6 100644
--- a/src/kudu/tablet/deltafile.cc
+++ b/src/kudu/tablet/deltafile.cc
@@ -42,7 +42,7 @@ DEFINE_int32(deltafile_default_block_size, 32*1024,
"on a per-table basis.");
TAG_FLAG(deltafile_default_block_size, experimental);
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltafile.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltafile.h b/src/kudu/tablet/deltafile.h
index 808d3eb..cb9a46e 100644
--- a/src/kudu/tablet/deltafile.h
+++ b/src/kudu/tablet/deltafile.h
@@ -18,7 +18,7 @@
#define KUDU_TABLET_DELTAFILE_H
#include <boost/ptr_container/ptr_deque.hpp>
-#include <tr1/memory>
+#include <memory>
#include <string>
#include <vector>
@@ -99,7 +99,7 @@ class DeltaFileWriter {
};
class DeltaFileReader : public DeltaStore,
- public std::tr1::enable_shared_from_this<DeltaFileReader> {
+ public std::enable_shared_from_this<DeltaFileReader> {
public:
static const char * const kDeltaStatsEntryName;
@@ -108,7 +108,7 @@ class DeltaFileReader : public DeltaStore,
// After this call, the delta reader is safe for use.
static Status Open(gscoped_ptr<fs::ReadableBlock> file,
const BlockId& block_id,
- std::tr1::shared_ptr<DeltaFileReader>* reader_out,
+ std::shared_ptr<DeltaFileReader>* reader_out,
DeltaType delta_type);
// Lazily opens a delta file using a previously opened block. A lazy open
@@ -118,7 +118,7 @@ class DeltaFileReader : public DeltaStore,
// Init() must be called before using the file's stats.
static Status OpenNoInit(gscoped_ptr<fs::ReadableBlock> file,
const BlockId& block_id,
- std::tr1::shared_ptr<DeltaFileReader>* reader_out,
+ std::shared_ptr<DeltaFileReader>* reader_out,
DeltaType delta_type);
virtual Status Init() OVERRIDE;
@@ -158,7 +158,7 @@ class DeltaFileReader : public DeltaStore,
DISALLOW_COPY_AND_ASSIGN(DeltaFileReader);
- const std::tr1::shared_ptr<cfile::CFileReader> &cfile_reader() const {
+ const std::shared_ptr<cfile::CFileReader> &cfile_reader() const {
return reader_;
}
@@ -171,7 +171,7 @@ class DeltaFileReader : public DeltaStore,
Status ReadDeltaStats();
- std::tr1::shared_ptr<cfile::CFileReader> reader_;
+ std::shared_ptr<cfile::CFileReader> reader_;
gscoped_ptr<DeltaStats> delta_stats_;
const BlockId block_id_;
@@ -251,7 +251,7 @@ class DeltaFileIterator : public DeltaIterator {
// The passed 'projection' and 'dfr' must remain valid for the lifetime
// of the iterator.
- DeltaFileIterator(const std::tr1::shared_ptr<DeltaFileReader>& dfr,
+ DeltaFileIterator(const std::shared_ptr<DeltaFileReader>& dfr,
const Schema *projection,
const MvccSnapshot &snap,
DeltaType delta_type);
@@ -276,7 +276,7 @@ class DeltaFileIterator : public DeltaIterator {
// Log a FATAL error message about a bad delta.
void FatalUnexpectedDelta(const DeltaKey &key, const Slice &deltas, const string &msg);
- std::tr1::shared_ptr<DeltaFileReader> dfr_;
+ std::shared_ptr<DeltaFileReader> dfr_;
// Schema used during projection.
const Schema* projection_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltamemstore-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltamemstore-test.cc b/src/kudu/tablet/deltamemstore-test.cc
index 28262e4..cecfa1c 100644
--- a/src/kudu/tablet/deltamemstore-test.cc
+++ b/src/kudu/tablet/deltamemstore-test.cc
@@ -15,11 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <boost/foreach.hpp>
#include <gtest/gtest.h>
+#include <memory>
#include <stdlib.h>
-#include <tr1/unordered_set>
+#include <unordered_set>
#include "kudu/common/schema.h"
#include "kudu/consensus/consensus.pb.h"
@@ -36,8 +36,8 @@
DEFINE_int32(benchmark_num_passes, 100, "Number of passes to apply deltas in the benchmark");
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
+using std::unordered_set;
namespace kudu {
namespace tablet {
@@ -93,8 +93,8 @@ class TestDeltaMemStore : public KuduTest {
size_t col_idx,
ColumnBlock *cb) {
ColumnSchema col_schema(schema_.column(col_idx));
- Schema single_col_projection(boost::assign::list_of(col_schema),
- boost::assign::list_of(schema_.column_id(col_idx)),
+ Schema single_col_projection({ col_schema },
+ { schema_.column_id(col_idx) },
0);
DeltaIterator* raw_iter;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltamemstore.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltamemstore.cc b/src/kudu/tablet/deltamemstore.cc
index d41018a..2b2999c 100644
--- a/src/kudu/tablet/deltamemstore.cc
+++ b/src/kudu/tablet/deltamemstore.cc
@@ -32,7 +32,7 @@ namespace kudu {
namespace tablet {
using log::LogAnchorRegistry;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
using strings::Substitute;
////////////////////////////////////////////////////////////
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/deltamemstore.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/deltamemstore.h b/src/kudu/tablet/deltamemstore.h
index ddbc326..387885e 100644
--- a/src/kudu/tablet/deltamemstore.h
+++ b/src/kudu/tablet/deltamemstore.h
@@ -20,8 +20,8 @@
#include <boost/thread/mutex.hpp>
#include <deque>
#include <gtest/gtest_prod.h>
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/common/columnblock.h"
@@ -60,12 +60,11 @@ struct DMSTreeTraits : public btree::BTreeTraits {
// modified columns.
class DeltaMemStore : public DeltaStore,
- public std::tr1::enable_shared_from_this<DeltaMemStore> {
+ public std::enable_shared_from_this<DeltaMemStore> {
public:
- DeltaMemStore(
- int64_t id, int64_t rs_id,
- log::LogAnchorRegistry* log_anchor_registry,
- const std::tr1::shared_ptr<MemTracker>& parent_tracker = std::tr1::shared_ptr<MemTracker>());
+ DeltaMemStore(int64_t id, int64_t rs_id,
+ log::LogAnchorRegistry* log_anchor_registry,
+ const std::shared_ptr<MemTracker>& parent_tracker = std::shared_ptr<MemTracker>());
virtual Status Init() OVERRIDE;
@@ -151,10 +150,10 @@ class DeltaMemStore : public DeltaStore,
const int64_t id_; // DeltaMemStore ID.
const int64_t rs_id_; // Rowset ID.
- std::tr1::shared_ptr<MemTracker> mem_tracker_;
- std::tr1::shared_ptr<MemoryTrackingBufferAllocator> allocator_;
+ std::shared_ptr<MemTracker> mem_tracker_;
+ std::shared_ptr<MemoryTrackingBufferAllocator> allocator_;
- std::tr1::shared_ptr<ThreadSafeMemoryTrackingArena> arena_;
+ std::shared_ptr<ThreadSafeMemoryTrackingArena> arena_;
// Concurrent B-Tree storing <key index> -> RowChangeList
gscoped_ptr<DMSTree> tree_;
@@ -215,11 +214,11 @@ class DMSIterator : public DeltaIterator {
// The projection passed here must be the same as the schema of any
// RowBlocks which are passed in, or else bad things will happen.
// The pointer must also remain valid for the lifetime of the iterator.
- DMSIterator(const std::tr1::shared_ptr<const DeltaMemStore> &dms,
+ DMSIterator(const std::shared_ptr<const DeltaMemStore> &dms,
const Schema *projection,
const MvccSnapshot &snapshot);
- const std::tr1::shared_ptr<const DeltaMemStore> dms_;
+ const std::shared_ptr<const DeltaMemStore> dms_;
// MVCC state which allows us to ignore uncommitted transactions.
const MvccSnapshot mvcc_snapshot_;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 811fb02..173a5d4 100644
--- a/src/kudu/tablet/diskrowset-test-base.h
+++ b/src/kudu/tablet/diskrowset-test-base.h
@@ -17,13 +17,12 @@
#ifndef KUDU_TABLET_LAYER_TEST_BASE_H
#define KUDU_TABLET_LAYER_TEST_BASE_H
-#include <boost/assign/list_of.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
+#include <memory>
#include <string>
-#include <tr1/memory>
-#include <tr1/unordered_set>
#include <unistd.h>
+#include <unordered_set>
#include <vector>
#include "kudu/common/iterator.h"
@@ -50,8 +49,7 @@ DEFINE_int32(n_read_passes, 10,
namespace kudu {
namespace tablet {
-using boost::assign::list_of;
-using std::tr1::unordered_set;
+using std::unordered_set;
class TestRowSet : public KuduRowSetTest {
public:
@@ -212,7 +210,7 @@ class TestRowSet : public KuduRowSetTest {
void VerifyUpdatesWithRowIter(const DiskRowSet &rs,
const unordered_set<uint32_t> &updated) {
- Schema proj_val = CreateProjection(schema_, list_of("val"));
+ Schema proj_val = CreateProjection(schema_, { "val" });
MvccSnapshot snap = MvccSnapshot::CreateSnapshotIncludingAllTransactions();
gscoped_ptr<RowwiseIterator> row_iter;
CHECK_OK(rs.NewRowIterator(&proj_val, snap, &row_iter));
@@ -300,14 +298,14 @@ class TestRowSet : public KuduRowSetTest {
void BenchmarkIterationPerformance(const DiskRowSet &rs,
const string &log_message) {
- Schema proj_val = CreateProjection(schema_, list_of("val"));
+ Schema proj_val = CreateProjection(schema_, { "val" });
LOG_TIMING(INFO, log_message + " (val column only)") {
for (int i = 0; i < FLAGS_n_read_passes; i++) {
IterateProjection(rs, proj_val, n_rows_, false);
}
}
- Schema proj_key = CreateProjection(schema_, list_of("key"));
+ Schema proj_key = CreateProjection(schema_, { "key" });
LOG_TIMING(INFO, log_message + " (key string column only)") {
for (int i = 0; i < FLAGS_n_read_passes; i++) {
IterateProjection(rs, proj_key, n_rows_, false);
@@ -321,7 +319,7 @@ class TestRowSet : public KuduRowSetTest {
}
}
- Status OpenTestRowSet(std::tr1::shared_ptr<DiskRowSet> *rowset) {
+ Status OpenTestRowSet(std::shared_ptr<DiskRowSet> *rowset) {
return DiskRowSet::Open(rowset_meta_, new log::LogAnchorRegistry(), rowset);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/diskrowset-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/diskrowset-test.cc b/src/kudu/tablet/diskrowset-test.cc
index e84d719..e445335 100644
--- a/src/kudu/tablet/diskrowset-test.cc
+++ b/src/kudu/tablet/diskrowset-test.cc
@@ -15,12 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
+#include <memory>
#include <time.h>
-#include <tr1/memory>
#include "kudu/common/row.h"
#include "kudu/common/schema.h"
@@ -41,15 +40,13 @@ DECLARE_int32(cfile_default_block_size);
DECLARE_double(tablet_delta_store_major_compact_min_ratio);
DECLARE_int32(tablet_delta_store_minor_compact_max);
-using std::tr1::shared_ptr;
+using std::is_sorted;
+using std::shared_ptr;
+using std::unordered_set;
namespace kudu {
namespace tablet {
-using boost::assign::list_of;
-using std::tr1::unordered_set;
-using util::gtl::is_sorted;
-
// TODO: add test which calls CopyNextRows on an iterator with no more
// rows - i think it segfaults!
@@ -69,7 +66,7 @@ TEST_F(TestRowSet, TestRowSetRoundTrip) {
// Now iterate only over the key column
Schema proj_key;
- ASSERT_OK(schema_.CreateProjectionByNames(list_of("key"), &proj_key));
+ ASSERT_OK(schema_.CreateProjectionByNames({ "key" }, &proj_key));
LOG_TIMING(INFO, "Iterating over only key column") {
IterateProjection(*rs, proj_key, n_rows_);
@@ -78,7 +75,7 @@ TEST_F(TestRowSet, TestRowSetRoundTrip) {
// Now iterate only over the non-key column
Schema proj_val;
- ASSERT_OK(schema_.CreateProjectionByNames(list_of("val"), &proj_val));
+ ASSERT_OK(schema_.CreateProjectionByNames({ "val" }, &proj_val));
LOG_TIMING(INFO, "Iterating over only val column") {
IterateProjection(*rs, proj_val, n_rows_);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/diskrowset.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/diskrowset.cc b/src/kudu/tablet/diskrowset.cc
index cbe47eb..edb1d74 100644
--- a/src/kudu/tablet/diskrowset.cc
+++ b/src/kudu/tablet/diskrowset.cc
@@ -18,7 +18,6 @@
#include <algorithm>
#include <boost/thread/locks.hpp>
#include <glog/logging.h>
-#include <tr1/memory>
#include <vector>
#include "kudu/common/generic_iterators.h"
@@ -58,8 +57,8 @@ using cfile::BloomFileWriter;
using fs::ScopedWritableBlockCloser;
using fs::WritableBlock;
using log::LogAnchorRegistry;
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
const char *DiskRowSet::kMinKeyMetaEntryName = "min_key";
const char *DiskRowSet::kMaxKeyMetaEntryName = "max_key";
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/diskrowset.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/diskrowset.h b/src/kudu/tablet/diskrowset.h
index 9574678..9aa0046 100644
--- a/src/kudu/tablet/diskrowset.h
+++ b/src/kudu/tablet/diskrowset.h
@@ -24,8 +24,8 @@
#include <boost/thread/mutex.hpp>
#include <gtest/gtest_prod.h>
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/common/row.h"
@@ -220,7 +220,7 @@ class RollingDiskRowSetWriter {
TabletMetadata* tablet_metadata_;
const Schema schema_;
- std::tr1::shared_ptr<RowSetMetadata> cur_drs_metadata_;
+ std::shared_ptr<RowSetMetadata> cur_drs_metadata_;
const BloomFilterSizing bloom_sizing_;
const size_t target_rowset_size_;
@@ -269,11 +269,11 @@ class DiskRowSet : public RowSet {
// Open a rowset from disk.
// If successful, sets *rowset to the newly open rowset
- static Status Open(const std::tr1::shared_ptr<RowSetMetadata>& rowset_metadata,
+ static Status Open(const std::shared_ptr<RowSetMetadata>& rowset_metadata,
log::LogAnchorRegistry* log_anchor_registry,
- std::tr1::shared_ptr<DiskRowSet> *rowset,
- const std::tr1::shared_ptr<MemTracker>& parent_tracker =
- std::tr1::shared_ptr<MemTracker>());
+ std::shared_ptr<DiskRowSet> *rowset,
+ const std::shared_ptr<MemTracker>& parent_tracker =
+ std::shared_ptr<MemTracker>());
////////////////////////////////////////////////////////////
// "Management" functions
@@ -358,7 +358,7 @@ class DiskRowSet : public RowSet {
return DCHECK_NOTNULL(delta_tracker_.get());
}
- std::tr1::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
+ std::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
return rowset_metadata_;
}
@@ -376,9 +376,9 @@ class DiskRowSet : public RowSet {
friend class CompactionInput;
friend class Tablet;
- DiskRowSet(const std::tr1::shared_ptr<RowSetMetadata>& rowset_metadata,
+ DiskRowSet(const std::shared_ptr<RowSetMetadata>& rowset_metadata,
log::LogAnchorRegistry* log_anchor_registry,
- const std::tr1::shared_ptr<MemTracker>& parent_tracker);
+ const std::shared_ptr<MemTracker>& parent_tracker);
Status Open();
@@ -389,17 +389,17 @@ class DiskRowSet : public RowSet {
// Major compacts all the delta files for the specified columns.
Status MajorCompactDeltaStoresWithColumnIds(const std::vector<ColumnId>& col_ids);
- std::tr1::shared_ptr<RowSetMetadata> rowset_metadata_;
+ std::shared_ptr<RowSetMetadata> rowset_metadata_;
bool open_;
log::LogAnchorRegistry* log_anchor_registry_;
- std::tr1::shared_ptr<MemTracker> parent_tracker_;
+ std::shared_ptr<MemTracker> parent_tracker_;
// Base data for this rowset.
mutable percpu_rwlock component_lock_;
- std::tr1::shared_ptr<CFileSet> base_data_;
+ std::shared_ptr<CFileSet> base_data_;
gscoped_ptr<DeltaTracker> delta_tracker_;
// Lock governing this rowset's inclusion in a compact/flush. If locked,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 c8d58bf..6d01907 100644
--- a/src/kudu/tablet/lock_manager-test.cc
+++ b/src/kudu/tablet/lock_manager-test.cc
@@ -20,7 +20,7 @@
#include <boost/thread/thread.hpp>
#include <glog/logging.h>
#include <gtest/gtest.h>
-#include <tr1/memory>
+#include <memory>
#include <vector>
#include "kudu/gutil/gscoped_ptr.h"
@@ -31,7 +31,7 @@
#include "kudu/util/thread.h"
using std::vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
DEFINE_int32(num_test_threads, 10, "number of stress test client threads");
DEFINE_int32(num_iterations, 1000, "number of iterations per client thread");
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/maintenance_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/maintenance_manager-test.cc b/src/kudu/tablet/maintenance_manager-test.cc
index fed7d33..5bb5766 100644
--- a/src/kudu/tablet/maintenance_manager-test.cc
+++ b/src/kudu/tablet/maintenance_manager-test.cc
@@ -14,9 +14,10 @@
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
-#include <gtest/gtest.h>
+
#include <gflags/gflags.h>
-#include <tr1/memory>
+#include <gtest/gtest.h>
+#include <memory>
#include <vector>
#include "kudu/gutil/strings/substitute.h"
@@ -28,10 +29,10 @@
#include "kudu/util/test_util.h"
#include "kudu/util/thread.h"
-using std::tr1::shared_ptr;
+using kudu::tablet::MaintenanceManagerStatusPB;
+using std::shared_ptr;
using std::vector;
using strings::Substitute;
-using kudu::tablet::MaintenanceManagerStatusPB;
METRIC_DEFINE_entity(test);
METRIC_DEFINE_gauge_uint32(test, maintenance_ops_running,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/maintenance_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/maintenance_manager.cc b/src/kudu/tablet/maintenance_manager.cc
index 707c448..56b2d9e 100644
--- a/src/kudu/tablet/maintenance_manager.cc
+++ b/src/kudu/tablet/maintenance_manager.cc
@@ -18,13 +18,12 @@
#include "kudu/tablet/maintenance_manager.h"
#include <boost/foreach.hpp>
+#include <gflags/gflags.h>
+#include <memory>
#include <stdint.h>
#include <string>
-#include <tr1/memory>
#include <utility>
-#include <gflags/gflags.h>
-
#include "kudu/gutil/stringprintf.h"
#include "kudu/gutil/strings/substitute.h"
#include "kudu/util/debug/trace_event.h"
@@ -36,7 +35,7 @@
#include "kudu/util/thread.h"
using std::pair;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
using strings::Substitute;
DEFINE_int32(maintenance_manager_num_threads, 1,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/maintenance_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/maintenance_manager.h b/src/kudu/tablet/maintenance_manager.h
index 4a76e7e..b1607ad 100644
--- a/src/kudu/tablet/maintenance_manager.h
+++ b/src/kudu/tablet/maintenance_manager.h
@@ -20,9 +20,9 @@
#include <stdint.h>
#include <map>
+#include <memory>
#include <set>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/gutil/macros.h"
@@ -195,7 +195,7 @@ class MaintenanceOp {
// The MaintenanceManager with which this op is registered, or null
// if it is not registered.
- std::tr1::shared_ptr<MaintenanceManager> manager_;
+ std::shared_ptr<MaintenanceManager> manager_;
IOUsage io_usage_;
};
@@ -218,13 +218,13 @@ struct CompletedOp {
// as flushes or compactions. It runs these operations in the background, in a
// thread pool. It uses information provided in MaintenanceOpStats objects to
// decide which operations, if any, to run.
-class MaintenanceManager : public std::tr1::enable_shared_from_this<MaintenanceManager> {
+class MaintenanceManager : public std::enable_shared_from_this<MaintenanceManager> {
public:
struct Options {
int32_t num_threads;
int32_t polling_interval_ms;
uint32_t history_size;
- std::tr1::shared_ptr<MemTracker> parent_mem_tracker;
+ std::shared_ptr<MemTracker> parent_mem_tracker;
};
explicit MaintenanceManager(const Options& options);
@@ -270,7 +270,7 @@ class MaintenanceManager : public std::tr1::enable_shared_from_this<MaintenanceM
// the completed_ops_count_ % the vector's size and then the count needs to be incremented.
std::vector<CompletedOp> completed_ops_;
int64_t completed_ops_count_;
- std::tr1::shared_ptr<MemTracker> parent_mem_tracker_;
+ std::shared_ptr<MemTracker> parent_mem_tracker_;
DISALLOW_COPY_AND_ASSIGN(MaintenanceManager);
};
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/major_delta_compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/major_delta_compaction-test.cc b/src/kudu/tablet/major_delta_compaction-test.cc
index df9e650..982b7cc 100644
--- a/src/kudu/tablet/major_delta_compaction-test.cc
+++ b/src/kudu/tablet/major_delta_compaction-test.cc
@@ -15,10 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
+#include <memory>
+#include <unordered_set>
#include "kudu/common/generic_iterators.h"
#include "kudu/common/partial_row.h"
@@ -33,25 +34,22 @@
#include "kudu/util/test_util.h"
#include "kudu/gutil/algorithm.h"
-using boost::assign::list_of;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
+using std::unordered_set;
namespace kudu {
namespace tablet {
using strings::Substitute;
-using util::gtl::is_sorted;
class TestMajorDeltaCompaction : public KuduRowSetTest {
public:
TestMajorDeltaCompaction() :
- KuduRowSetTest(Schema(list_of
- (ColumnSchema("key", STRING))
- (ColumnSchema("val1", INT32))
- (ColumnSchema("val2", STRING))
- (ColumnSchema("val3", INT32))
- (ColumnSchema("val4", STRING)), 1)),
+ KuduRowSetTest(Schema({ ColumnSchema("key", STRING),
+ ColumnSchema("val1", INT32),
+ ColumnSchema("val2", STRING),
+ ColumnSchema("val3", INT32),
+ ColumnSchema("val4", STRING) }, 1)),
mvcc_(scoped_refptr<server::Clock>(
server::LogicalClock::CreateStartingAt(Timestamp::kInitialTimestamp))) {
}
@@ -181,10 +179,9 @@ TEST_F(TestMajorDeltaCompaction, TestCompact) {
shared_ptr<RowSet> rs = all_rowsets.front();
- vector<ColumnId> col_ids_to_compact = list_of
- (schema_.column_id(1))
- (schema_.column_id(3))
- (schema_.column_id(4));
+ vector<ColumnId> col_ids_to_compact = { schema_.column_id(1),
+ schema_.column_id(3),
+ schema_.column_id(4) };
// We'll run a few rounds of update/compact to make sure
// that we don't get into some funny state (regression test for
@@ -241,10 +238,9 @@ TEST_F(TestMajorDeltaCompaction, TestUndos) {
ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, old_state));
// Major compact, check we still have the old data.
- vector<ColumnId> col_ids_to_compact = list_of
- (schema_.column_id(1))
- (schema_.column_id(3))
- (schema_.column_id(4));
+ vector<ColumnId> col_ids_to_compact = { schema_.column_id(1),
+ schema_.column_id(3),
+ schema_.column_id(4) };
ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs));
ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, old_state));
@@ -285,7 +281,7 @@ TEST_F(TestMajorDeltaCompaction, TestCarryDeletesOver) {
ASSERT_NO_FATAL_FAILURE(DeleteRows(kNumRows));
ASSERT_OK(tablet()->FlushBiggestDMS());
- vector<ColumnId> col_ids_to_compact = list_of(schema_.column_id(4));
+ vector<ColumnId> col_ids_to_compact = { schema_.column_id(4) };
ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs));
ASSERT_NO_FATAL_FAILURE(VerifyData());
@@ -331,7 +327,7 @@ TEST_F(TestMajorDeltaCompaction, TestReinserts) {
// Now we'll push some of the updates down.
shared_ptr<RowSet> rs = all_rowsets.front();
- vector<ColumnId> col_ids_to_compact = list_of(schema_.column_id(4));
+ vector<ColumnId> col_ids_to_compact = { schema_.column_id(4) };
ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs));
// The data we'll see here is the 3rd batch of inserts, doesn't have updates.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/memrowset-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/memrowset-test.cc b/src/kudu/tablet/memrowset-test.cc
index c977536..b210895 100644
--- a/src/kudu/tablet/memrowset-test.cc
+++ b/src/kudu/tablet/memrowset-test.cc
@@ -15,7 +15,6 @@
// specific language governing permissions and limitations
// under the License.
-#include <boost/assign/list_of.hpp>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
@@ -39,9 +38,9 @@ DEFINE_int32(num_scan_passes, 1,
namespace kudu {
namespace tablet {
-using std::tr1::shared_ptr;
-using log::LogAnchorRegistry;
using consensus::OpId;
+using log::LogAnchorRegistry;
+using std::shared_ptr;
class TestMemRowSet : public ::testing::Test {
public:
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/memrowset.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/memrowset.cc b/src/kudu/tablet/memrowset.cc
index ac2a636..534a247 100644
--- a/src/kudu/tablet/memrowset.cc
+++ b/src/kudu/tablet/memrowset.cc
@@ -39,7 +39,7 @@ DEFINE_bool(mrs_use_codegen, true, "whether the memrowset should use code "
TAG_FLAG(mrs_use_codegen, hidden);
using std::pair;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu { namespace tablet {
@@ -376,7 +376,7 @@ gscoped_ptr<MRSRowProjector> GenerateAppropriateProjector(
} // anonymous namespace
-MemRowSet::Iterator::Iterator(const std::tr1::shared_ptr<const MemRowSet> &mrs,
+MemRowSet::Iterator::Iterator(const std::shared_ptr<const MemRowSet> &mrs,
MemRowSet::MSBTIter *iter,
const Schema *projection,
const MvccSnapshot &mvcc_snap)
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/memrowset.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/memrowset.h b/src/kudu/tablet/memrowset.h
index dbaa529..19e1b54 100644
--- a/src/kudu/tablet/memrowset.h
+++ b/src/kudu/tablet/memrowset.h
@@ -18,8 +18,8 @@
#define KUDU_TABLET_MEMROWSET_H
#include <boost/optional.hpp>
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/common/scan_spec.h"
@@ -170,15 +170,15 @@ struct MSBTreeTraits : public btree::BTreeTraits {
//
// The data is kept sorted.
class MemRowSet : public RowSet,
- public std::tr1::enable_shared_from_this<MemRowSet> {
+ public std::enable_shared_from_this<MemRowSet> {
public:
class Iterator;
MemRowSet(int64_t id,
const Schema &schema,
log::LogAnchorRegistry* log_anchor_registry,
- const std::tr1::shared_ptr<MemTracker>& parent_tracker =
- std::tr1::shared_ptr<MemTracker>());
+ const std::shared_ptr<MemTracker>& parent_tracker =
+ std::shared_ptr<MemTracker>());
~MemRowSet();
@@ -288,8 +288,8 @@ class MemRowSet : public RowSet,
return id_;
}
- std::tr1::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
- return std::tr1::shared_ptr<RowSetMetadata>(
+ std::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
+ return std::shared_ptr<RowSetMetadata>(
reinterpret_cast<RowSetMetadata *>(NULL));
}
@@ -345,10 +345,10 @@ class MemRowSet : public RowSet,
int64_t id_;
const Schema schema_;
- std::tr1::shared_ptr<MemTracker> parent_tracker_;
- std::tr1::shared_ptr<MemTracker> mem_tracker_;
- std::tr1::shared_ptr<MemoryTrackingBufferAllocator> allocator_;
- std::tr1::shared_ptr<ThreadSafeMemoryTrackingArena> arena_;
+ std::shared_ptr<MemTracker> parent_tracker_;
+ std::shared_ptr<MemTracker> mem_tracker_;
+ std::shared_ptr<MemoryTrackingBufferAllocator> allocator_;
+ std::shared_ptr<ThreadSafeMemoryTrackingArena> arena_;
typedef btree::CBTreeIterator<MSBTreeTraits> MSBTIter;
@@ -462,7 +462,7 @@ class MemRowSet::Iterator : public RowwiseIterator {
DISALLOW_COPY_AND_ASSIGN(Iterator);
- Iterator(const std::tr1::shared_ptr<const MemRowSet> &mrs,
+ Iterator(const std::shared_ptr<const MemRowSet> &mrs,
MemRowSet::MSBTIter *iter,
const Schema *projection,
const MvccSnapshot &mvcc_snap);
@@ -473,7 +473,7 @@ class MemRowSet::Iterator : public RowwiseIterator {
RowBlockRow *dst_row,
Arena *dst_arena);
- const std::tr1::shared_ptr<const MemRowSet> memrowset_;
+ const std::shared_ptr<const MemRowSet> memrowset_;
gscoped_ptr<MemRowSet::MSBTIter> iter_;
// The MVCC snapshot which determines which rows and mutations are visible to
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/metadata-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/metadata-test.cc b/src/kudu/tablet/metadata-test.cc
index 80e6326..c5d879c 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/assign/list_of.hpp>
#include <boost/foreach.hpp>
#include <gtest/gtest.h>
#include <string>
@@ -29,7 +28,6 @@
#include "kudu/util/status.h"
#include "kudu/util/test_util.h"
-using boost::assign::list_of;
using std::vector;
using std::string;
using strings::Substitute;
@@ -40,7 +38,7 @@ namespace tablet {
class MetadataTest : public KuduTest {
public:
MetadataTest() {
- all_blocks_ = list_of(BlockId(1))(BlockId(2))(BlockId(3))(BlockId(4));
+ all_blocks_ = { BlockId(1), BlockId(2), BlockId(3), BlockId(4) };
tablet_meta_ = new TabletMetadata(NULL, "fake-tablet");
CHECK_OK(RowSetMetadata::CreateNew(tablet_meta_.get(), 0, &meta_));
@@ -64,8 +62,8 @@ TEST_F(MetadataTest, RSMD_TestReplaceDeltas_1) {
ASSERT_OK(meta_->CommitUpdate(
RowSetMetadataUpdate()
- .ReplaceRedoDeltaBlocks(to_replace, list_of(BlockId(123)))));
- ASSERT_EQ(list_of(BlockId(1))(BlockId(123))(BlockId(4)),
+ .ReplaceRedoDeltaBlocks(to_replace, { BlockId(123) })));
+ ASSERT_EQ(vector<BlockId>({ BlockId(1), BlockId(123), BlockId(4) }),
meta_->redo_delta_blocks());
}
@@ -77,8 +75,8 @@ TEST_F(MetadataTest, RSMD_TestReplaceDeltas_2) {
ASSERT_OK(meta_->CommitUpdate(
RowSetMetadataUpdate()
- .ReplaceRedoDeltaBlocks(to_replace, list_of(BlockId(123)))));
- ASSERT_EQ(list_of(BlockId(123))(BlockId(3))(BlockId(4)),
+ .ReplaceRedoDeltaBlocks(to_replace, { BlockId(123) })));
+ ASSERT_EQ(vector<BlockId>({ BlockId(123), BlockId(3), BlockId(4) }),
meta_->redo_delta_blocks());
}
@@ -90,8 +88,8 @@ TEST_F(MetadataTest, RSMD_TestReplaceDeltas_3) {
ASSERT_OK(meta_->CommitUpdate(
RowSetMetadataUpdate()
- .ReplaceRedoDeltaBlocks(to_replace, list_of(BlockId(123)))));
- ASSERT_EQ(list_of(BlockId(1))(BlockId(2))(BlockId(123)),
+ .ReplaceRedoDeltaBlocks(to_replace, { BlockId(123) })));
+ ASSERT_EQ(vector<BlockId>({ BlockId(1), BlockId(2), BlockId(123) }),
meta_->redo_delta_blocks());
}
@@ -103,7 +101,7 @@ TEST_F(MetadataTest, RSMD_TestReplaceDeltas_Bad_NonContiguous) {
Status s = meta_->CommitUpdate(
RowSetMetadataUpdate()
- .ReplaceRedoDeltaBlocks(to_replace, list_of(BlockId(123))));
+ .ReplaceRedoDeltaBlocks(to_replace, { BlockId(123) }));
EXPECT_EQ(Substitute("Invalid argument: Cannot find subsequence <$0> in <$1>",
BlockId::JoinStrings(to_replace),
BlockId::JoinStrings(all_blocks_)),
@@ -120,7 +118,7 @@ TEST_F(MetadataTest, RSMD_TestReplaceDeltas_Bad_DoesntExist) {
Status s = meta_->CommitUpdate(
RowSetMetadataUpdate()
- .ReplaceRedoDeltaBlocks(to_replace, list_of(BlockId(123))));
+ .ReplaceRedoDeltaBlocks(to_replace, { BlockId(123) }));
EXPECT_EQ(Substitute("Invalid argument: Cannot find subsequence <$0> in <$1>",
BlockId::JoinStrings(to_replace),
BlockId::JoinStrings(all_blocks_)),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/mock-rowsets.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mock-rowsets.h b/src/kudu/tablet/mock-rowsets.h
index 6512d39..d4d1980 100644
--- a/src/kudu/tablet/mock-rowsets.h
+++ b/src/kudu/tablet/mock-rowsets.h
@@ -17,8 +17,8 @@
#ifndef KUDU_TABLET_MOCK_ROWSETS_H
#define KUDU_TABLET_MOCK_ROWSETS_H
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/gutil/strings/substitute.h"
@@ -81,9 +81,9 @@ class MockRowSet : public RowSet {
LOG(FATAL) << "Unimplemented";
return NULL;
}
- virtual std::tr1::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
+ virtual std::shared_ptr<RowSetMetadata> metadata() OVERRIDE {
LOG(FATAL) << "Unimplemented";
- return std::tr1::shared_ptr<RowSetMetadata>(
+ return std::shared_ptr<RowSetMetadata>(
reinterpret_cast<RowSetMetadata *>(NULL));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 9bec724..dd6ba82 100644
--- a/src/kudu/tablet/mt-diskrowset-test.cc
+++ b/src/kudu/tablet/mt-diskrowset-test.cc
@@ -18,18 +18,18 @@
#include <boost/foreach.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/thread/thread.hpp>
-#include <tr1/memory>
+#include <memory>
#include "kudu/tablet/diskrowset-test-base.h"
DEFINE_int32(num_threads, 2, "Number of threads to test");
+using std::shared_ptr;
+using std::unordered_set;
+
namespace kudu {
namespace tablet {
-using std::tr1::unordered_set;
-using std::tr1::shared_ptr;
-
class TestMultiThreadedRowSet : public TestRowSet {
public:
void RowSetUpdateThread(DiskRowSet *rs) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 6b08995..fa83453 100644
--- a/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
+++ b/src/kudu/tablet/mt-rowset_delta_compaction-test.cc
@@ -17,8 +17,7 @@
#include <boost/foreach.hpp>
#include <boost/thread/thread.hpp>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <memory>
#include "kudu/gutil/atomicops.h"
#include "kudu/gutil/stringprintf.h"
@@ -39,7 +38,7 @@ DEFINE_int32(num_compaction_threads, kDefaultNumCompactionThreads, "Number of co
DEFINE_int32(num_seconds_per_thread, kDefaultNumSecondsPerThread,
"Minimum number of seconds each thread should work");
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
namespace tablet {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 f1e8cdc..4c30568 100644
--- a/src/kudu/tablet/mt-tablet-test.cc
+++ b/src/kudu/tablet/mt-tablet-test.cc
@@ -19,8 +19,7 @@
#include <boost/ptr_container/ptr_vector.hpp>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <memory>
#include "kudu/codegen/compilation_manager.h"
#include "kudu/gutil/macros.h"
@@ -52,8 +51,7 @@ DEFINE_int32(tablet_test_flush_threshold_mb, 0, "Minimum memrowset size to flush
DEFINE_double(flusher_backoff, 2.0f, "Ratio to backoff the flusher thread");
DEFINE_int32(flusher_initial_frequency_ms, 30, "Number of ms to wait between flushes");
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
namespace kudu {
namespace tablet {
@@ -78,7 +76,7 @@ class MultiThreadedTabletTest : public TabletTestBase<SETUP> {
CHECK_OK(tablet()->CountRows(&count));
const Schema* schema = tablet()->schema();
ColumnSchema valcol = schema->column(schema->find_column("val"));
- valcol_projection_ = Schema(boost::assign::list_of(valcol), 0);
+ valcol_projection_ = Schema({ valcol }, 0);
CHECK_OK(tablet()->NewRowIterator(valcol_projection_, &iter));
codegen::CompilationManager::GetSingleton()->Wait();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/mvcc.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/mvcc.h b/src/kudu/tablet/mvcc.h
index 34082fd..69f7b16 100644
--- a/src/kudu/tablet/mvcc.h
+++ b/src/kudu/tablet/mvcc.h
@@ -18,8 +18,8 @@
#define KUDU_TABLET_MVCC_H
#include <gtest/gtest_prod.h>
-#include <tr1/unordered_map>
#include <string>
+#include <unordered_map>
#include <vector>
#include "kudu/gutil/gscoped_ptr.h"
@@ -377,7 +377,7 @@ class MvccManager {
MvccSnapshot cur_snap_;
// The set of timestamps corresponding to currently in-flight transactions.
- typedef std::tr1::unordered_map<Timestamp::val_type, TxnState> InFlightMap;
+ typedef std::unordered_map<Timestamp::val_type, TxnState> InFlightMap;
InFlightMap timestamps_in_flight_;
// A transaction ID below which all transactions are either committed or in-flight,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/rowset.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset.cc b/src/kudu/tablet/rowset.cc
index 2a21012..f6b3266 100644
--- a/src/kudu/tablet/rowset.cc
+++ b/src/kudu/tablet/rowset.cc
@@ -18,9 +18,9 @@
#include "kudu/tablet/rowset.h"
#include <limits>
+#include <memory>
#include <string>
#include <vector>
-#include <tr1/memory>
#include "kudu/common/generic_iterators.h"
#include "kudu/gutil/stl_util.h"
@@ -28,7 +28,7 @@
#include "kudu/gutil/strings/substitute.h"
#include "kudu/tablet/rowset_metadata.h"
-using std::tr1::shared_ptr;
+using std::shared_ptr;
using strings::Substitute;
namespace kudu { namespace tablet {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/rowset.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset.h b/src/kudu/tablet/rowset.h
index 7b03e5d..74ba4fb 100644
--- a/src/kudu/tablet/rowset.h
+++ b/src/kudu/tablet/rowset.h
@@ -18,8 +18,8 @@
#define KUDU_TABLET_ROWSET_H
#include <boost/thread/mutex.hpp>
+#include <memory>
#include <string>
-#include <tr1/memory>
#include <vector>
#include "kudu/cfile/cfile_util.h"
@@ -124,7 +124,7 @@ class RowSet {
virtual boost::mutex *compact_flush_lock() = 0;
// Returns the metadata associated with this rowset.
- virtual std::tr1::shared_ptr<RowSetMetadata> metadata() = 0;
+ virtual std::shared_ptr<RowSetMetadata> metadata() = 0;
// Get the size of the delta's MemStore
virtual size_t DeltaMemStoreSize() const = 0;
@@ -166,7 +166,7 @@ class RowSet {
};
// Used often enough, may as well typedef it.
-typedef vector<std::tr1::shared_ptr<RowSet> > RowSetVector;
+typedef vector<std::shared_ptr<RowSet> > RowSetVector;
// Structure which caches an encoded and hashed key, suitable
// for probing against rowsets.
class RowSetKeyProbe {
@@ -283,7 +283,7 @@ class DuplicatingRowSet : public RowSet {
virtual Status DebugDump(vector<string> *lines = NULL) OVERRIDE;
- std::tr1::shared_ptr<RowSetMetadata> metadata() OVERRIDE;
+ std::shared_ptr<RowSetMetadata> metadata() OVERRIDE;
// A flush-in-progress rowset should never be selected for compaction.
boost::mutex *compact_flush_lock() OVERRIDE {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/rowset_info.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_info.cc b/src/kudu/tablet/rowset_info.cc
index 16685d1..7d570d4 100644
--- a/src/kudu/tablet/rowset_info.cc
+++ b/src/kudu/tablet/rowset_info.cc
@@ -18,8 +18,8 @@
#include "kudu/tablet/rowset_info.h"
#include <algorithm>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <memory>
+#include <unordered_map>
#include <string>
#include <utility>
@@ -35,8 +35,8 @@
#include "kudu/tablet/rowset_tree.h"
#include "kudu/util/slice.h"
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::shared_ptr;
+using std::unordered_map;
using std::vector;
// Enforce a minimum size of 1MB, since otherwise the knapsack algorithm
@@ -163,8 +163,8 @@ void CheckCollectOrderedCorrectness(const vector<RowSetInfo>& min_key,
CHECK_EQ(min_key.front().cdf_min_key(), 0.0f);
CHECK_EQ(max_key.back().cdf_max_key(), total_width);
}
- DCHECK(util::gtl::is_sorted(min_key.begin(), min_key.end(), LessCDFAndRSMin));
- DCHECK(util::gtl::is_sorted(max_key.begin(), max_key.end(), LessCDFAndRSMax));
+ DCHECK(std::is_sorted(min_key.begin(), min_key.end(), LessCDFAndRSMin));
+ DCHECK(std::is_sorted(max_key.begin(), max_key.end(), LessCDFAndRSMax));
}
} // anonymous namespace
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/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 a7534bb..190d48d 100644
--- a/src/kudu/tablet/rowset_tree-test.cc
+++ b/src/kudu/tablet/rowset_tree-test.cc
@@ -15,12 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-#include <gtest/gtest.h>
#include <glog/logging.h>
-
+#include <gtest/gtest.h>
+#include <memory>
#include <stdio.h>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <unordered_set>
#include "kudu/gutil/map-util.h"
#include "kudu/tablet/mock-rowsets.h"
@@ -29,9 +28,9 @@
#include "kudu/util/stopwatch.h"
#include "kudu/util/test_util.h"
+using std::shared_ptr;
using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::unordered_set;
namespace kudu { namespace tablet {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/tablet/rowset_tree.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/rowset_tree.cc b/src/kudu/tablet/rowset_tree.cc
index eda2e6c..d0c55bd 100644
--- a/src/kudu/tablet/rowset_tree.cc
+++ b/src/kudu/tablet/rowset_tree.cc
@@ -19,6 +19,7 @@
#include <algorithm>
#include <cstddef>
+#include <memory>
#include <string>
#include <vector>
@@ -29,7 +30,7 @@
#include "kudu/util/slice.h"
using std::vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
namespace kudu {
namespace tablet {