kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From danburk...@apache.org
Subject [6/9] incubator-kudu git commit: Enable C++11
Date Wed, 13 Jan 2016 17:18:21 GMT
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/block_manager-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager-stress-test.cc b/src/kudu/fs/block_manager-stress-test.cc
index 4616ef6..1fc4b17 100644
--- a/src/kudu/fs/block_manager-stress-test.cc
+++ b/src/kudu/fs/block_manager-stress-test.cc
@@ -17,15 +17,15 @@
 
 #include <boost/foreach.hpp>
 #include <cmath>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/fs/file_block_manager.h"
 #include "kudu/fs/log_block_manager.h"
+#include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/substitute.h"
-#include "kudu/gutil/stl_util.h"
 #include "kudu/util/atomic.h"
 #include "kudu/util/metrics.h"
 #include "kudu/util/random.h"
@@ -46,8 +46,8 @@ DEFINE_string(block_manager_paths, "", "Comma-separated list of paths to "
               "use for block storage. If empty, will use the default unit "
               "test path");
 
+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/fs/block_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager-test.cc b/src/kudu/fs/block_manager-test.cc
index 12f3050..c1a943c 100644
--- a/src/kudu/fs/block_manager-test.cc
+++ b/src/kudu/fs/block_manager-test.cc
@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <tr1/memory>
+#include <memory>
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 
 #include "kudu/fs/file_block_manager.h"
@@ -35,9 +34,8 @@
 #include "kudu/util/test_util.h"
 #include "kudu/util/thread.h"
 
-using boost::assign::list_of;
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 using strings::Substitute;
 
@@ -73,7 +71,7 @@ class BlockManagerTest : public KuduTest {
   BlockManagerTest() :
     bm_(CreateBlockManager(scoped_refptr<MetricEntity>(),
                            shared_ptr<MemTracker>(),
-                           list_of(GetTestDataDirectory()))) {
+                           { GetTestDataDirectory() })) {
   }
 
   virtual void SetUp() OVERRIDE {
@@ -206,7 +204,7 @@ void BlockManagerTest<LogBlockManager>::RunLogMetricsTest() {
   scoped_refptr<MetricEntity> entity = METRIC_ENTITY_server.Instantiate(&registry, "test");
   this->ReopenBlockManager(entity,
                            shared_ptr<MemTracker>(),
-                           list_of(GetTestDataDirectory()),
+                           { GetTestDataDirectory() },
                            false);
   ASSERT_NO_FATAL_FAILURE(CheckLogMetrics(entity, 0, 0, 0, 0));
 
@@ -255,7 +253,7 @@ void BlockManagerTest<LogBlockManager>::RunLogMetricsTest() {
   scoped_refptr<MetricEntity> new_entity = METRIC_ENTITY_server.Instantiate(&new_registry, "test");
   ASSERT_NO_FATAL_FAILURE(this->ReopenBlockManager(new_entity,
                                                    shared_ptr<MemTracker>(),
-                                                   list_of(GetTestDataDirectory()),
+                                                   { GetTestDataDirectory() },
                                                    false));
   ASSERT_NO_FATAL_FAILURE(CheckLogMetrics(new_entity, 10 * 1024, 11, 10, 10));
 
@@ -282,7 +280,7 @@ void BlockManagerTest<LogBlockManager>::RunLogContainerPreallocationTest() {
   // not from the end of the file.
   ASSERT_NO_FATAL_FAILURE(this->ReopenBlockManager(scoped_refptr<MetricEntity>(),
                                                    shared_ptr<MemTracker>(),
-                                                   list_of(GetTestDataDirectory()),
+                                                   { GetTestDataDirectory() },
                                                    false));
   ASSERT_OK(this->bm_->CreateBlock(&written_block));
   ASSERT_OK(written_block->Close());
@@ -316,7 +314,7 @@ void BlockManagerTest<FileBlockManager>::RunMemTrackerTest() {
   shared_ptr<MemTracker> tracker = MemTracker::CreateTracker(-1, "test tracker");
   ASSERT_NO_FATAL_FAILURE(this->ReopenBlockManager(scoped_refptr<MetricEntity>(),
                                                    tracker,
-                                                   list_of(GetTestDataDirectory()),
+                                                   { GetTestDataDirectory() },
                                                    false));
 
   // The file block manager does not allocate memory for persistent data.
@@ -333,7 +331,7 @@ void BlockManagerTest<LogBlockManager>::RunMemTrackerTest() {
   shared_ptr<MemTracker> tracker = MemTracker::CreateTracker(-1, "test tracker");
   ASSERT_NO_FATAL_FAILURE(this->ReopenBlockManager(scoped_refptr<MetricEntity>(),
                                                    tracker,
-                                                   list_of(GetTestDataDirectory()),
+                                                   { GetTestDataDirectory() },
                                                    false));
 
   // The initial consumption should be non-zero due to the block map.
@@ -549,7 +547,7 @@ TYPED_TEST(BlockManagerTest, PersistenceTest) {
   gscoped_ptr<BlockManager> new_bm(this->CreateBlockManager(
       scoped_refptr<MetricEntity>(),
       MemTracker::CreateTracker(-1, "other tracker"),
-      list_of(GetTestDataDirectory())));
+      { GetTestDataDirectory() }));
   ASSERT_OK(new_bm->Open());
 
   // Test that the state of all three blocks is properly reflected.
@@ -635,7 +633,7 @@ TYPED_TEST(BlockManagerTest, MetricsTest) {
   scoped_refptr<MetricEntity> entity = METRIC_ENTITY_server.Instantiate(&registry, "test");
   ASSERT_NO_FATAL_FAILURE(this->ReopenBlockManager(entity,
                                                    shared_ptr<MemTracker>(),
-                                                   list_of(GetTestDataDirectory()),
+                                                   { GetTestDataDirectory() },
                                                    false));
   ASSERT_NO_FATAL_FAILURE(CheckMetrics(entity, 0, 0, 0, 0, 0, 0));
 
@@ -752,7 +750,7 @@ TEST_F(LogBlockManagerTest, TestReuseBlockIds) {
   NO_FATALS(ReopenBlockManager(
       scoped_refptr<MetricEntity>(),
       shared_ptr<MemTracker>(),
-      list_of(GetTestDataDirectory()),
+      { GetTestDataDirectory() },
       false));
 }
 #endif // defined(__linux__)

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/block_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager.h b/src/kudu/fs/block_manager.h
index 63375a5..598e8a6 100644
--- a/src/kudu/fs/block_manager.h
+++ b/src/kudu/fs/block_manager.h
@@ -20,9 +20,9 @@
 
 #include <boost/foreach.hpp>
 #include <cstddef>
+#include <memory>
 #include <stdint.h>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/fs/block_id.h"
@@ -174,7 +174,7 @@ struct BlockManagerOptions {
 
   // The memory tracker under which all new memory trackers will be parented.
   // If NULL, new memory trackers will be parented to the root tracker.
-  std::tr1::shared_ptr<MemTracker> parent_mem_tracker;
+  std::shared_ptr<MemTracker> parent_mem_tracker;
 
   // The paths where data blocks will be stored. Cannot be empty.
   std::vector<std::string> root_paths;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/block_manager_util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager_util-test.cc b/src/kudu/fs/block_manager_util-test.cc
index 1e58a6d..a9be3ac 100644
--- a/src/kudu/fs/block_manager_util-test.cc
+++ b/src/kudu/fs/block_manager_util-test.cc
@@ -20,7 +20,6 @@
 #include <vector>
 
 #include <boost/foreach.hpp>
-#include <boost/assign/list_of.hpp>
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest.h>
 
@@ -33,7 +32,6 @@
 namespace kudu {
 namespace fs {
 
-using boost::assign::list_of;
 using google::protobuf::RepeatedPtrField;
 using std::string;
 using std::vector;
@@ -47,7 +45,7 @@ TEST_F(KuduTest, Lifecycle) {
   // Test that the metadata file was created.
   {
     PathInstanceMetadataFile file(env_.get(), kType, kFileName);
-    ASSERT_OK(file.Create(kUuid, list_of(kUuid)));
+    ASSERT_OK(file.Create(kUuid, { kUuid }));
   }
   ASSERT_TRUE(env_->FileExists(kFileName));
 
@@ -77,7 +75,7 @@ TEST_F(KuduTest, Locking) {
   string kUuid = "a_uuid";
 
   PathInstanceMetadataFile file(env_.get(), kType, kFileName);
-  ASSERT_OK(file.Create(kUuid, list_of(kUuid)));
+  ASSERT_OK(file.Create(kUuid, { kUuid }));
 
   PathInstanceMetadataFile first(env_.get(), kType, kFileName);
   ASSERT_OK(first.LoadFromDisk());
@@ -126,7 +124,8 @@ static void RunCheckIntegrityTest(Env* env,
 }
 
 TEST_F(KuduTest, CheckIntegrity) {
-  RepeatedPtrField<string> kAllUuids = list_of("fee")("fi")("fo")("fum");
+  vector<string> uuids = { "fee", "fi", "fo", "fum" };
+  RepeatedPtrField<string> kAllUuids(uuids.begin(), uuids.end());
 
   // Initialize path_sets to be fully consistent.
   vector<PathSetPB> path_sets(kAllUuids.size());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/block_manager_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager_util.cc b/src/kudu/fs/block_manager_util.cc
index 18b4ea0..760079d 100644
--- a/src/kudu/fs/block_manager_util.cc
+++ b/src/kudu/fs/block_manager_util.cc
@@ -17,7 +17,7 @@
 #include "kudu/fs/block_manager_util.h"
 
 #include <set>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <utility>
 
 #include <boost/foreach.hpp>
@@ -38,7 +38,7 @@ namespace fs {
 
 using std::set;
 using std::string;
-using std::tr1::unordered_map;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/file_block_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/file_block_manager.cc b/src/kudu/fs/file_block_manager.cc
index ed63558..150878b 100644
--- a/src/kudu/fs/file_block_manager.cc
+++ b/src/kudu/fs/file_block_manager.cc
@@ -20,7 +20,7 @@
 #include <boost/foreach.hpp>
 #include <deque>
 #include <string>
-#include <tr1/unordered_set>
+#include <unordered_set>
 #include <vector>
 
 #include "kudu/fs/block_manager_metrics.h"
@@ -41,9 +41,9 @@
 #include "kudu/util/status.h"
 
 using kudu::env_util::ScopedFileDeleter;
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::unordered_set;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/file_block_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/file_block_manager.h b/src/kudu/fs/file_block_manager.h
index ae4dbe1..4d4a90d 100644
--- a/src/kudu/fs/file_block_manager.h
+++ b/src/kudu/fs/file_block_manager.h
@@ -19,9 +19,9 @@
 #define KUDU_FS_FILE_BLOCK_MANAGER_H
 
 #include <map>
+#include <memory>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <unordered_set>
 #include <vector>
 
 #include "kudu/fs/block_id.h"
@@ -131,7 +131,7 @@ class FileBlockManager : public BlockManager {
 
   // Tracks the block directories which are dirty from block creation. This
   // lets us perform some simple coalescing when synchronizing metadata.
-  std::tr1::unordered_set<std::string> dirty_dirs_;
+  std::unordered_set<std::string> dirty_dirs_;
 
   // Points to the filesystem path to be used when creating the next block.
   PathMap::iterator next_root_path_;
@@ -142,7 +142,7 @@ class FileBlockManager : public BlockManager {
 
   // Tracks memory consumption of any allocations numerous enough to be
   // interesting.
-  std::tr1::shared_ptr<MemTracker> mem_tracker_;
+  std::shared_ptr<MemTracker> mem_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(FileBlockManager);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/fs_manager-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs_manager-test.cc b/src/kudu/fs/fs_manager-test.cc
index 9f6b969..b79282e 100644
--- a/src/kudu/fs/fs_manager-test.cc
+++ b/src/kudu/fs/fs_manager-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 <glog/stl_logging.h>
 #include <gtest/gtest.h>
@@ -27,8 +26,7 @@
 #include "kudu/util/test_macros.h"
 #include "kudu/util/test_util.h"
 
-using boost::assign::list_of;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 
@@ -44,8 +42,7 @@ class FsManagerTestBase : public KuduTest {
   }
 
   void ReinitFsManager() {
-    ReinitFsManager(GetTestPath("fs_root"),
-                    list_of(GetTestPath("fs_root")));
+    ReinitFsManager(GetTestPath("fs_root"), { GetTestPath("fs_root")} );
   }
 
   void ReinitFsManager(const string& wal_path, const vector<string>& data_paths) {
@@ -93,17 +90,16 @@ TEST_F(FsManagerTestBase, TestBaseOperations) {
 }
 
 TEST_F(FsManagerTestBase, TestIllegalPaths) {
-  vector<string> illegal = list_of("")("asdf")("/foo\n\t");
+  vector<string> illegal = { "", "asdf", "/foo\n\t" };
   BOOST_FOREACH(const string& path, illegal) {
-    ReinitFsManager(path, list_of(path));
+    ReinitFsManager(path, { path });
     ASSERT_TRUE(fs_manager()->CreateInitialFileSystemLayout().IsIOError());
   }
 }
 
 TEST_F(FsManagerTestBase, TestMultiplePaths) {
   string wal_path = GetTestPath("a");
-  vector<string> data_paths = list_of(
-      GetTestPath("a"))(GetTestPath("b"))(GetTestPath("c"));
+  vector<string> data_paths = { GetTestPath("a"), GetTestPath("b"), GetTestPath("c") };
   ReinitFsManager(wal_path, data_paths);
   ASSERT_OK(fs_manager()->CreateInitialFileSystemLayout());
   ASSERT_OK(fs_manager()->Open());
@@ -111,16 +107,16 @@ TEST_F(FsManagerTestBase, TestMultiplePaths) {
 
 TEST_F(FsManagerTestBase, TestMatchingPathsWithMismatchedSlashes) {
   string wal_path = GetTestPath("foo");
-  vector<string> data_paths = list_of(wal_path + "/");
+  vector<string> data_paths = { wal_path + "/" };
   ReinitFsManager(wal_path, data_paths);
   ASSERT_OK(fs_manager()->CreateInitialFileSystemLayout());
 }
 
 TEST_F(FsManagerTestBase, TestDuplicatePaths) {
   string path = GetTestPath("foo");
-  ReinitFsManager(path, list_of(path)(path)(path));
+  ReinitFsManager(path, { path, path, path });
   ASSERT_OK(fs_manager()->CreateInitialFileSystemLayout());
-  ASSERT_EQ(list_of(JoinPathSegments(path, fs_manager()->kDataDirName)),
+  ASSERT_EQ(vector<string>({ JoinPathSegments(path, fs_manager()->kDataDirName) }),
             fs_manager()->GetDataRootDirs());
 }
 
@@ -154,7 +150,7 @@ TEST_F(FsManagerTestBase, TestCannotUseNonEmptyFsRoot) {
   }
 
   // Try to create the FS layout. It should fail.
-  ReinitFsManager(path, list_of(path));
+  ReinitFsManager(path, { path });
   ASSERT_TRUE(fs_manager()->CreateInitialFileSystemLayout().IsAlreadyPresent());
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/fs_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs_manager.cc b/src/kudu/fs/fs_manager.cc
index 84c8805..d303261 100644
--- a/src/kudu/fs/fs_manager.cc
+++ b/src/kudu/fs/fs_manager.cc
@@ -20,19 +20,17 @@
 #include <deque>
 #include <iostream>
 #include <map>
-#include <tr1/memory>
-#include <tr1/unordered_set>
+#include <unordered_set>
 
 #include <boost/foreach.hpp>
-#include <boost/assign/list_of.hpp>
 #include <glog/logging.h>
 #include <glog/stl_logging.h>
 #include <google/protobuf/message.h>
 
 #include "kudu/fs/block_id.h"
 #include "kudu/fs/file_block_manager.h"
-#include "kudu/fs/log_block_manager.h"
 #include "kudu/fs/fs.pb.h"
+#include "kudu/fs/log_block_manager.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/strings/join.h"
 #include "kudu/gutil/strings/numbers.h"
@@ -44,8 +42,8 @@
 #include "kudu/gutil/walltime.h"
 #include "kudu/util/env_util.h"
 #include "kudu/util/flag_tags.h"
-#include "kudu/util/net/net_util.h"
 #include "kudu/util/metrics.h"
+#include "kudu/util/net/net_util.h"
 #include "kudu/util/oid_generator.h"
 #include "kudu/util/path_util.h"
 #include "kudu/util/pb_util.h"
@@ -74,19 +72,17 @@ DEFINE_string(fs_data_dirs, "",
               "block directory.");
 TAG_FLAG(fs_data_dirs, stable);
 
-using boost::assign::list_of;
 using google::protobuf::Message;
-using strings::Substitute;
-using std::map;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
 using kudu::env_util::ScopedFileDeleter;
-using kudu::fs::CreateBlockOptions;
 using kudu::fs::BlockManagerOptions;
+using kudu::fs::CreateBlockOptions;
 using kudu::fs::FileBlockManager;
 using kudu::fs::LogBlockManager;
 using kudu::fs::ReadableBlock;
 using kudu::fs::WritableBlock;
+using std::map;
+using std::unordered_set;
+using strings::Substitute;
 
 namespace kudu {
 
@@ -117,7 +113,7 @@ FsManager::FsManager(Env* env, const string& root_path)
   : env_(DCHECK_NOTNULL(env)),
     read_only_(false),
     wal_fs_root_(root_path),
-    data_fs_roots_(list_of(root_path).convert_to_container<vector<string> >()),
+    data_fs_roots_({ root_path }),
     metric_entity_(NULL),
     initted_(false) {
 }
@@ -293,10 +289,9 @@ Status FsManager::CreateInitialFileSystemLayout() {
   }
 
   // Initialize ancillary directories.
-  vector<string> ancillary_dirs = list_of
-      (GetWalsRootDir())
-      (GetTabletMetadataDir())
-      (GetConsensusMetadataDir());
+  vector<string> ancillary_dirs = { GetWalsRootDir(),
+                                    GetTabletMetadataDir(),
+                                    GetConsensusMetadataDir() };
   BOOST_FOREACH(const string& dir, ancillary_dirs) {
     bool created;
     RETURN_NOT_OK_PREPEND(CreateDirIfMissing(dir, &created),

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/fs_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs_manager.h b/src/kudu/fs/fs_manager.h
index 9cb40f7..fab0436 100644
--- a/src/kudu/fs/fs_manager.h
+++ b/src/kudu/fs/fs_manager.h
@@ -18,14 +18,13 @@
 #ifndef KUDU_FS_FS_MANAGER_H
 #define KUDU_FS_FS_MANAGER_H
 
+#include <gtest/gtest_prod.h>
 #include <iosfwd>
+#include <memory>
 #include <set>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
-#include <gtest/gtest_prod.h>
-
 #include "kudu/gutil/gscoped_ptr.h"
 #include "kudu/gutil/ref_counted.h"
 #include "kudu/util/env.h"
@@ -69,7 +68,7 @@ struct FsManagerOpts {
 
   // The memory tracker under which all new memory trackers will be parented.
   // If NULL, new memory trackers will be parented to the root tracker.
-  std::tr1::shared_ptr<MemTracker> parent_mem_tracker;
+  std::shared_ptr<MemTracker> parent_mem_tracker;
 
   // The path where WALs will be stored. Cannot be empty.
   std::string wal_path;
@@ -255,7 +254,7 @@ class FsManager {
 
   scoped_refptr<MetricEntity> metric_entity_;
 
-  std::tr1::shared_ptr<MemTracker> parent_mem_tracker_;
+  std::shared_ptr<MemTracker> parent_mem_tracker_;
 
   // Canonicalized forms of 'wal_fs_root_ and 'data_fs_roots_'. Constructed
   // during Init().

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/log_block_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/fs/log_block_manager.cc b/src/kudu/fs/log_block_manager.cc
index 970f219..8aec59e 100644
--- a/src/kudu/fs/log_block_manager.cc
+++ b/src/kudu/fs/log_block_manager.cc
@@ -79,9 +79,8 @@ METRIC_DEFINE_counter(server, log_block_manager_full_containers,
                       kudu::MetricUnit::kLogBlockContainers,
                       "Number of full log block containers");
 
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
-using std::tr1::unordered_set;
+using std::unordered_map;
+using std::unordered_set;
 using strings::Substitute;
 using kudu::env_util::ScopedFileDeleter;
 using kudu::fs::internal::LogBlock;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/fs/log_block_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/log_block_manager.h b/src/kudu/fs/log_block_manager.h
index 4b5fec4..8e58843 100644
--- a/src/kudu/fs/log_block_manager.h
+++ b/src/kudu/fs/log_block_manager.h
@@ -20,10 +20,10 @@
 
 #include <deque>
 #include <gtest/gtest_prod.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <memory>
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -180,7 +180,7 @@ class LogBlockManager : public BlockManager {
 
   // Simpler typedef for a block map which isn't tracked in the memory tracker.
   // Used during startup.
-  typedef std::tr1::unordered_map<
+  typedef std::unordered_map<
       const BlockId,
       scoped_refptr<internal::LogBlock>,
       BlockIdHash,
@@ -188,7 +188,7 @@ class LogBlockManager : public BlockManager {
 
   typedef MemTrackerAllocator<
       std::pair<const BlockId, scoped_refptr<internal::LogBlock> > > BlockAllocator;
-  typedef std::tr1::unordered_map<
+  typedef std::unordered_map<
       const BlockId,
       scoped_refptr<internal::LogBlock>,
       BlockIdHash,
@@ -271,7 +271,7 @@ class LogBlockManager : public BlockManager {
 
   // Tracks memory consumption of any allocations numerous enough to be
   // interesting (e.g. LogBlocks).
-  std::tr1::shared_ptr<MemTracker> mem_tracker_;
+  std::shared_ptr<MemTracker> mem_tracker_;
 
   // Protects the block map, container structures, and 'dirty_dirs'.
   mutable simple_spinlock lock_;
@@ -286,7 +286,7 @@ class LogBlockManager : public BlockManager {
   //
   // Together with blocks_by_block_id's keys, used to prevent collisions
   // when creating new anonymous blocks.
-  std::tr1::unordered_set<BlockId, BlockIdHash> open_block_ids_;
+  std::unordered_set<BlockId, BlockIdHash> open_block_ids_;
 
   // Holds (and owns) all containers loaded from disk.
   std::vector<internal::LogBlockContainer*> all_containers_;
@@ -300,7 +300,7 @@ class LogBlockManager : public BlockManager {
   // Tracks dirty container directories.
   //
   // Synced and cleared by SyncMetadata().
-  std::tr1::unordered_set<std::string> dirty_dirs_;
+  std::unordered_set<std::string> dirty_dirs_;
 
   // For manipulating files.
   Env* env_;
@@ -315,12 +315,12 @@ class LogBlockManager : public BlockManager {
   AtomicInt<int32> root_paths_idx_;
 
   // Maps root paths to instance metadata files found in each root path.
-  typedef std::tr1::unordered_map<std::string, PathInstanceMetadataFile*> InstanceMap;
+  typedef std::unordered_map<std::string, PathInstanceMetadataFile*> InstanceMap;
   InstanceMap instances_by_root_path_;
 
   // Maps root paths to thread pools. Each pool runs at most one thread, and
   // so serves as a "work queue" for that particular disk.
-  typedef std::tr1::unordered_map<std::string, ThreadPool*> ThreadPoolMap;
+  typedef std::unordered_map<std::string, ThreadPool*> ThreadPoolMap;
   ThreadPoolMap thread_pools_by_root_path_;
 
   // For generating container names.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/algorithm.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/algorithm.h b/src/kudu/gutil/algorithm.h
index 89a54e8..ff45e98 100644
--- a/src/kudu/gutil/algorithm.h
+++ b/src/kudu/gutil/algorithm.h
@@ -218,33 +218,6 @@ inline std::pair<ForwardIter, ForwardIter> minmax_element(ForwardIter first,
   return util::gtl::minmax_element(first, last, std::less<value_type>());
 }
 
-// Returns true if [first, last) is sorted in nondescending order by
-// pred.  Complexity: for nonempty ranges, at most last-first - 1
-// applications of comp.
-template <typename ForwardIterator, typename Compare>
-bool is_sorted(ForwardIterator first, ForwardIterator last, Compare comp) {
-  if (first != last) {
-    ForwardIterator next(first);
-    ++next;
-    while (next != last) {
-      if (comp(*next, *first))
-        return false;
-      first = next;
-      ++next;
-    }
-  }
-  return true;
-}
-
-// Returns true if [first, last) is sorted in nondescending order by
-// operator<.  Complexity: for nonempty ranges, exactly last-first - 1
-// applications of operator<.
-template <typename ForwardIterator>
-inline bool is_sorted(ForwardIterator first, ForwardIterator last) {
-  typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-  return util::gtl::is_sorted(first, last, std::less<value_type>());
-}
-
 // Returns true if [first, last) is partitioned by pred, i.e. if all
 // elements that satisfy pred appear before those that do
 // not. Complexity: linear.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/port.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/port.h b/src/kudu/gutil/port.h
index b66e393..d99e404 100644
--- a/src/kudu/gutil/port.h
+++ b/src/kudu/gutil/port.h
@@ -223,66 +223,6 @@ typedef int uid_t;
 // Linux has this in <linux/errno.h>
 #define EXFULL      ENOMEM  // not really that great a translation...
 
-// Mach-O supports sections (albeit with small names), but doesn't have
-// vars at the beginning and end.  Instead you should call the function
-// getsectdata("__DATA", name, &size).
-#define HAVE_ATTRIBUTE_SECTION 1
-
-// Any function with ATTRIBUTE_SECTION must not be inlined, or it will
-// be placed into whatever section its caller is placed into.
-#define ATTRIBUTE_SECTION(name) \
-  __attribute__ ((section ("__DATA, " #name))) __attribute__ ((noinline))
-
-#define ENUM_DYLD_BOOL  // so that we don't pollute the global namespace
-extern "C" {
-  #include <mach-o/getsect.h>
-  #include <mach-o/dyld.h>
-}
-class AssignAttributeStartEnd {
- public:
-  AssignAttributeStartEnd(const char* name, char** pstart, char** pend) {
-    // Find out what dynamic library name is defined in
-    for (int i = _dyld_image_count() - 1; i >= 0; --i) {
-      const mach_header* hdr = _dyld_get_image_header(i);
-      uint32_t len;
-      *pstart = getsectdatafromheader(hdr, "__DATA", name, &len);
-      if (*pstart) {   // NULL if not defined in this dynamic library
-        *pstart += _dyld_get_image_vmaddr_slide(i);   // correct for reloc
-        *pend = *pstart + len;
-        return;
-      }
-    }
-    // If we get here, not defined in a dll at all.  See if defined statically.
-    unsigned long len;    // don't ask me why this type isn't uint32_t too...
-    *pstart = getsectdata("__DATA", name, &len);
-    *pend = *pstart + len;
-  }
-};
-
-// 1) DEFINE_ATTRIBUTE_SECTION_VARS: must be called once per unique
-//    name.  You want to make sure this is executed before any
-//    DECLARE_ATTRIBUTE_SECTION_VARS; the easiest way is to put them
-//    in the same .cc file.  Put this call at the global level.
-// 2) INIT_ATTRIBUTE_SECTION_VARS: you can scatter calls to this in
-//    multiple places to help ensure execution before any
-//    DECLARE_ATTRIBUTE_SECTION_VARS.  You must have at least one
-//    DEFINE, but you can have many INITs.  Put each in its own scope.
-// 3) DECLARE_ATTRIBUTE_SECTION_VARS: must be called before using
-//    ATTRIBUTE_SECTION_START or ATTRIBUTE_SECTION_STOP on a name.
-//    Put this call at the global level.
-#define DECLARE_ATTRIBUTE_SECTION_VARS(name) \
-  extern char* __start_##name; \
-  extern char* __stop_##name;
-
-#define INIT_ATTRIBUTE_SECTION_VARS(name)               \
-  DECLARE_ATTRIBUTE_SECTION_VARS(name);                 \
-  static const AssignAttributeStartEnd __assign_##name( \
-    #name, &__start_##name, &__stop_##name)
-
-#define DEFINE_ATTRIBUTE_SECTION_VARS(name)             \
-  char* __start_##name, *__stop_##name;                 \
-  INIT_ATTRIBUTE_SECTION_VARS(name)
-
 // Darwin doesn't have strnlen. No comment.
 inline size_t strnlen(const char *s, size_t maxlen) {
   const char* end = (const char *)memchr(s, '\0', maxlen);
@@ -476,49 +416,6 @@ inline void* memrchr(const void* bytes, int find_char, size_t len) {
 #define HAVE_ATTRIBUTE_SECTION 1
 #endif
 
-#if HAVE_ATTRIBUTE_SECTION  // define section support for the case of GCC
-
-//
-// Tell the compiler/linker to put a given function into a section and define
-// "__start_ ## name" and "__stop_ ## name" symbols to bracket the section.
-// Sections can not span more than none compilation unit.
-// This functionality is supported by GNU linker.
-// Any function with ATTRIBUTE_SECTION must not be inlined, or it will
-// be placed into whatever section its caller is placed into.
-//
-#ifndef ATTRIBUTE_SECTION
-#define ATTRIBUTE_SECTION(name) \
-  __attribute__ ((section (#name))) __attribute__ ((noinline))
-#endif
-
-//
-// Weak section declaration to be used as a global declaration
-// for ATTRIBUTE_SECTION_START|STOP(name) to compile and link
-// even without functions with ATTRIBUTE_SECTION(name).
-// DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
-// a no-op on ELF but not on Mach-O.
-//
-#ifndef DECLARE_ATTRIBUTE_SECTION_VARS
-#define DECLARE_ATTRIBUTE_SECTION_VARS(name) \
-  extern char __start_##name[] ATTRIBUTE_WEAK; \
-  extern char __stop_##name[] ATTRIBUTE_WEAK
-#endif
-#ifndef DEFINE_ATTRIBUTE_SECTION_VARS
-#define INIT_ATTRIBUTE_SECTION_VARS(name)
-#define DEFINE_ATTRIBUTE_SECTION_VARS(name)
-#endif
-
-//
-// Return void* pointers to start/end of a section of code with
-// functions having ATTRIBUTE_SECTION(name).
-// Returns 0 if no such functions exits.
-// One must DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and link.
-//
-#define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(__start_##name))
-#define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(__stop_##name))
-
-#endif  // HAVE_ATTRIBUTE_SECTION
-
 //
 // The legacy prod71 libc does not provide the stack alignment required for use
 // of SSE intrinsics.  In order to properly use the intrinsics you need to use
@@ -757,7 +654,6 @@ inline void aligned_free(void *aligned_memory) {
 #define ATTRIBUTE_INITIAL_EXEC
 #define ATTRIBUTE_NONNULL(arg_index)
 #define ATTRIBUTE_NORETURN
-#define HAVE_ATTRIBUTE_SECTION 0
 #define ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
 #define REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
 #define MUST_USE_RESULT
@@ -841,18 +737,6 @@ struct AlignType { typedef char result[Size]; };
 #define ALIGNED_CHAR_ARRAY ALIGNED_CHAR_ARRAY_is_not_available_without_Cplusplus
 #endif // __cplusplus
 
-#if !HAVE_ATTRIBUTE_SECTION  // provide dummy definitions
-
-#define ATTRIBUTE_SECTION(name)
-#define INIT_ATTRIBUTE_SECTION_VARS(name)
-#define DEFINE_ATTRIBUTE_SECTION_VARS(name)
-#define DECLARE_ATTRIBUTE_SECTION_VARS(name)
-#define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(0))
-#define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(0))
-
-#endif  // !HAVE_ATTRIBUTE_SECTION
-
-
 #ifdef _MSC_VER     /* if Visual C++ */
 
 // This compiler flag can be easily overlooked on MSVC.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/stl_util.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/stl_util.h b/src/kudu/gutil/stl_util.h
index e2b8c70..68e31e9 100644
--- a/src/kudu/gutil/stl_util.h
+++ b/src/kudu/gutil/stl_util.h
@@ -580,8 +580,8 @@ void STLSetDifference(const SortedSTLContainerA &a,
                       const SortedSTLContainerB &b,
                       SortedSTLContainerC *c) {
   // The qualified name avoids an ambiguity error, particularly with C++11:
-  assert(util::gtl::is_sorted(a.begin(), a.end()));
-  assert(util::gtl::is_sorted(b.begin(), b.end()));
+  assert(std::is_sorted(a.begin(), a.end()));
+  assert(std::is_sorted(b.begin(), b.end()));
   assert(static_cast<const void *>(&a) !=
          static_cast<const void *>(c));
   assert(static_cast<const void *>(&b) !=
@@ -604,8 +604,8 @@ template<typename SortedSTLContainerA,
 void STLSetUnion(const SortedSTLContainerA &a,
                  const SortedSTLContainerB &b,
                  SortedSTLContainerC *c) {
-  assert(util::gtl::is_sorted(a.begin(), a.end()));
-  assert(util::gtl::is_sorted(b.begin(), b.end()));
+  assert(std::is_sorted(a.begin(), a.end()));
+  assert(std::is_sorted(b.begin(), b.end()));
   assert(static_cast<const void *>(&a) !=
          static_cast<const void *>(c));
   assert(static_cast<const void *>(&b) !=
@@ -620,8 +620,8 @@ template<typename SortedSTLContainerA,
 void STLSetSymmetricDifference(const SortedSTLContainerA &a,
                                const SortedSTLContainerB &b,
                                SortedSTLContainerC *c) {
-  assert(util::gtl::is_sorted(a.begin(), a.end()));
-  assert(util::gtl::is_sorted(b.begin(), b.end()));
+  assert(std::is_sorted(a.begin(), a.end()));
+  assert(std::is_sorted(b.begin(), b.end()));
   assert(static_cast<const void *>(&a) !=
          static_cast<const void *>(c));
   assert(static_cast<const void *>(&b) !=
@@ -652,8 +652,8 @@ template<typename SortedSTLContainerA,
 void STLSetIntersection(const SortedSTLContainerA &a,
                         const SortedSTLContainerB &b,
                         SortedSTLContainerC *c) {
-  assert(util::gtl::is_sorted(a.begin(), a.end()));
-  assert(util::gtl::is_sorted(b.begin(), b.end()));
+  assert(std::is_sorted(a.begin(), a.end()));
+  assert(std::is_sorted(b.begin(), b.end()));
   assert(static_cast<const void *>(&a) !=
          static_cast<const void *>(c));
   assert(static_cast<const void *>(&b) !=
@@ -676,8 +676,8 @@ template<typename SortedSTLContainerA,
          typename SortedSTLContainerB>
 bool STLIncludes(const SortedSTLContainerA &a,
                  const SortedSTLContainerB &b) {
-  assert(util::gtl::is_sorted(a.begin(), a.end()));
-  assert(util::gtl::is_sorted(b.begin(), b.end()));
+  assert(std::is_sorted(a.begin(), a.end()));
+  assert(std::is_sorted(b.begin(), b.end()));
   return std::includes(a.begin(), a.end(),
                        b.begin(), b.end());
 }
@@ -914,8 +914,8 @@ struct STLEmptyBaseHandle : public Base {
 template<typename InputIterator1, typename InputIterator2>
 bool SortedRangesHaveIntersection(InputIterator1 begin1, InputIterator1 end1,
                                   InputIterator2 begin2, InputIterator2 end2) {
-  assert(util::gtl::is_sorted(begin1, end1));
-  assert(util::gtl::is_sorted(begin2, end2));
+  assert(std::is_sorted(begin1, end1));
+  assert(std::is_sorted(begin2, end2));
   while (begin1 != end1 && begin2 != end2) {
     if (*begin1 < *begin2) {
       ++begin1;
@@ -934,8 +934,8 @@ template<typename InputIterator1, typename InputIterator2, typename Comp>
 bool SortedRangesHaveIntersection(InputIterator1 begin1, InputIterator1 end1,
                                   InputIterator2 begin2, InputIterator2 end2,
                                   Comp comparator) {
-  assert(util::gtl::is_sorted(begin1, end1, comparator));
-  assert(util::gtl::is_sorted(begin2, end2, comparator));
+  assert(std::is_sorted(begin1, end1, comparator));
+  assert(std::is_sorted(begin2, end2, comparator));
   while (begin1 != end1 && begin2 != end2) {
     if (comparator(*begin1, *begin2)) {
       ++begin1;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/strings/stringpiece.cc
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/strings/stringpiece.cc b/src/kudu/gutil/strings/stringpiece.cc
index a46bc05..9df0f38 100644
--- a/src/kudu/gutil/strings/stringpiece.cc
+++ b/src/kudu/gutil/strings/stringpiece.cc
@@ -4,33 +4,30 @@
 
 #include "kudu/gutil/strings/stringpiece.h"
 
-#include <string.h>
 #include <algorithm>
+#include <climits>
+#include <glog/logging.h>
+#include <string.h>
+#include <string>
+
+#include "kudu/gutil/hash/hash.h"
+#include "kudu/gutil/logging-inl.h"
+#include "kudu/gutil/stl_util.h"
+#include "kudu/gutil/strings/memutil.h"
+
 using std::copy;
 using std::max;
 using std::min;
 using std::reverse;
 using std::sort;
 using std::swap;
-#include <climits>
-#include <string>
 using std::string;
 
-#include <glog/logging.h>
-#include "kudu/gutil/logging-inl.h"
-#include "kudu/gutil/strings/memutil.h"
-#include "kudu/gutil/stl_util.h"
-#include "kudu/gutil/hash/hash.h"
-
-#include <ext/hash_set>
-namespace __gnu_cxx {
-
-size_t hash<StringPiece>::operator()(StringPiece s) const {
-  return HashTo32(s.data(), s.size());
-}
-
-}  // namespace __gnu_cxx
-
+namespace std {
+  size_t hash<StringPiece>::operator()(StringPiece s) const {
+    return HashTo32(s.data(), s.size());
+  }
+} // namespace std
 
 std::ostream& operator<<(std::ostream& o, StringPiece piece) {
   o.write(piece.data(), piece.size());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/strings/stringpiece.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/strings/stringpiece.h b/src/kudu/gutil/strings/stringpiece.h
index 12b258f..0f28f2b 100644
--- a/src/kudu/gutil/strings/stringpiece.h
+++ b/src/kudu/gutil/strings/stringpiece.h
@@ -114,13 +114,11 @@
 
 
 #include <assert.h>
-#include <stddef.h>
-#include <string.h>
-#include <ext/hash_map>
-using __gnu_cxx::hash;
-using __gnu_cxx::hash_map;
+#include <functional>
 #include <iosfwd>
 #include <limits>
+#include <stddef.h>
+#include <string.h>
 #include <string>
 
 #include "kudu/gutil/integral_types.h"
@@ -349,20 +347,12 @@ template <class X> struct GoodFastHash;
 
 // SWIG doesn't know how to parse this stuff properly. Omit it.
 #ifndef SWIG
-#include <ext/hash_set>
-namespace __gnu_cxx {
 
+namespace std {
 template<> struct hash<StringPiece> {
   size_t operator()(StringPiece s) const;
-  // Less than operator, for MSVC.
-  bool operator()(const StringPiece& s1, const StringPiece& s2) const {
-    return s1 < s2;
-  }
-  static const size_t bucket_size = 4;  // These are required by MSVC
-  static const size_t min_buckets = 8;  // 4 and 8 are defaults.
 };
-
-}  // namespace __gnu_cxx
+}  // namespace std
 
 
 // An implementation of GoodFastHash for StringPiece.  See

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/gutil/sysinfo.cc
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/sysinfo.cc b/src/kudu/gutil/sysinfo.cc
index 8c3c6be..fbb0f98 100644
--- a/src/kudu/gutil/sysinfo.cc
+++ b/src/kudu/gutil/sysinfo.cc
@@ -42,8 +42,6 @@
 #include <unistd.h>   // for read()
 #endif
 #if defined __MACH__          // Mac OS X, almost certainly
-#include <mach-o/dyld.h>      // for iterating over dll's in ProcMapsIter
-#include <mach-o/loader.h>    // for iterating over dll's in ProcMapsIter
 #include <sys/types.h>
 #include <sys/sysctl.h>       // how we figure out numcpu's on OS X
 #elif defined __FreeBSD__

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/all_types-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/all_types-itest.cc b/src/kudu/integration-tests/all_types-itest.cc
index 63da4a1..66333c2 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -16,7 +16,6 @@
 // under the License.
 
 #include <gtest/gtest.h>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/gutil/strings/substitute.h"
@@ -27,12 +26,13 @@
 
 DEFINE_int32(num_rows_per_tablet, 100, "The number of rows to be inserted into each tablet");
 
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
 namespace client {
 
+using sp::shared_ptr;
+
 static const int kNumTabletServers = 3;
 static const int kNumTablets = 3;
 static const int KMaxBatchSize = 8 * 1024 * 1024;
@@ -419,7 +419,7 @@ class AllTypesItest : public KuduTest {
   TestSetup setup_;
   KuduSchema schema_;
   vector<KuduPartialRow> split_rows_;
-  std::tr1::shared_ptr<KuduClient> client_;
+  shared_ptr<KuduClient> client_;
   gscoped_ptr<ExternalMiniCluster> cluster_;
   shared_ptr<KuduTable> table_;
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/alter_table-randomized-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/alter_table-randomized-test.cc b/src/kudu/integration-tests/alter_table-randomized-test.cc
index 27cd45b..3880c79 100644
--- a/src/kudu/integration-tests/alter_table-randomized-test.cc
+++ b/src/kudu/integration-tests/alter_table-randomized-test.cc
@@ -16,19 +16,17 @@
 // under the License.
 
 #include <boost/foreach.hpp>
-#include <boost/assign/list_of.hpp>
 
 #include <algorithm>
 #include <map>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/client/client-test-util.h"
-#include "kudu/integration-tests/cluster_verifier.h"
-#include "kudu/integration-tests/external_mini_cluster.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
+#include "kudu/integration-tests/cluster_verifier.h"
+#include "kudu/integration-tests/external_mini_cluster.h"
 #include "kudu/util/random.h"
 #include "kudu/util/random_util.h"
 #include "kudu/util/test_util.h"
@@ -48,10 +46,10 @@ using client::KuduTableAlterer;
 using client::KuduTableCreator;
 using client::KuduValue;
 using client::KuduWriteOperation;
+using client::sp::shared_ptr;
 using std::make_pair;
 using std::map;
 using std::pair;
-using std::tr1::shared_ptr;
 using std::vector;
 using strings::SubstituteAndAppend;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/alter_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc
index 4a71b1e..e0b0025 100644
--- a/src/kudu/integration-tests/alter_table-test.cc
+++ b/src/kudu/integration-tests/alter_table-test.cc
@@ -19,10 +19,9 @@
 #include <boost/foreach.hpp>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include <map>
 #include <string>
-#include <tr1/memory>
 #include <utility>
-#include <map>
 
 #include "kudu/client/client.h"
 #include "kudu/client/client-test-util.h"
@@ -56,10 +55,6 @@ DECLARE_bool(use_hybrid_clock);
 
 namespace kudu {
 
-using std::map;
-using std::pair;
-using std::vector;
-using std::tr1::shared_ptr;
 using client::KuduClient;
 using client::KuduClientBuilder;
 using client::KuduColumnSchema;
@@ -75,9 +70,13 @@ using client::KuduTableAlterer;
 using client::KuduTableCreator;
 using client::KuduUpdate;
 using client::KuduValue;
-using master::MiniMaster;
+using client::sp::shared_ptr;
 using master::AlterTableRequestPB;
 using master::AlterTableResponsePB;
+using master::MiniMaster;
+using std::map;
+using std::pair;
+using std::vector;
 using tablet::TabletPeer;
 using tserver::MiniTabletServer;
 
@@ -239,7 +238,7 @@ class AlterTableTest : public KuduTest {
   static const char *kTableName;
 
   gscoped_ptr<MiniCluster> cluster_;
-  std::tr1::shared_ptr<KuduClient> client_;
+  shared_ptr<KuduClient> client_;
 
   KuduSchema schema_;
 
@@ -558,8 +557,8 @@ TEST_F(AlterTableTest, TestBootstrapAfterAlters) {
   ASSERT_OK(tablet_peer_->tablet()->Flush());
   InsertRows(1, 1);
 
-  UpdateRow(0, boost::assign::map_list_of("c1", 10001));
-  UpdateRow(1, boost::assign::map_list_of("c1", 10002));
+  UpdateRow(0, { {"c1", 10001} });
+  UpdateRow(1, { {"c1", 10002} });
 
   NO_FATALS(ScanToStrings(&rows));
   ASSERT_EQ(2, rows.size());
@@ -618,7 +617,7 @@ TEST_F(AlterTableTest, TestCompactAfterUpdatingRemovedColumn) {
   ASSERT_EQ("(int32 c0=16777216, int32 c1=1, int32 c2=12345)", rows[1]);
 
   // Add a delta for c1.
-  UpdateRow(0, boost::assign::map_list_of("c1", 54321));
+  UpdateRow(0, { {"c1", 54321} });
 
   // Drop c1.
   LOG(INFO) << "Dropping c1";
@@ -651,7 +650,7 @@ TEST_F(AlterTableTest, TestMajorCompactDeltasAfterUpdatingRemovedColumn) {
   ASSERT_EQ("(int32 c0=0, int32 c1=0, int32 c2=12345)", rows[0]);
 
   // Add a delta for c1.
-  UpdateRow(0, boost::assign::map_list_of("c1", 54321));
+  UpdateRow(0, { {"c1", 54321} });
 
   // Make sure the delta is in a delta-file.
   ASSERT_OK(tablet_peer_->tablet()->FlushBiggestDMS());
@@ -700,7 +699,7 @@ TEST_F(AlterTableTest, TestMajorCompactDeltasIntoMissingBaseData) {
   ASSERT_OK(AddNewI32Column(kTableName, "c2", 12345));
 
   // Add a delta for c2.
-  UpdateRow(0, boost::assign::map_list_of("c2", 54321));
+  UpdateRow(0, { {"c2", 54321} });
 
   // Make sure the delta is in a delta-file.
   ASSERT_OK(tablet_peer_->tablet()->FlushBiggestDMS());
@@ -749,7 +748,7 @@ TEST_F(AlterTableTest, TestMajorCompactDeltasAfterAddUpdateRemoveColumn) {
   ASSERT_OK(AddNewI32Column(kTableName, "c2", 12345));
 
   // Add a delta for c2.
-  UpdateRow(0, boost::assign::map_list_of("c2", 54321));
+  UpdateRow(0, { {"c2", 54321} });
 
   // Make sure the delta is in a delta-file.
   ASSERT_OK(tablet_peer_->tablet()->FlushBiggestDMS());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/client-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/client-stress-test.cc b/src/kudu/integration-tests/client-stress-test.cc
index 988df2e..fb1c52c 100644
--- a/src/kudu/integration-tests/client-stress-test.cc
+++ b/src/kudu/integration-tests/client-stress-test.cc
@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/client/client-test-util.h"
@@ -36,7 +35,6 @@ METRIC_DECLARE_counter(leader_memory_pressure_rejections);
 METRIC_DECLARE_counter(follower_memory_pressure_rejections);
 
 using strings::Substitute;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
@@ -54,7 +52,7 @@ class ClientStressTest : public KuduTest {
     ExternalMiniClusterOptions opts = default_opts();
     if (multi_master()) {
       opts.num_masters = 3;
-      opts.master_rpc_ports = boost::assign::list_of(11010)(11011)(11012);
+      opts.master_rpc_ports = { 11010, 11011, 11012 };
     }
     opts.num_tablet_servers = 3;
     cluster_.reset(new ExternalMiniCluster(opts));
@@ -69,7 +67,7 @@ class ClientStressTest : public KuduTest {
 
  protected:
   void ScannerThread(KuduClient* client, const CountDownLatch* go_latch, int32_t start_key) {
-    shared_ptr<KuduTable> table;
+    client::sp::shared_ptr<KuduTable> table;
     CHECK_OK(client->OpenTable(TestWorkload::kDefaultTableName, &table));
     vector<string> rows;
 
@@ -129,7 +127,7 @@ TEST_F(ClientStressTest, TestStartScans) {
   for (int run = 1; run <= (AllowSlowTests() ? 10 : 2); run++) {
     LOG(INFO) << "Starting run " << run;
     KuduClientBuilder builder;
-    shared_ptr<KuduClient> client;
+    client::sp::shared_ptr<KuduClient> client;
     CHECK_OK(cluster_->CreateClient(builder, &client));
 
     CountDownLatch go_latch(1);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/cluster_itest_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.cc b/src/kudu/integration-tests/cluster_itest_util.cc
index a7da471..48f88b4 100644
--- a/src/kudu/integration-tests/cluster_itest_util.cc
+++ b/src/kudu/integration-tests/cluster_itest_util.cc
@@ -72,9 +72,9 @@ using master::TabletLocationsPB;
 using rpc::Messenger;
 using rpc::RpcController;
 using std::min;
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 using tserver::CreateTsClientProxies;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/cluster_itest_util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.h b/src/kudu/integration-tests/cluster_itest_util.h
index 78ce527..c908dc4 100644
--- a/src/kudu/integration-tests/cluster_itest_util.h
+++ b/src/kudu/integration-tests/cluster_itest_util.h
@@ -28,9 +28,9 @@
 #define KUDU_INTEGRATION_TESTS_CLUSTER_ITEST_UTIL_H_
 
 #include <boost/optional/optional_fwd.hpp>
+#include <memory>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/gutil/gscoped_ptr.h"
@@ -86,10 +86,10 @@ struct TServerDetails {
 };
 
 // tablet_id -> replica map.
-typedef std::tr1::unordered_multimap<std::string, TServerDetails*> TabletReplicaMap;
+typedef std::unordered_multimap<std::string, TServerDetails*> TabletReplicaMap;
 
 // uuid -> tablet server map.
-typedef std::tr1::unordered_map<std::string, TServerDetails*> TabletServerMap;
+typedef std::unordered_map<std::string, TServerDetails*> TabletServerMap;
 
 // Returns possibly the simplest imaginable schema, with a single int key column.
 client::KuduSchema SimpleIntKeyKuduSchema();
@@ -98,8 +98,8 @@ client::KuduSchema SimpleIntKeyKuduSchema();
 // Note: The bare-pointer TServerDetails values must be deleted by the caller!
 // Consider using ValueDeleter (in gutil/stl_util.h) for that.
 Status CreateTabletServerMap(master::MasterServiceProxy* master_proxy,
-                             const std::tr1::shared_ptr<rpc::Messenger>& messenger,
-                             std::tr1::unordered_map<std::string, TServerDetails*>* ts_map);
+                             const std::shared_ptr<rpc::Messenger>& messenger,
+                             std::unordered_map<std::string, TServerDetails*>* ts_map);
 
 // Gets a vector containing the latest OpId for each of the given replicas.
 // Returns a bad Status if any replica cannot be reached.
@@ -231,13 +231,13 @@ Status ListRunningTabletIds(const TServerDetails* ts,
                             std::vector<std::string>* tablet_ids);
 
 // Get the list of tablet locations for the specified tablet from the Master.
-Status GetTabletLocations(const std::tr1::shared_ptr<master::MasterServiceProxy>& master_proxy,
+Status GetTabletLocations(const std::shared_ptr<master::MasterServiceProxy>& master_proxy,
                           const std::string& tablet_id,
                           const MonoDelta& timeout,
                           master::TabletLocationsPB* tablet_locations);
 
 // Get the list of tablet locations for all tablets in the specified table from the Master.
-Status GetTableLocations(const std::tr1::shared_ptr<master::MasterServiceProxy>& master_proxy,
+Status GetTableLocations(const std::shared_ptr<master::MasterServiceProxy>& master_proxy,
                          const std::string& table_name,
                          const MonoDelta& timeout,
                          master::GetTableLocationsResponsePB* table_locations);
@@ -245,7 +245,7 @@ Status GetTableLocations(const std::tr1::shared_ptr<master::MasterServiceProxy>&
 // Wait for the specified number of voters to be reported to the config on the
 // master for the specified tablet.
 Status WaitForNumVotersInConfigOnMaster(
-    const std::tr1::shared_ptr<master::MasterServiceProxy>& master_proxy,
+    const std::shared_ptr<master::MasterServiceProxy>& master_proxy,
     const std::string& tablet_id,
     int num_voters,
     const MonoDelta& timeout);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/cluster_verifier.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_verifier.cc b/src/kudu/integration-tests/cluster_verifier.cc
index 99bf45a..e876875 100644
--- a/src/kudu/integration-tests/cluster_verifier.cc
+++ b/src/kudu/integration-tests/cluster_verifier.cc
@@ -17,7 +17,7 @@
 
 #include <gtest/gtest.h>
 #include <string>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/client/client.h"
@@ -29,7 +29,6 @@
 #include "kudu/util/monotime.h"
 #include "kudu/util/test_util.h"
 
-using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
@@ -81,10 +80,10 @@ void ClusterVerifier::CheckCluster() {
 Status ClusterVerifier::DoKsck() {
   Sockaddr addr = cluster_->leader_master()->bound_rpc_addr();
 
-  shared_ptr<KsckMaster> master;
+  std::shared_ptr<KsckMaster> master;
   RETURN_NOT_OK(RemoteKsckMaster::Build(addr, &master));
-  shared_ptr<KsckCluster> cluster(new KsckCluster(master));
-  shared_ptr<Ksck> ksck(new Ksck(cluster));
+  std::shared_ptr<KsckCluster> cluster(new KsckCluster(master));
+  std::shared_ptr<Ksck> ksck(new Ksck(cluster));
 
   // This is required for everything below.
   RETURN_NOT_OK(ksck->CheckMasterRunning());
@@ -107,12 +106,12 @@ void ClusterVerifier::CheckRowCount(const std::string& table_name,
 Status ClusterVerifier::DoCheckRowCount(const std::string& table_name,
                                         ComparisonMode mode,
                                         int expected_row_count) {
-  shared_ptr<client::KuduClient> client;
+  client::sp::shared_ptr<client::KuduClient> client;
   client::KuduClientBuilder builder;
   RETURN_NOT_OK_PREPEND(cluster_->CreateClient(builder,
                                                &client),
                         "Unable to connect to cluster");
-  shared_ptr<client::KuduTable> table;
+  client::sp::shared_ptr<client::KuduTable> table;
   RETURN_NOT_OK_PREPEND(client->OpenTable(table_name, &table),
                         "Unable to open table");
   client::KuduScanner scanner(table.get());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/create-table-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/create-table-itest.cc b/src/kudu/integration-tests/create-table-itest.cc
index 6d64ee7..e1a360e 100644
--- a/src/kudu/integration-tests/create-table-itest.cc
+++ b/src/kudu/integration-tests/create-table-itest.cc
@@ -17,8 +17,8 @@
 
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/client/client-test-util.h"
 #include "kudu/common/wire_protocol-test-util.h"

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/create-table-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/create-table-stress-test.cc b/src/kudu/integration-tests/create-table-stress-test.cc
index 55e5f8e..0a2ddf3 100644
--- a/src/kudu/integration-tests/create-table-stress-test.cc
+++ b/src/kudu/integration-tests/create-table-stress-test.cc
@@ -15,12 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/bind.hpp>
 #include <boost/thread/thread.hpp>
 #include <glog/stl_logging.h>
 #include <gtest/gtest.h>
-#include <tr1/memory>
+#include <memory>
 
 #include "kudu/client/client.h"
 #include "kudu/common/schema.h"
@@ -37,8 +36,6 @@
 #include "kudu/util/stopwatch.h"
 #include "kudu/util/test_util.h"
 
-using std::tr1::shared_ptr;
-
 using kudu::client::KuduClient;
 using kudu::client::KuduClientBuilder;
 using kudu::client::KuduColumnSchema;
@@ -114,10 +111,10 @@ class CreateTableStressTest : public KuduTest {
   void CreateBigTable(const string& table_name, int num_tablets);
 
  protected:
-  shared_ptr<KuduClient> client_;
+  client::sp::shared_ptr<KuduClient> client_;
   gscoped_ptr<MiniCluster> cluster_;
   KuduSchema schema_;
-  shared_ptr<Messenger> messenger_;
+  std::shared_ptr<Messenger> messenger_;
   gscoped_ptr<MasterServiceProxy> master_proxy_;
   TabletServerMap ts_map_;
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/delete_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/delete_table-test.cc b/src/kudu/integration-tests/delete_table-test.cc
index b5ad767..5c11d55 100644
--- a/src/kudu/integration-tests/delete_table-test.cc
+++ b/src/kudu/integration-tests/delete_table-test.cc
@@ -19,8 +19,9 @@
 #include <boost/optional.hpp>
 #include <glog/stl_logging.h>
 #include <gtest/gtest.h>
-#include <tr1/memory>
+#include <memory>
 #include <string>
+#include <unordered_map>
 
 #include "kudu/client/client-test-util.h"
 #include "kudu/common/wire_protocol-test-util.h"
@@ -33,6 +34,8 @@
 #include "kudu/tserver/tserver.pb.h"
 #include "kudu/util/curl_util.h"
 
+using kudu::client::KuduClient;
+using kudu::client::KuduClientBuilder;
 using kudu::client::KuduSchema;
 using kudu::client::KuduSchemaFromSchema;
 using kudu::client::KuduTableCreator;
@@ -41,16 +44,17 @@ using kudu::consensus::ConsensusMetadataPB;
 using kudu::consensus::ConsensusStatePB;
 using kudu::consensus::RaftPeerPB;
 using kudu::itest::TServerDetails;
-using kudu::tablet::TabletDataState;
 using kudu::tablet::TABLET_DATA_COPYING;
 using kudu::tablet::TABLET_DATA_DELETED;
 using kudu::tablet::TABLET_DATA_READY;
 using kudu::tablet::TABLET_DATA_TOMBSTONED;
+using kudu::tablet::TabletDataState;
 using kudu::tablet::TabletSuperBlockPB;
 using kudu::tserver::ListTabletsResponsePB;
 using kudu::tserver::TabletServerErrorPB;
 using std::numeric_limits;
 using std::string;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/external_mini_cluster-itest-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster-itest-base.h b/src/kudu/integration-tests/external_mini_cluster-itest-base.h
index a2480a3..e2a9cf5 100644
--- a/src/kudu/integration-tests/external_mini_cluster-itest-base.h
+++ b/src/kudu/integration-tests/external_mini_cluster-itest-base.h
@@ -19,9 +19,8 @@
 #define KUDU_INTEGRATION_TESTS_EXTERNAL_MINI_CLUSTER_ITEST_BASE_H_
 
 #include <gtest/gtest.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/client/client.h"
@@ -67,8 +66,8 @@ class ExternalMiniClusterITestBase : public KuduTest {
 
   gscoped_ptr<ExternalMiniCluster> cluster_;
   gscoped_ptr<itest::ExternalMiniClusterFsInspector> inspect_;
-  std::tr1::shared_ptr<client::KuduClient> client_;
-  std::tr1::unordered_map<std::string, itest::TServerDetails*> ts_map_;
+  client::sp::shared_ptr<client::KuduClient> client_;
+  std::unordered_map<std::string, itest::TServerDetails*> ts_map_;
 };
 
 void ExternalMiniClusterITestBase::StartCluster(const std::vector<std::string>& extra_ts_flags,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/external_mini_cluster-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster-test.cc b/src/kudu/integration-tests/external_mini_cluster-test.cc
index 9304a05..ddc8230 100644
--- a/src/kudu/integration-tests/external_mini_cluster-test.cc
+++ b/src/kudu/integration-tests/external_mini_cluster-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
@@ -41,7 +40,7 @@ class EMCTest : public KuduTest {
     // Hard-coded RPC ports for the masters. This is safe, as this unit test
     // runs under a resource lock (see CMakeLists.txt in this directory).
     // TODO we should have a generic method to obtain n free ports.
-    master_peer_ports_ = boost::assign::list_of(11010)(11011)(11012);
+    master_peer_ports_ = { 11010, 11011, 11012 };
   }
 
  protected:

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/external_mini_cluster.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster.cc b/src/kudu/integration-tests/external_mini_cluster.cc
index f8bccb6..4ca4934 100644
--- a/src/kudu/integration-tests/external_mini_cluster.cc
+++ b/src/kudu/integration-tests/external_mini_cluster.cc
@@ -19,9 +19,9 @@
 
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
+#include <memory>
 #include <rapidjson/document.h>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/client/client.h"
 #include "kudu/common/wire_protocol.h"
@@ -47,16 +47,16 @@
 #include "kudu/util/subprocess.h"
 #include "kudu/util/test_util.h"
 
-using rapidjson::Value;
-using std::string;
-using std::tr1::shared_ptr;
-using strings::Substitute;
 using kudu::master::GetLeaderMasterRpc;
 using kudu::master::MasterServiceProxy;
 using kudu::server::ServerStatusPB;
-using kudu::tserver::TabletServerServiceProxy;
 using kudu::tserver::ListTabletsRequestPB;
 using kudu::tserver::ListTabletsResponsePB;
+using kudu::tserver::TabletServerServiceProxy;
+using rapidjson::Value;
+using std::string;
+using strings::Substitute;
+
 typedef ListTabletsResponsePB::StatusAndSchemaPB StatusAndSchemaPB;
 
 namespace kudu {
@@ -442,23 +442,23 @@ vector<ExternalDaemon*> ExternalMiniCluster::daemons() const {
   return results;
 }
 
-shared_ptr<rpc::Messenger> ExternalMiniCluster::messenger() {
+std::shared_ptr<rpc::Messenger> ExternalMiniCluster::messenger() {
   return messenger_;
 }
 
-shared_ptr<MasterServiceProxy> ExternalMiniCluster::master_proxy() {
+std::shared_ptr<MasterServiceProxy> ExternalMiniCluster::master_proxy() {
   CHECK_EQ(masters_.size(), 1);
   return master_proxy(0);
 }
 
-shared_ptr<MasterServiceProxy> ExternalMiniCluster::master_proxy(int idx) {
+std::shared_ptr<MasterServiceProxy> ExternalMiniCluster::master_proxy(int idx) {
   CHECK_LT(idx, masters_.size());
-  return shared_ptr<MasterServiceProxy>(
+  return std::shared_ptr<MasterServiceProxy>(
       new MasterServiceProxy(messenger_, CHECK_NOTNULL(master(idx))->bound_rpc_addr()));
 }
 
 Status ExternalMiniCluster::CreateClient(client::KuduClientBuilder& builder,
-                                         shared_ptr<client::KuduClient>* client) {
+                                         client::sp::shared_ptr<client::KuduClient>* client) {
   CHECK(!masters_.empty());
   builder.clear_master_server_addrs();
   BOOST_FOREACH(const scoped_refptr<ExternalMaster>& master, masters_) {
@@ -492,7 +492,7 @@ Status ExternalMiniCluster::SetFlag(ExternalDaemon* daemon,
 // ExternalDaemon
 //------------------------------------------------------------
 
-ExternalDaemon::ExternalDaemon(const shared_ptr<rpc::Messenger>& messenger,
+ExternalDaemon::ExternalDaemon(const std::shared_ptr<rpc::Messenger>& messenger,
                                const string& exe,
                                const string& data_dir,
                                const vector<string>& extra_flags) :
@@ -774,7 +774,7 @@ ScopedResumeExternalDaemon::~ScopedResumeExternalDaemon() {
 // ExternalMaster
 //------------------------------------------------------------
 
-ExternalMaster::ExternalMaster(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+ExternalMaster::ExternalMaster(const std::shared_ptr<rpc::Messenger>& messenger,
                                const string& exe,
                                const string& data_dir,
                                const vector<string>& extra_flags)
@@ -782,7 +782,7 @@ ExternalMaster::ExternalMaster(const std::tr1::shared_ptr<rpc::Messenger>& messe
       rpc_bind_address_("127.0.0.1:0") {
 }
 
-ExternalMaster::ExternalMaster(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+ExternalMaster::ExternalMaster(const std::shared_ptr<rpc::Messenger>& messenger,
                                const string& exe,
                                const string& data_dir,
                                const string& rpc_bind_address,
@@ -825,7 +825,7 @@ Status ExternalMaster::Restart() {
 // ExternalTabletServer
 //------------------------------------------------------------
 
-ExternalTabletServer::ExternalTabletServer(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+ExternalTabletServer::ExternalTabletServer(const std::shared_ptr<rpc::Messenger>& messenger,
                                            const string& exe,
                                            const string& data_dir,
                                            const string& bind_host,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/external_mini_cluster.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/external_mini_cluster.h b/src/kudu/integration-tests/external_mini_cluster.h
index 65c714b..f03a61e 100644
--- a/src/kudu/integration-tests/external_mini_cluster.h
+++ b/src/kudu/integration-tests/external_mini_cluster.h
@@ -17,9 +17,9 @@
 #ifndef KUDU_INTEGRATION_TESTS_EXTERNAL_MINI_CLUSTER_H
 #define KUDU_INTEGRATION_TESTS_EXTERNAL_MINI_CLUSTER_H
 
+#include <memory>
 #include <string>
 #include <sys/types.h>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/client/client.h"
@@ -211,16 +211,16 @@ class ExternalMiniCluster {
   }
 
   // Return the client messenger used by the ExternalMiniCluster.
-  std::tr1::shared_ptr<rpc::Messenger> messenger();
+  std::shared_ptr<rpc::Messenger> messenger();
 
   // If the cluster is configured for a single non-distributed master,
   // return a proxy to that master. Requires that the single master is
   // running.
-  std::tr1::shared_ptr<master::MasterServiceProxy> master_proxy();
+  std::shared_ptr<master::MasterServiceProxy> master_proxy();
 
   // Returns an RPC proxy to the master at 'idx'. Requires that the
   // master at 'idx' is running.
-  std::tr1::shared_ptr<master::MasterServiceProxy> master_proxy(int idx);
+  std::shared_ptr<master::MasterServiceProxy> master_proxy(int idx);
 
   // Wait until the number of registered tablet servers reaches the
   // given count on at least one of the running masters.  Returns
@@ -241,7 +241,7 @@ class ExternalMiniCluster {
   //
   // REQUIRES: the cluster must have already been Start()ed.
   Status CreateClient(client::KuduClientBuilder& builder,
-                      std::tr1::shared_ptr<client::KuduClient>* client);
+                      client::sp::shared_ptr<client::KuduClient>* client);
 
   // Sets the given flag on the given daemon, which must be running.
   //
@@ -274,14 +274,14 @@ class ExternalMiniCluster {
   std::vector<scoped_refptr<ExternalMaster> > masters_;
   std::vector<scoped_refptr<ExternalTabletServer> > tablet_servers_;
 
-  std::tr1::shared_ptr<rpc::Messenger> messenger_;
+  std::shared_ptr<rpc::Messenger> messenger_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalMiniCluster);
 };
 
 class ExternalDaemon : public RefCountedThreadSafe<ExternalDaemon> {
  public:
-  ExternalDaemon(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+  ExternalDaemon(const std::shared_ptr<rpc::Messenger>& messenger,
                  const std::string& exe, const std::string& data_dir,
                  const std::vector<std::string>& extra_flags);
 
@@ -342,7 +342,7 @@ class ExternalDaemon : public RefCountedThreadSafe<ExternalDaemon> {
   // In a non-coverage build, this does nothing.
   void FlushCoverage();
 
-  const std::tr1::shared_ptr<rpc::Messenger> messenger_;
+  const std::shared_ptr<rpc::Messenger> messenger_;
   const std::string exe_;
   const std::string data_dir_;
   std::vector<std::string> extra_flags_;
@@ -379,11 +379,11 @@ class ScopedResumeExternalDaemon {
 
 class ExternalMaster : public ExternalDaemon {
  public:
-  ExternalMaster(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+  ExternalMaster(const std::shared_ptr<rpc::Messenger>& messenger,
                  const std::string& exe, const std::string& data_dir,
                  const std::vector<std::string>& extra_flags);
 
-  ExternalMaster(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+  ExternalMaster(const std::shared_ptr<rpc::Messenger>& messenger,
                  const std::string& exe, const std::string& data_dir,
                  const std::string& rpc_bind_address,
                  const std::vector<std::string>& extra_flags);
@@ -404,7 +404,7 @@ class ExternalMaster : public ExternalDaemon {
 
 class ExternalTabletServer : public ExternalDaemon {
  public:
-  ExternalTabletServer(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+  ExternalTabletServer(const std::shared_ptr<rpc::Messenger>& messenger,
                        const std::string& exe, const std::string& data_dir,
                        const std::string& bind_host,
                        const std::vector<HostPort>& master_addrs,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/flex_partitioning-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/flex_partitioning-itest.cc b/src/kudu/integration-tests/flex_partitioning-itest.cc
index 94dd2ee..e481876 100644
--- a/src/kudu/integration-tests/flex_partitioning-itest.cc
+++ b/src/kudu/integration-tests/flex_partitioning-itest.cc
@@ -20,10 +20,9 @@
 
 #include <algorithm>
 #include <boost/foreach.hpp>
-#include <boost/assign/list_of.hpp>
 #include <glog/stl_logging.h>
 #include <map>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 #include "kudu/client/client-test-util.h"
@@ -42,7 +41,6 @@
 namespace kudu {
 namespace itest {
 
-using boost::assign::list_of;
 using client::KuduClient;
 using client::KuduClientBuilder;
 using client::KuduColumnSchema;
@@ -55,8 +53,8 @@ using client::KuduSession;
 using client::KuduTable;
 using client::KuduTableCreator;
 using client::KuduValue;
-using std::tr1::unordered_map;
-using std::tr1::shared_ptr;
+using client::sp::shared_ptr;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 
@@ -407,7 +405,7 @@ TEST_F(FlexPartitioningITest, TestSimplePartitioning) {
   NO_FATALS(CreateTable(1, // 2 columns
                         vector<string>(), 0, // No hash buckets
                         vector<string>(), 0, // No hash buckets
-                        list_of<string>("c0"), // no range partitioning
+                        { "c0" }, // no range partitioning
                         2)); // 1 split;
   ASSERT_EQ(2, CountTablets());
 
@@ -420,9 +418,9 @@ TEST_F(FlexPartitioningITest, TestSimplePartitioning) {
 // );
 TEST_F(FlexPartitioningITest, TestSinglePKBucketed) {
   NO_FATALS(CreateTable(1, // 1 column
-                        list_of("c0"), 3, // bucket by "c0" in 3 buckets
+                        { "c0" }, 3, // bucket by "c0" in 3 buckets
                         vector<string>(), 0, // no other buckets
-                        list_of<string>("c0"), // default range
+                        { "c0" }, // default range
                         2)); // one split
   ASSERT_EQ(6, CountTablets());
 
@@ -437,9 +435,9 @@ TEST_F(FlexPartitioningITest, TestSinglePKBucketed) {
 // );
 TEST_F(FlexPartitioningITest, TestCompositePK_BucketOnSecondColumn) {
   NO_FATALS(CreateTable(2, // 2 columns
-                        list_of("c1"), 3, // bucket by "c0" in 3 buckets
+                        { "c1" }, 3, // bucket by "c0" in 3 buckets
                         vector<string>(), 0, // no other buckets
-                        list_of<string>("c0")("c1"), // default range
+                        { "c0", "c1" }, // default range
                         1)); // no splits;
   ASSERT_EQ(3, CountTablets());
 
@@ -456,7 +454,7 @@ TEST_F(FlexPartitioningITest, TestCompositePK_RangePartitionByReversedPK) {
   NO_FATALS(CreateTable(2, // 2 columns
                         vector<string>(), 0, // no buckets
                         vector<string>(), 0, // no buckets
-                        list_of<string>("c1")("c0"), // range partition by reversed PK
+                        { "c1", "c0" }, // range partition by reversed PK
                         2)); // one split
   ASSERT_EQ(2, CountTablets());
 
@@ -473,7 +471,7 @@ TEST_F(FlexPartitioningITest, TestCompositePK_RangePartitionByPKPrefix) {
   NO_FATALS(CreateTable(2, // 2 columns
                         vector<string>(), 0, // no buckets
                         vector<string>(), 0, // no buckets
-                        list_of<string>("c0"), // range partition by c0
+                        { "c0" }, // range partition by c0
                         2)); // one split
   ASSERT_EQ(2, CountTablets());
 
@@ -490,7 +488,7 @@ TEST_F(FlexPartitioningITest, TestCompositePK_RangePartitionByPKSuffix) {
   NO_FATALS(CreateTable(2, // 2 columns
                         vector<string>(), 0, // no buckets
                         vector<string>(), 0, // no buckets
-                        list_of<string>("c1"), // range partition by c1
+                        { "c1" }, // range partition by c1
                         2)); // one split
   ASSERT_EQ(2, CountTablets());
 
@@ -506,9 +504,9 @@ TEST_F(FlexPartitioningITest, TestCompositePK_RangePartitionByPKSuffix) {
 // );
 TEST_F(FlexPartitioningITest, TestCompositePK_RangeAndBucket) {
   NO_FATALS(CreateTable(2, // 2 columns
-                        list_of<string>("c1"), 4, // BUCKET BY c1 INTO 4 BUCKETS
+                        { "c1" }, 4, // BUCKET BY c1 INTO 4 BUCKETS
                         vector<string>(), 0, // no buckets
-                        list_of<string>("c0"), // range partition by c0
+                        { "c0" }, // range partition by c0
                         2)); // 1 split;
   ASSERT_EQ(8, CountTablets());
 
@@ -524,9 +522,9 @@ TEST_F(FlexPartitioningITest, TestCompositePK_RangeAndBucket) {
 // );
 TEST_F(FlexPartitioningITest, TestCompositePK_MultipleBucketings) {
   NO_FATALS(CreateTable(2, // 2 columns
-                        list_of<string>("c1"), 4, // BUCKET BY c1 INTO 4 BUCKETS
-                        list_of<string>("c0"), 3, // BUCKET BY c0 INTO 3 BUCKETS
-                        list_of<string>("c0")("c1"), // default range partitioning
+                        { "c1" }, 4, // BUCKET BY c1 INTO 4 BUCKETS
+                        { "c0" }, 3, // BUCKET BY c0 INTO 3 BUCKETS
+                        { "c0", "c1" }, // default range partitioning
                         2)); // 1 split;
   ASSERT_EQ(4 * 3 * 2, CountTablets());
 
@@ -542,7 +540,7 @@ TEST_F(FlexPartitioningITest, TestCompositePK_MultipleBucketings) {
 // );
 TEST_F(FlexPartitioningITest, TestCompositePK_SingleBucketNoRange) {
   NO_FATALS(CreateTable(2, // 2 columns
-                        list_of<string>("c0"), 4, // BUCKET BY c0 INTO 4 BUCKETS
+                        { "c0" }, 4, // BUCKET BY c0 INTO 4 BUCKETS
                         vector<string>(), 0, // no buckets
                         vector<string>(), // no range partitioning
                         1)); // 0 splits;
@@ -561,8 +559,8 @@ TEST_F(FlexPartitioningITest, TestCompositePK_SingleBucketNoRange) {
 // );
 TEST_F(FlexPartitioningITest, TestCompositePK_MultipleBucketingsNoRange) {
   NO_FATALS(CreateTable(2, // 2 columns
-                        list_of<string>("c0"), 4, // BUCKET BY c0 INTO 4 BUCKETS
-                        list_of<string>("c1"), 5, // BUCKET BY c1 INTO 5 BUCKETS
+                        { "c0" }, 4, // BUCKET BY c0 INTO 4 BUCKETS
+                        { "c1" }, 5, // BUCKET BY c1 INTO 5 BUCKETS
                         vector<string>(), // no range partitioning
                         1)); // 0 splits;
   ASSERT_EQ(20, CountTablets());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/full_stack-insert-scan-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/full_stack-insert-scan-test.cc b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
index 78bbfc3..c42707f 100644
--- a/src/kudu/integration-tests/full_stack-insert-scan-test.cc
+++ b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
@@ -15,16 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-
 #include <cmath>
 #include <cstdlib>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <memory>
 #include <signal.h>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/client/callbacks.h"
@@ -74,18 +72,16 @@ DEFINE_bool(perf_fp_flag, false, "Only applicable with --perf_record_scan,"
             " provides argument \"fp\" to the --call-graph flag");
 DECLARE_bool(enable_maintenance_manager);
 
-using boost::assign::list_of;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
 namespace tablet {
 
-using client::KuduInsert;
 using client::KuduClient;
 using client::KuduClientBuilder;
 using client::KuduColumnSchema;
+using client::KuduInsert;
 using client::KuduRowResult;
 using client::KuduScanner;
 using client::KuduSchema;
@@ -179,7 +175,7 @@ class FullStackInsertScanTest : public KuduTest {
   // Adds newly generated client's session and table pointers to arrays at id
   void CreateNewClient(int id) {
     ASSERT_OK(client_->OpenTable(kTableName, &tables_[id]));
-    shared_ptr<KuduSession> session = client_->NewSession();
+    client::sp::shared_ptr<KuduSession> session = client_->NewSession();
     session->SetTimeoutMillis(kSessionTimeoutMs);
     ASSERT_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH));
     sessions_[id] = session;
@@ -213,12 +209,12 @@ class FullStackInsertScanTest : public KuduTest {
   Random random_;
 
   KuduSchema schema_;
-  shared_ptr<MiniCluster> cluster_;
-  shared_ptr<KuduClient> client_;
-  shared_ptr<KuduTable> reader_table_;
+  std::shared_ptr<MiniCluster> cluster_;
+  client::sp::shared_ptr<KuduClient> client_;
+  client::sp::shared_ptr<KuduTable> reader_table_;
   // Concurrent client insertion test variables
-  vector<shared_ptr<KuduSession> > sessions_;
-  vector<shared_ptr<KuduTable> > tables_;
+  vector<client::sp::shared_ptr<KuduSession> > sessions_;
+  vector<client::sp::shared_ptr<KuduTable> > tables_;
 };
 
 namespace {
@@ -320,7 +316,7 @@ void FullStackInsertScanTest::DoTestScans() {
   if (record) record->Start();
 
   NO_FATALS(ScanProjection(vector<string>(), "empty projection, 0 col"));
-  NO_FATALS(ScanProjection(list_of<string>("key"), "key scan, 1 col"));
+  NO_FATALS(ScanProjection({ "key" }, "key scan, 1 col"));
   NO_FATALS(ScanProjection(AllColumnNames(), "full schema scan, 10 col"));
   NO_FATALS(ScanProjection(StringColumnNames(), "String projection, 1 col"));
   NO_FATALS(ScanProjection(Int32ColumnNames(), "Int32 projection, 4 col"));
@@ -353,8 +349,8 @@ void FullStackInsertScanTest::InsertRows(CountDownLatch* start_latch, int id,
 
   start_latch->Wait();
   // Retrieve id's session and table
-  shared_ptr<KuduSession> session = sessions_[id];
-  shared_ptr<KuduTable> table = tables_[id];
+  client::sp::shared_ptr<KuduSession> session = sessions_[id];
+  client::sp::shared_ptr<KuduTable> table = tables_[id];
   // Identify start and end of keyrange id is responsible for
   int64_t start = kNumInsertsPerClient * id;
   int64_t end = start + kNumInsertsPerClient;
@@ -446,23 +442,21 @@ vector<string> FullStackInsertScanTest::AllColumnNames() const {
 }
 
 vector<string> FullStackInsertScanTest::StringColumnNames() const {
-  return list_of<string>("string_val");
+  return { "string_val" };
 }
 
 vector<string> FullStackInsertScanTest::Int32ColumnNames() const {
-  return list_of<string>
-    ("int32_val1")
-    ("int32_val2")
-    ("int32_val3")
-    ("int32_val4");
+  return { "int32_val1",
+           "int32_val2",
+           "int32_val3",
+           "int32_val4" };
 }
 
 vector<string> FullStackInsertScanTest::Int64ColumnNames() const {
-  return list_of<string>
-    ("int64_val1")
-    ("int64_val2")
-    ("int64_val3")
-    ("int64_val4");
+  return { "int64_val1",
+           "int64_val2",
+           "int64_val3",
+           "int64_val4" };
 }
 
 } // namespace tablet

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/linked_list-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test-util.h b/src/kudu/integration-tests/linked_list-test-util.h
index 6e95069..42a0891 100644
--- a/src/kudu/integration-tests/linked_list-test-util.h
+++ b/src/kudu/integration-tests/linked_list-test-util.h
@@ -16,13 +16,11 @@
 // under the License.
 
 #include <algorithm>
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
 #include <iostream>
 #include <list>
 #include <string>
-#include <tr1/memory>
 #include <utility>
 #include <vector>
 
@@ -62,15 +60,13 @@ typedef vector<pair<uint64_t, int64_t> > SnapsAndCounts;
 // facilitates checking for data integrity.
 class LinkedListTester {
  public:
-  LinkedListTester(const std::tr1::shared_ptr<client::KuduClient>& client,
+  LinkedListTester(const client::sp::shared_ptr<client::KuduClient>& client,
                    const std::string& table_name,
                    int num_chains,
                    int num_tablets,
                    int num_replicas,
                    bool enable_mutation)
-    : verify_projection_(boost::assign::list_of
-                         (kKeyColumnName)(kLinkColumnName)(kUpdatedColumnName)
-                         .convert_to_container<vector<string> >()),
+    : verify_projection_({ kKeyColumnName, kLinkColumnName, kUpdatedColumnName }),
       table_name_(table_name),
       num_chains_(num_chains),
       num_tablets_(num_tablets),
@@ -170,7 +166,7 @@ class LinkedListTester {
   const int num_replicas_;
   const bool enable_mutation_;
   HdrHistogram latency_histogram_;
-  std::tr1::shared_ptr<client::KuduClient> client_;
+  client::sp::shared_ptr<client::KuduClient> client_;
   SnapsAndCounts sampled_timestamps_and_counts_;
 
  private:
@@ -258,7 +254,7 @@ class ScopedRowUpdater {
 
  private:
   void RowUpdaterThread() {
-    std::tr1::shared_ptr<client::KuduSession> session(table_->client()->NewSession());
+    client::sp::shared_ptr<client::KuduSession> session(table_->client()->NewSession());
     session->SetTimeoutMillis(15000);
     CHECK_OK(session->SetFlushMode(client::KuduSession::MANUAL_FLUSH));
 
@@ -441,7 +437,7 @@ Status LinkedListTester::LoadLinkedList(
     int64_t *written_count) {
 
   sampled_timestamps_and_counts_.clear();
-  std::tr1::shared_ptr<client::KuduTable> table;
+  client::sp::shared_ptr<client::KuduTable> table;
   RETURN_NOT_OK_PREPEND(client_->OpenTable(table_name_, &table),
                         "Could not open table " + table_name_);
 
@@ -457,7 +453,7 @@ Status LinkedListTester::LoadLinkedList(
   MonoTime deadline = start;
   deadline.AddDelta(run_for);
 
-  std::tr1::shared_ptr<client::KuduSession> session = client_->NewSession();
+  client::sp::shared_ptr<client::KuduSession> session = client_->NewSession();
   session->SetTimeoutMillis(15000);
   RETURN_NOT_OK_PREPEND(session->SetFlushMode(client::KuduSession::MANUAL_FLUSH),
                         "Couldn't set flush mode");
@@ -570,7 +566,7 @@ Status LinkedListTester::VerifyLinkedListRemote(
     const uint64_t snapshot_timestamp, const int64_t expected, bool log_errors,
     const boost::function<Status(const std::string&)>& cb, int64_t* verified_count) {
 
-  std::tr1::shared_ptr<client::KuduTable> table;
+  client::sp::shared_ptr<client::KuduTable> table;
   RETURN_NOT_OK(client_->OpenTable(table_name_, &table));
 
   string snapshot_str;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/linked_list-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test.cc b/src/kudu/integration-tests/linked_list-test.cc
index bb68d3b..f1dc222 100644
--- a/src/kudu/integration-tests/linked_list-test.cc
+++ b/src/kudu/integration-tests/linked_list-test.cc
@@ -52,8 +52,8 @@
 using kudu::client::KuduClient;
 using kudu::client::KuduClientBuilder;
 using kudu::client::KuduSchema;
+using kudu::client::sp::shared_ptr;
 using kudu::itest::TServerDetails;
-using std::tr1::shared_ptr;
 
 DEFINE_int32(seconds_to_run, 5, "Number of seconds for which to run the test");
 
@@ -140,7 +140,7 @@ class LinkedListTest : public tserver::TabletServerIntegrationTestBase {
     }
   }
 
-  std::tr1::shared_ptr<KuduClient> client_;
+  shared_ptr<KuduClient> client_;
   gscoped_ptr<LinkedListTester> tester_;
 };
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/master_failover-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/master_failover-itest.cc b/src/kudu/integration-tests/master_failover-itest.cc
index ea06992..02d9655 100644
--- a/src/kudu/integration-tests/master_failover-itest.cc
+++ b/src/kudu/integration-tests/master_failover-itest.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>
 #include <string>
@@ -39,15 +38,8 @@ namespace client {
 
 const int kNumTabletServerReplicas = 3;
 
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduTable;
+using sp::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 class MasterFailoverTest : public KuduTest {
@@ -58,7 +50,7 @@ class MasterFailoverTest : public KuduTest {
   };
 
   MasterFailoverTest() {
-    opts_.master_rpc_ports = boost::assign::list_of(11010)(11011)(11012);
+    opts_.master_rpc_ports = { 11010, 11011, 11012 };
     opts_.num_masters = num_masters_ = opts_.master_rpc_ports.size();
     opts_.num_tablet_servers = kNumTabletServerReplicas;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/integration-tests/master_replication-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/master_replication-itest.cc b/src/kudu/integration-tests/master_replication-itest.cc
index b580ee8..f3fb1bc 100644
--- a/src/kudu/integration-tests/master_replication-itest.cc
+++ b/src/kudu/integration-tests/master_replication-itest.cc
@@ -15,11 +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 <vector>
 
 #include "kudu/client/client.h"
@@ -31,7 +29,6 @@
 #include "kudu/master/mini_master.h"
 #include "kudu/util/test_util.h"
 
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace kudu {
@@ -45,6 +42,7 @@ using client::KuduSchema;
 using client::KuduSchemaBuilder;
 using client::KuduTable;
 using client::KuduTableCreator;
+using client::sp::shared_ptr;
 
 const char * const kTableId1 = "testMasterReplication-1";
 const char * const kTableId2 = "testMasterReplication-2";
@@ -57,7 +55,7 @@ class MasterReplicationTest : public KuduTest {
     // Hard-coded ports for the masters. This is safe, as this unit test
     // runs under a resource lock (see CMakeLists.txt in this directory).
     // TODO we should have a generic method to obtain n free ports.
-    opts_.master_rpc_ports = boost::assign::list_of(11010)(11011)(11012);
+    opts_.master_rpc_ports = { 11010, 11011, 11012 };
 
     opts_.num_masters = num_masters_ = opts_.master_rpc_ports.size();
     opts_.num_tablet_servers = kNumTabletServerReplicas;



Mime
View raw message