kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From danburk...@apache.org
Subject [4/9] incubator-kudu git commit: Enable C++11
Date Wed, 13 Jan 2016 17:18:19 GMT
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 {



Mime
View raw message