kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From danburk...@apache.org
Subject [7/9] incubator-kudu git commit: Enable C++11
Date Wed, 13 Jan 2016 17:18:22 GMT
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/generic_iterators.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/generic_iterators.h b/src/kudu/common/generic_iterators.h
index 7338709..dff1b38 100644
--- a/src/kudu/common/generic_iterators.h
+++ b/src/kudu/common/generic_iterators.h
@@ -17,11 +17,11 @@
 #ifndef KUDU_COMMON_MERGE_ITERATOR_H
 #define KUDU_COMMON_MERGE_ITERATOR_H
 
-#include <gtest/gtest_prod.h>
-#include <tr1/memory>
-#include <tr1/unordered_map>
 #include <deque>
+#include <gtest/gtest_prod.h>
+#include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/common/iterator.h"
@@ -41,7 +41,7 @@ class MergeIterator : public RowwiseIterator {
   // key columns. It should probably just be the required projection, which must be
   // a subset of the columns in 'iters'.
   MergeIterator(const Schema &schema,
-                const std::vector<std::tr1::shared_ptr<RowwiseIterator> > &iters);
+                const std::vector<std::shared_ptr<RowwiseIterator> > &iters);
 
   // The passed-in iterators should be already initialized.
   Status Init(ScanSpec *spec) OVERRIDE;
@@ -67,8 +67,8 @@ class MergeIterator : public RowwiseIterator {
 
   // Holds the subiterators until Init is called.
   // This is required because we can't create a MergeIterState of an uninitialized iterator.
-  std::deque<std::tr1::shared_ptr<RowwiseIterator> > orig_iters_;
-  std::vector<std::tr1::shared_ptr<MergeIterState> > iters_;
+  std::deque<std::shared_ptr<RowwiseIterator> > orig_iters_;
+  std::vector<std::shared_ptr<MergeIterState> > iters_;
 
   // When the underlying iterators are initialized, each needs its own
   // copy of the scan spec in order to do its own pushdown calculations, etc.
@@ -91,7 +91,7 @@ class UnionIterator : public RowwiseIterator {
   //
   // All passed-in iterators must be fully able to evaluate all predicates - i.e.
   // calling iter->Init(spec) should remove all predicates from the spec.
-  explicit UnionIterator(const std::vector<std::tr1::shared_ptr<RowwiseIterator> > &iters);
+  explicit UnionIterator(const std::vector<std::shared_ptr<RowwiseIterator> > &iters);
 
   Status Init(ScanSpec *spec) OVERRIDE;
 
@@ -118,11 +118,11 @@ class UnionIterator : public RowwiseIterator {
   // Schema: initialized during Init()
   gscoped_ptr<Schema> schema_;
   bool initted_;
-  std::deque<std::tr1::shared_ptr<RowwiseIterator> > iters_;
+  std::deque<std::shared_ptr<RowwiseIterator> > iters_;
 
   // Since we pop from 'iters_' this field is needed in order to keep
   // the underlying iterators available for GetIteratorStats.
-  std::vector<std::tr1::shared_ptr<RowwiseIterator> > all_iters_;
+  std::vector<std::shared_ptr<RowwiseIterator> > all_iters_;
 
   // When the underlying iterators are initialized, each needs its own
   // copy of the scan spec in order to do its own pushdown calculations, etc.
@@ -139,7 +139,7 @@ class UnionIterator : public RowwiseIterator {
 // an entire batch, then other columns may avoid doing any IO.
 class MaterializingIterator : public RowwiseIterator {
  public:
-  explicit MaterializingIterator(const std::tr1::shared_ptr<ColumnwiseIterator> &iter);
+  explicit MaterializingIterator(const std::shared_ptr<ColumnwiseIterator> &iter);
 
   // Initialize the iterator, performing predicate pushdown as described above.
   Status Init(ScanSpec *spec) OVERRIDE;
@@ -164,9 +164,9 @@ class MaterializingIterator : public RowwiseIterator {
 
   Status MaterializeBlock(RowBlock *dst);
 
-  std::tr1::shared_ptr<ColumnwiseIterator> iter_;
+  std::shared_ptr<ColumnwiseIterator> iter_;
 
-  std::tr1::unordered_multimap<size_t, ColumnRangePredicate> preds_by_column_;
+  std::unordered_multimap<size_t, ColumnRangePredicate> preds_by_column_;
 
   // The order in which the columns will be materialized.
   std::vector<size_t> materialization_order_;
@@ -188,7 +188,7 @@ class PredicateEvaluatingIterator : public RowwiseIterator {
   //
   // POSTCONDITION: spec->predicates().empty()
   // POSTCONDITION: base_iter and its wrapper are initialized
-  static Status InitAndMaybeWrap(std::tr1::shared_ptr<RowwiseIterator> *base_iter,
+  static Status InitAndMaybeWrap(std::shared_ptr<RowwiseIterator> *base_iter,
                                  ScanSpec *spec);
 
   // Initialize the iterator.
@@ -213,12 +213,12 @@ class PredicateEvaluatingIterator : public RowwiseIterator {
   // Construct the evaluating iterator.
   // This is only called from ::InitAndMaybeWrap()
   // REQUIRES: base_iter is already Init()ed.
-  explicit PredicateEvaluatingIterator(const std::tr1::shared_ptr<RowwiseIterator> &base_iter);
+  explicit PredicateEvaluatingIterator(const std::shared_ptr<RowwiseIterator> &base_iter);
 
 
   FRIEND_TEST(TestPredicateEvaluatingIterator, TestPredicateEvaluation);
 
-  std::tr1::shared_ptr<RowwiseIterator> base_iter_;
+  std::shared_ptr<RowwiseIterator> base_iter_;
   std::vector<ColumnRangePredicate> predicates_;
 };
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/key_encoder.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/key_encoder.cc b/src/kudu/common/key_encoder.cc
index c4e2e8b..3d4e4e8 100644
--- a/src/kudu/common/key_encoder.cc
+++ b/src/kudu/common/key_encoder.cc
@@ -16,9 +16,9 @@
 // under the License.
 
 #include <boost/noncopyable.hpp>
+#include <functional>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/common/common.pb.h"
@@ -27,8 +27,8 @@
 #include "kudu/gutil/singleton.h"
 #include "kudu/util/faststring.h"
 
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::shared_ptr;
+using std::unordered_map;
 
 namespace kudu {
 
@@ -64,7 +64,7 @@ class EncoderResolver {
   }
 
   friend class Singleton<EncoderResolver<Buffer> >;
-  unordered_map<DataType, shared_ptr<KeyEncoder<Buffer> >, std::tr1::hash<size_t> > encoders_;
+  unordered_map<DataType, shared_ptr<KeyEncoder<Buffer> >, std::hash<size_t> > encoders_;
 };
 
 template <typename Buffer>

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/partial_row-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/partial_row-test.cc b/src/kudu/common/partial_row-test.cc
index 8f59139..9661140 100644
--- a/src/kudu/common/partial_row-test.cc
+++ b/src/kudu/common/partial_row-test.cc
@@ -16,7 +16,6 @@
 // under the License.
 
 #include <gtest/gtest.h>
-#include <boost/assign/list_of.hpp>
 
 #include "kudu/common/partial_row.h"
 #include "kudu/common/row.h"
@@ -28,11 +27,10 @@ namespace kudu {
 class PartialRowTest : public KuduTest {
  public:
   PartialRowTest()
-    : schema_(boost::assign::list_of
-              (ColumnSchema("key", INT32))
-              (ColumnSchema("int_val", INT32))
-              (ColumnSchema("string_val", STRING, true))
-              (ColumnSchema("binary_val", BINARY, true)),
+    : schema_({ ColumnSchema("key", INT32),
+                ColumnSchema("int_val", INT32),
+                ColumnSchema("string_val", STRING, true),
+                ColumnSchema("binary_val", BINARY, true) },
               1) {
     SeedRandom();
   }

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/partition-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/partition-test.cc b/src/kudu/common/partition-test.cc
index 7a51970..bf24a4a 100644
--- a/src/kudu/common/partition-test.cc
+++ b/src/kudu/common/partition-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <iterator>
 #include <stdint.h>
 #include <vector>
@@ -32,8 +31,6 @@
 using std::vector;
 using std::string;
 
-using boost::assign::list_of;
-
 namespace kudu {
 
 namespace {
@@ -62,14 +59,14 @@ void SetRangePartitionComponent(PartitionSchemaPB* partition_schema_pb,
 TEST(PartitionTest, TestPartitionKeyEncoding) {
   // CREATE TABLE t (a INT32, b VARCHAR, c VARCHAR, PRIMARY KEY (a, b, c))
   // PARITITION BY [HASH BUCKET (a, b), HASH BUCKET (c), RANGE (a, b, c)];
-  Schema schema(list_of(ColumnSchema("a", INT32))
-                       (ColumnSchema("b", STRING))
-                       (ColumnSchema("c", STRING)),
-                list_of(0)(1)(2), 3);
+  Schema schema({ ColumnSchema("a", INT32),
+                  ColumnSchema("b", STRING),
+                  ColumnSchema("c", STRING) },
+                { ColumnId(0), ColumnId(1), ColumnId(2) }, 3);
 
   PartitionSchemaPB schema_builder;
-  AddHashBucketComponent(&schema_builder, list_of("a")("b"), 32, 0);
-  AddHashBucketComponent(&schema_builder, list_of("c"), 32, 42);
+  AddHashBucketComponent(&schema_builder, { "a", "b" }, 32, 0);
+  AddHashBucketComponent(&schema_builder, { "c" }, 32, 42);
   PartitionSchema partition_schema;
   ASSERT_OK(PartitionSchema::FromPB(schema_builder, schema, &partition_schema));
 
@@ -154,7 +151,7 @@ TEST(PartitionTest, TestPartitionKeyEncoding) {
 TEST(PartitionTest, TestCreateRangePartitions) {
   // CREATE TABLE t (a VARCHAR PRIMARY KEY),
   // PARITITION BY [RANGE (a)];
-  Schema schema(list_of(ColumnSchema("a", STRING)), list_of(0), 1);
+  Schema schema({ ColumnSchema("a", STRING) }, { ColumnId(0) }, 1);
 
   PartitionSchema partition_schema;
   ASSERT_OK(PartitionSchema::FromPB(PartitionSchemaPB(), schema, &partition_schema));
@@ -183,7 +180,7 @@ TEST(PartitionTest, TestCreateRangePartitions) {
   ASSERT_OK(partition_schema.EncodeKey(split2, &pk2));
 
   // Split keys need not be passed in sorted order.
-  vector<KuduPartialRow> split_rows = list_of(split2)(split1);
+  vector<KuduPartialRow> split_rows = { split2, split1 };
   vector<Partition> partitions;
   ASSERT_OK(partition_schema.CreatePartitions(split_rows, schema, &partitions));
   ASSERT_EQ(3, partitions.size());
@@ -216,11 +213,11 @@ TEST(PartitionTest, TestCreateRangePartitions) {
 TEST(PartitionTest, TestCreateHashBucketPartitions) {
   // CREATE TABLE t (a VARCHAR PRIMARY KEY),
   // PARITITION BY [HASH BUCKET (a)];
-  Schema schema(list_of(ColumnSchema("a", STRING)), list_of(0), 1);
+  Schema schema({ ColumnSchema("a", STRING) }, { ColumnId(0) }, 1);
 
   PartitionSchemaPB schema_builder;
   SetRangePartitionComponent(&schema_builder, vector<string>());
-  AddHashBucketComponent(&schema_builder, list_of("a"), 3, 42);
+  AddHashBucketComponent(&schema_builder, { "a" }, 3, 42);
   PartitionSchema partition_schema;
   ASSERT_OK(PartitionSchema::FromPB(schema_builder, schema, &partition_schema));
 
@@ -265,14 +262,14 @@ TEST(PartitionTest, TestCreateHashBucketPartitions) {
 TEST(PartitionTest, TestCreatePartitions) {
   // CREATE TABLE t (a VARCHAR, b VARCHAR, c VARCHAR, PRIMARY KEY (a, b, c))
   // PARITITION BY [HASH BUCKET (a), HASH BUCKET (b), RANGE (a, b, c)];
-  Schema schema(list_of(ColumnSchema("a", STRING))
-                       (ColumnSchema("b", STRING))
-                       (ColumnSchema("c", STRING)),
-                list_of(0)(1)(2), 3);
+  Schema schema({ ColumnSchema("a", STRING),
+                  ColumnSchema("b", STRING),
+                  ColumnSchema("c", STRING) },
+                { ColumnId(0), ColumnId(1), ColumnId(2) }, 3);
 
   PartitionSchemaPB schema_builder;
-  AddHashBucketComponent(&schema_builder, list_of("a"), 2, 0);
-  AddHashBucketComponent(&schema_builder, list_of("b"), 2, 0);
+  AddHashBucketComponent(&schema_builder, { "a" }, 2, 0);
+  AddHashBucketComponent(&schema_builder, { "b" }, 2, 0);
   PartitionSchema partition_schema;
   ASSERT_OK(PartitionSchema::FromPB(schema_builder, schema, &partition_schema));
 
@@ -321,7 +318,7 @@ TEST(PartitionTest, TestCreatePartitions) {
   ASSERT_OK(partition_schema.EncodeKey(split_b, &partition_key_b));
 
   // Split keys need not be passed in sorted order.
-  vector<KuduPartialRow> split_rows = list_of(split_b)(split_a);
+  vector<KuduPartialRow> split_rows = { split_b, split_a };
   vector<Partition> partitions;
   ASSERT_OK(partition_schema.CreatePartitions(split_rows, schema, &partitions));
   ASSERT_EQ(12, partitions.size());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/predicate-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/predicate-test.cc b/src/kudu/common/predicate-test.cc
index 2dad430..a9cc376 100644
--- a/src/kudu/common/predicate-test.cc
+++ b/src/kudu/common/predicate-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <gtest/gtest.h>
 
 #include "kudu/common/scan_predicate.h"
@@ -29,10 +28,9 @@ class TestPredicate : public KuduTest {
   TestPredicate() :
     arena_(1024, 4096),
     n_rows_(100),
-    schema_(boost::assign::list_of
-            (ColumnSchema("col0", UINT32))
-            (ColumnSchema("col1", UINT32))
-            (ColumnSchema("col2", STRING)),
+    schema_({ ColumnSchema("col0", UINT32),
+              ColumnSchema("col1", UINT32),
+              ColumnSchema("col2", STRING) },
             1),
     row_block_(schema_, n_rows_, &arena_)
   {}

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/predicate_encoder-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/predicate_encoder-test.cc b/src/kudu/common/predicate_encoder-test.cc
index 583f681..2b5f899 100644
--- a/src/kudu/common/predicate_encoder-test.cc
+++ b/src/kudu/common/predicate_encoder-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>
 #include <vector>
@@ -78,10 +77,9 @@ class CompositeIntKeysTest : public TestRangePredicateEncoder {
  public:
   CompositeIntKeysTest() :
     TestRangePredicateEncoder(
-        Schema(boost::assign::list_of
-               (ColumnSchema("a", UINT8))
-               (ColumnSchema("b", UINT8))
-               (ColumnSchema("c", UINT8)),
+        Schema({ ColumnSchema("a", UINT8),
+                 ColumnSchema("b", UINT8),
+                 ColumnSchema("c", UINT8) },
                3)) {
   }
 };
@@ -236,10 +234,9 @@ class CompositeIntStringKeysTest : public TestRangePredicateEncoder {
  public:
   CompositeIntStringKeysTest() :
     TestRangePredicateEncoder(
-        Schema(boost::assign::list_of
-               (ColumnSchema("a", UINT8))
-               (ColumnSchema("b", STRING))
-               (ColumnSchema("c", STRING)),
+        Schema({ ColumnSchema("a", UINT8),
+                 ColumnSchema("b", STRING),
+                 ColumnSchema("c", STRING) },
                3)) {
   }
 };
@@ -275,9 +272,7 @@ class SingleIntKeyTest : public TestRangePredicateEncoder {
  public:
   SingleIntKeyTest() :
     TestRangePredicateEncoder(
-        Schema(boost::assign::list_of
-               (ColumnSchema("a", UINT8)),
-                1)) {
+        Schema({ ColumnSchema("a", UINT8) }, 1)) {
     }
 };
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/row.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/row.h b/src/kudu/common/row.h
index ccd180f..a501274 100644
--- a/src/kudu/common/row.h
+++ b/src/kudu/common/row.h
@@ -361,11 +361,11 @@ class DeltaProjector {
  private:
   DISALLOW_COPY_AND_ASSIGN(DeltaProjector);
 
-  std::tr1::unordered_map<size_t, size_t> base_cols_mapping_;     // [proj_idx] = base_idx
-  std::tr1::unordered_map<size_t, size_t> rbase_cols_mapping_;    // [id] = proj_idx
+  std::unordered_map<size_t, size_t> base_cols_mapping_;     // [proj_idx] = base_idx
+  std::unordered_map<size_t, size_t> rbase_cols_mapping_;    // [id] = proj_idx
 
-  std::tr1::unordered_map<size_t, size_t> adapter_cols_mapping_;  // [proj_idx] = base_idx
-  std::tr1::unordered_map<size_t, size_t> radapter_cols_mapping_; // [id] = proj_idx
+  std::unordered_map<size_t, size_t> adapter_cols_mapping_;  // [proj_idx] = base_idx
+  std::unordered_map<size_t, size_t> radapter_cols_mapping_; // [id] = proj_idx
 
   const Schema* delta_schema_;
   const Schema* projection_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/row_changelist-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/row_changelist-test.cc b/src/kudu/common/row_changelist-test.cc
index 61c5665..457f7bf 100644
--- a/src/kudu/common/row_changelist-test.cc
+++ b/src/kudu/common/row_changelist-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>
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/row_key-util-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/row_key-util-test.cc b/src/kudu/common/row_key-util-test.cc
index ae1c06e..661dde4 100644
--- a/src/kudu/common/row_key-util-test.cc
+++ b/src/kudu/common/row_key-util-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <gtest/gtest.h>
 
 #include "kudu/common/partial_row.h"
@@ -41,10 +40,9 @@ class RowKeyUtilTest : public KuduTest {
 };
 
 TEST_F(RowKeyUtilTest, TestIncrementNonCompositeKey) {
-  Schema schema(boost::assign::list_of
-                (ColumnSchema("key", INT32))
-                (ColumnSchema("other_col", INT32))
-                (ColumnSchema("other_col2", STRING, true)),
+  Schema schema({ ColumnSchema("key", INT32),
+                  ColumnSchema("other_col", INT32),
+                  ColumnSchema("other_col2", STRING, true) },
                 1);
   KuduPartialRow p_row(&schema);
   ContiguousRow row(&schema, row_data(&p_row));
@@ -61,11 +59,10 @@ TEST_F(RowKeyUtilTest, TestIncrementNonCompositeKey) {
 }
 
 TEST_F(RowKeyUtilTest, TestIncrementCompositeKey) {
-  Schema schema(boost::assign::list_of
-                   (ColumnSchema("k1", INT32))
-                   (ColumnSchema("k2", INT32))
-                   (ColumnSchema("other_col", STRING, true)),
-                   2);
+  Schema schema({ ColumnSchema("k1", INT32),
+                  ColumnSchema("k2", INT32),
+                  ColumnSchema("other_col", STRING, true) },
+                2);
 
   KuduPartialRow p_row(&schema);
   ContiguousRow row(&schema, row_data(&p_row));
@@ -90,11 +87,10 @@ TEST_F(RowKeyUtilTest, TestIncrementCompositeKey) {
 }
 
 TEST_F(RowKeyUtilTest, TestIncrementCompositeIntStringKey) {
-  Schema schema(boost::assign::list_of
-                   (ColumnSchema("k1", INT32))
-                   (ColumnSchema("k2", STRING))
-                   (ColumnSchema("other_col", STRING, true)),
-                   2);
+  Schema schema({ ColumnSchema("k1", INT32),
+                  ColumnSchema("k2", STRING),
+                  ColumnSchema("other_col", STRING, true) },
+                2);
 
   KuduPartialRow p_row(&schema);
   ContiguousRow row(&schema, row_data(&p_row));
@@ -112,11 +108,10 @@ TEST_F(RowKeyUtilTest, TestIncrementCompositeIntStringKey) {
 }
 
 TEST_F(RowKeyUtilTest, TestIncrementCompositeStringIntKey) {
-  Schema schema(boost::assign::list_of
-                   (ColumnSchema("k1", STRING))
-                   (ColumnSchema("k2", INT32))
-                   (ColumnSchema("other_col", STRING, true)),
-                   2);
+  Schema schema({ ColumnSchema("k1", STRING),
+                  ColumnSchema("k2", INT32),
+                  ColumnSchema("other_col", STRING, true) },
+                2);
 
   KuduPartialRow p_row(&schema);
   ContiguousRow row(&schema, row_data(&p_row));

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/row_operations-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/row_operations-test.cc b/src/kudu/common/row_operations-test.cc
index 7eba133..eac8ed4 100644
--- a/src/kudu/common/row_operations-test.cc
+++ b/src/kudu/common/row_operations-test.cc
@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/common/partial_row.h"
 #include "kudu/common/row_operations.h"
@@ -26,7 +25,7 @@
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/test_util.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 using strings::SubstituteAndAppend;
 
@@ -333,10 +332,9 @@ string TestProjection(RowOperationsPB::Type type,
 // Test decoding partial rows from a client who has a schema which matches
 // the table schema.
 TEST_F(RowOperationsTest, ProjectionTestWholeSchemaSpecified) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        1);
 
   // Test a row missing 'int_val', which is required.
@@ -390,12 +388,10 @@ TEST_F(RowOperationsTest, ProjectionTestWithDefaults) {
 
   // Clients may not have the defaults specified.
   // TODO: evaluate whether this should be true - how "dumb" should clients be?
-  Schema client_schema(
-    boost::assign::list_of
-    (ColumnSchema("key", INT32))
-    (ColumnSchema("nullable_with_default", INT32, true))
-    (ColumnSchema("non_null_with_default", INT32, false)),
-    1);
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("nullable_with_default", INT32, true),
+                         ColumnSchema("non_null_with_default", INT32, false) },
+                       1);
 
   // Specify just the key. The other two columns have defaults, so they'll get filled in.
   {
@@ -443,9 +439,8 @@ TEST_F(RowOperationsTest, ProjectionTestWithClientHavingValidSubset) {
   CHECK_OK(b.AddNullableColumn("new_nullable_int", INT32));
   Schema server_schema = b.Build();
 
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32) },
                        1);
 
   // Specify just the key. This is an error because we're missing int_val.
@@ -491,10 +486,9 @@ TEST_F(RowOperationsTest, ProjectionTestWithClientHavingInvalidSubset) {
 
 // Simple Update case where the client and server schemas match.
 TEST_F(RowOperationsTest, TestProjectUpdates) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        1);
   Schema server_schema = SchemaBuilder(client_schema).Build();
 
@@ -528,15 +522,13 @@ TEST_F(RowOperationsTest, TestProjectUpdates) {
 // Client schema has the columns in a different order. Makes
 // sure the name-based projection is functioning.
 TEST_F(RowOperationsTest, TestProjectUpdatesReorderedColumns) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("string_val", STRING, true))
-                       (ColumnSchema("int_val", INT32)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("string_val", STRING, true),
+                         ColumnSchema("int_val", INT32) },
                        1);
-  Schema server_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema server_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        1);
   server_schema = SchemaBuilder(server_schema).Build();
 
@@ -550,14 +542,12 @@ TEST_F(RowOperationsTest, TestProjectUpdatesReorderedColumns) {
 // Client schema is missing one of the columns in the server schema.
 // This is OK on an update.
 TEST_F(RowOperationsTest, DISABLED_TestProjectUpdatesSubsetOfColumns) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        1);
-  Schema server_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema server_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        1);
   server_schema = SchemaBuilder(server_schema).Build();
 
@@ -569,13 +559,11 @@ TEST_F(RowOperationsTest, DISABLED_TestProjectUpdatesSubsetOfColumns) {
 }
 
 TEST_F(RowOperationsTest, TestClientMismatchedType) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT8)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT8) },
                        1);
-  Schema server_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("int_val", INT32)),
+  Schema server_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("int_val", INT32) },
                        1);
   server_schema = SchemaBuilder(server_schema).Build();
 
@@ -588,10 +576,9 @@ TEST_F(RowOperationsTest, TestClientMismatchedType) {
 }
 
 TEST_F(RowOperationsTest, TestProjectDeletes) {
-  Schema client_schema(boost::assign::list_of
-                       (ColumnSchema("key", INT32))
-                       (ColumnSchema("key_2", INT32))
-                       (ColumnSchema("string_val", STRING, true)),
+  Schema client_schema({ ColumnSchema("key", INT32),
+                         ColumnSchema("key_2", INT32),
+                         ColumnSchema("string_val", STRING, true) },
                        2);
   Schema server_schema = SchemaBuilder(client_schema).Build();
 
@@ -618,14 +605,14 @@ TEST_F(RowOperationsTest, TestProjectDeletes) {
 }
 
 TEST_F(RowOperationsTest, SplitKeyRoundTrip) {
-  Schema client_schema = Schema(boost::assign::list_of(ColumnSchema("int8", INT8))
-                                                      (ColumnSchema("int16", INT16))
-                                                      (ColumnSchema("int32", INT32))
-                                                      (ColumnSchema("int64", INT64))
-                                                      (ColumnSchema("string", STRING))
-                                                      (ColumnSchema("binary", BINARY))
-                                                      (ColumnSchema("timestamp", TIMESTAMP))
-                                                      (ColumnSchema("missing", STRING)),
+  Schema client_schema = Schema({ ColumnSchema("int8", INT8),
+                                  ColumnSchema("int16", INT16),
+                                  ColumnSchema("int32", INT32),
+                                  ColumnSchema("int64", INT64),
+                                  ColumnSchema("string", STRING),
+                                  ColumnSchema("binary", BINARY),
+                                  ColumnSchema("timestamp", TIMESTAMP),
+                                  ColumnSchema("missing", STRING) },
                                 8);
 
   // Use values at the upper end of the range.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/row_operations.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/row_operations.h b/src/kudu/common/row_operations.h
index 0e0c741..e7ee722 100644
--- a/src/kudu/common/row_operations.h
+++ b/src/kudu/common/row_operations.h
@@ -17,8 +17,8 @@
 #ifndef KUDU_COMMON_ROW_OPERATIONS_H
 #define KUDU_COMMON_ROW_OPERATIONS_H
 
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/common/row_changelist.h"
@@ -59,7 +59,7 @@ struct DecodedRowOperation {
   RowChangeList changelist;
 
   // For SPLIT_ROW, the partial row to split on.
-  std::tr1::shared_ptr<KuduPartialRow> split_row;
+  std::shared_ptr<KuduPartialRow> split_row;
 
   std::string ToString(const Schema& schema) const;
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/schema-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema-test.cc b/src/kudu/common/schema-test.cc
index 7781f13..cb63ffa 100644
--- a/src/kudu/common/schema-test.cc
+++ b/src/kudu/common/schema-test.cc
@@ -15,15 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
+#include "kudu/common/schema.h"
+
 #include <glog/logging.h>
 #include <gtest/gtest.h>
+#include <unordered_map>
 #include <vector>
-#include <tr1/unordered_map>
 
-#include "kudu/common/row.h"
-#include "kudu/common/schema.h"
 #include "kudu/common/key_encoder.h"
+#include "kudu/common/row.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/util/hexdump.h"
 #include "kudu/util/stopwatch.h"
@@ -32,9 +32,8 @@
 namespace kudu {
 namespace tablet {
 
-using boost::assign::list_of;
+using std::unordered_map;
 using std::vector;
-using std::tr1::unordered_map;
 using strings::Substitute;
 
 // Copy a row and its referenced data into the given Arena.
@@ -65,8 +64,7 @@ TEST(TestSchema, TestSchema) {
   ColumnSchema col2("uint32val", UINT32, true);
   ColumnSchema col3("int32val", INT32);
 
-  vector<ColumnSchema> cols = boost::assign::list_of
-    (col1)(col2)(col3);
+  vector<ColumnSchema> cols = { col1, col2, col3 };
   Schema schema(cols, 1);
 
   ASSERT_EQ(sizeof(Slice) + sizeof(uint32_t) + sizeof(int32_t),
@@ -88,14 +86,12 @@ TEST(TestSchema, TestSchema) {
 }
 
 TEST(TestSchema, TestSwap) {
-  Schema schema1(boost::assign::list_of
-                 (ColumnSchema("col1", STRING))
-                 (ColumnSchema("col2", STRING))
-                 (ColumnSchema("col3", UINT32)),
+  Schema schema1({ ColumnSchema("col1", STRING),
+                   ColumnSchema("col2", STRING),
+                   ColumnSchema("col3", UINT32) },
                  2);
-  Schema schema2(boost::assign::list_of
-                 (ColumnSchema("col3", UINT32))
-                 (ColumnSchema("col2", STRING)),
+  Schema schema2({ ColumnSchema("col3", UINT32),
+                   ColumnSchema("col2", STRING) },
                  1);
   schema1.swap(schema2);
   ASSERT_EQ(2, schema1.num_columns());
@@ -108,10 +104,9 @@ TEST(TestSchema, TestReset) {
   Schema schema;
   ASSERT_FALSE(schema.initialized());
 
-  ASSERT_OK(schema.Reset(boost::assign::list_of
-                                (ColumnSchema("col3", UINT32))
-                                (ColumnSchema("col2", STRING)),
-                                1));
+  ASSERT_OK(schema.Reset({ ColumnSchema("col3", UINT32),
+                           ColumnSchema("col2", STRING) },
+                         1));
   ASSERT_TRUE(schema.initialized());
 
   // Swap the initialized schema with an uninitialized one.
@@ -136,15 +131,13 @@ TEST(TestSchema, TestEmptyVariant) {
 }
 
 TEST(TestSchema, TestProjectSubset) {
-  Schema schema1(boost::assign::list_of
-                 (ColumnSchema("col1", STRING))
-                 (ColumnSchema("col2", STRING))
-                 (ColumnSchema("col3", UINT32)),
+  Schema schema1({ ColumnSchema("col1", STRING),
+                   ColumnSchema("col2", STRING),
+                   ColumnSchema("col3", UINT32) },
                  1);
 
-  Schema schema2(boost::assign::list_of
-                 (ColumnSchema("col3", UINT32))
-                 (ColumnSchema("col2", STRING)),
+  Schema schema2({ ColumnSchema("col3", UINT32),
+                   ColumnSchema("col2", STRING) },
                  0);
 
   RowProjector row_projector(&schema1, &schema2);
@@ -165,13 +158,10 @@ TEST(TestSchema, TestProjectSubset) {
 // Test projection when the type of the projected column
 // doesn't match the original type.
 TEST(TestSchema, TestProjectTypeMismatch) {
-  Schema schema1(boost::assign::list_of
-                 (ColumnSchema("key", STRING))
-                 (ColumnSchema("val", UINT32)),
+  Schema schema1({ ColumnSchema("key", STRING),
+                   ColumnSchema("val", UINT32) },
                  1);
-  Schema schema2(boost::assign::list_of
-                 (ColumnSchema("val", STRING)),
-                 0);
+  Schema schema2({ ColumnSchema("val", STRING) }, 0);
 
   RowProjector row_projector(&schema1, &schema2);
   Status s = row_projector.Init();
@@ -182,22 +172,12 @@ TEST(TestSchema, TestProjectTypeMismatch) {
 // Test projection when the some columns in the projection
 // are not present in the base schema
 TEST(TestSchema, TestProjectMissingColumn) {
-  Schema schema1(boost::assign::list_of
-                 (ColumnSchema("key", STRING))
-                 (ColumnSchema("val", UINT32)),
-                 1);
-  Schema schema2(boost::assign::list_of
-                 (ColumnSchema("val", UINT32))
-                 (ColumnSchema("non_present", STRING)),
-                 0);
-  Schema schema3(boost::assign::list_of
-                 (ColumnSchema("val", UINT32))
-                 (ColumnSchema("non_present", UINT32, true)),
-                 0);
+  Schema schema1({ ColumnSchema("key", STRING), ColumnSchema("val", UINT32) }, 1);
+  Schema schema2({ ColumnSchema("val", UINT32), ColumnSchema("non_present", STRING) }, 0);
+  Schema schema3({ ColumnSchema("val", UINT32), ColumnSchema("non_present", UINT32, true) }, 0);
   uint32_t default_value = 15;
-  Schema schema4(boost::assign::list_of
-                 (ColumnSchema("val", UINT32))
-                 (ColumnSchema("non_present", UINT32, false, &default_value)),
+  Schema schema4({ ColumnSchema("val", UINT32),
+                   ColumnSchema("non_present", UINT32, false, &default_value) },
                  0);
 
   RowProjector row_projector(&schema1, &schema2);
@@ -262,12 +242,11 @@ TEST(TestSchema, TestProjectRename) {
 
 // Test that the schema can be used to compare and stringify rows.
 TEST(TestSchema, TestRowOperations) {
-  Schema schema(boost::assign::list_of
-                 (ColumnSchema("col1", STRING))
-                 (ColumnSchema("col2", STRING))
-                 (ColumnSchema("col3", UINT32))
-                 (ColumnSchema("col4", INT32)),
-                 1);
+  Schema schema({ ColumnSchema("col1", STRING),
+                  ColumnSchema("col2", STRING),
+                  ColumnSchema("col3", UINT32),
+                  ColumnSchema("col4", INT32) },
+                1);
 
   Arena arena(1024, 256*1024);
 
@@ -298,27 +277,25 @@ TEST(TestKeyEncoder, TestKeyEncoder) {
   faststring fs;
   const KeyEncoder<faststring>& encoder = GetKeyEncoder<faststring>(GetTypeInfo(STRING));
 
-  typedef boost::tuple<vector<Slice>, Slice> test_pair;
-  using boost::assign::list_of;
+  typedef std::tuple<vector<Slice>, Slice> test_pair;
 
   vector<test_pair> pairs;
 
   // Simple key
-  pairs.push_back(test_pair(list_of(Slice("foo", 3)),
-                            Slice("foo", 3)));
+  pairs.push_back(test_pair({ Slice("foo", 3) }, Slice("foo", 3)));
 
   // Simple compound key
-  pairs.push_back(test_pair(list_of(Slice("foo", 3))(Slice("bar", 3)),
+  pairs.push_back(test_pair({ Slice("foo", 3), Slice("bar", 3) },
                             Slice("foo" "\x00\x00" "bar", 8)));
 
   // Compound key with a \x00 in it
-  pairs.push_back(test_pair(list_of(Slice("xxx\x00yyy", 7))(Slice("bar", 3)),
+  pairs.push_back(test_pair({ Slice("xxx\x00yyy", 7), Slice("bar", 3) },
                             Slice("xxx" "\x00\x01" "yyy" "\x00\x00" "bar", 13)));
 
   int i = 0;
   BOOST_FOREACH(const test_pair &t, pairs) {
-    const vector<Slice> &in = boost::get<0>(t);
-    Slice expected = boost::get<1>(t);
+    const vector<Slice> &in = std::get<0>(t);
+    Slice expected = std::get<1>(t);
 
     fs.clear();
     for (int col = 0; col < in.size(); col++) {
@@ -334,10 +311,9 @@ TEST(TestKeyEncoder, TestKeyEncoder) {
 }
 
 TEST(TestSchema, TestDecodeKeys_CompoundStringKey) {
-  Schema schema(boost::assign::list_of
-                (ColumnSchema("col1", STRING))
-                (ColumnSchema("col2", STRING))
-                (ColumnSchema("col3", STRING)),
+  Schema schema({ ColumnSchema("col1", STRING),
+                  ColumnSchema("col2", STRING),
+                  ColumnSchema("col3", STRING) },
                 2);
 
   EXPECT_EQ("(string col1=foo, string col2=bar)",
@@ -356,10 +332,9 @@ TEST(TestSchema, TestDecodeKeys_CompoundStringKey) {
 // Test that appropriate statuses are returned when trying to decode an invalid
 // encoded key.
 TEST(TestSchema, TestDecodeKeys_InvalidKeys) {
-  Schema schema(boost::assign::list_of
-                (ColumnSchema("col1", STRING))
-                (ColumnSchema("col2", UINT32))
-                (ColumnSchema("col3", STRING)),
+  Schema schema({ ColumnSchema("col1", STRING),
+                  ColumnSchema("col2", UINT32),
+                  ColumnSchema("col3", STRING) },
                 2);
 
   EXPECT_EQ("<invalid key: Invalid argument: Error decoding composite key component"
@@ -374,18 +349,17 @@ TEST(TestSchema, TestDecodeKeys_InvalidKeys) {
 }
 
 TEST(TestSchema, TestCreateProjection) {
-  Schema schema(boost::assign::list_of
-                (ColumnSchema("col1", STRING))
-                (ColumnSchema("col2", STRING))
-                (ColumnSchema("col3", STRING))
-                (ColumnSchema("col4", STRING))
-                (ColumnSchema("col5", STRING)),
+  Schema schema({ ColumnSchema("col1", STRING),
+                  ColumnSchema("col2", STRING),
+                  ColumnSchema("col3", STRING),
+                  ColumnSchema("col4", STRING),
+                  ColumnSchema("col5", STRING) },
                 2);
   Schema schema_with_ids = SchemaBuilder(schema).Build();
   Schema partial_schema;
 
   // By names, without IDs
-  ASSERT_OK(schema.CreateProjectionByNames(list_of("col1")("col2")("col4"), &partial_schema));
+  ASSERT_OK(schema.CreateProjectionByNames({ "col1", "col2", "col4" }, &partial_schema));
   EXPECT_EQ("Schema [\n"
             "\tcol1[string NOT NULL],\n"
             "\tcol2[string NOT NULL],\n"
@@ -394,8 +368,7 @@ TEST(TestSchema, TestCreateProjection) {
             partial_schema.ToString());
 
   // By names, with IDS
-  ASSERT_OK(schema_with_ids.CreateProjectionByNames(
-                list_of("col1")("col2")("col4"), &partial_schema));
+  ASSERT_OK(schema_with_ids.CreateProjectionByNames({ "col1", "col2", "col4" }, &partial_schema));
   EXPECT_EQ(Substitute("Schema [\n"
                        "\t$0:col1[string NOT NULL],\n"
                        "\t$1:col2[string NOT NULL],\n"
@@ -407,17 +380,15 @@ TEST(TestSchema, TestCreateProjection) {
             partial_schema.ToString());
 
   // By names, with missing names.
-  Status s = schema.CreateProjectionByNames(list_of("foobar"), &partial_schema);
+  Status s = schema.CreateProjectionByNames({ "foobar" }, &partial_schema);
   EXPECT_EQ("Not found: column not found: foobar", s.ToString());
 
   // By IDs
-  ASSERT_OK(schema_with_ids.CreateProjectionByIdsIgnoreMissing(
-                list_of
-                (schema_with_ids.column_id(0))
-                (schema_with_ids.column_id(1))
-                (ColumnId(1000)) // missing column
-                (schema_with_ids.column_id(3)),
-                &partial_schema));
+  ASSERT_OK(schema_with_ids.CreateProjectionByIdsIgnoreMissing({ schema_with_ids.column_id(0),
+                                                                 schema_with_ids.column_id(1),
+                                                                 ColumnId(1000), // missing column
+                                                                 schema_with_ids.column_id(3) },
+                                                               &partial_schema));
   EXPECT_EQ(Substitute("Schema [\n"
                        "\t$0:col1[string NOT NULL],\n"
                        "\t$1:col2[string NOT NULL],\n"
@@ -432,8 +403,7 @@ TEST(TestSchema, TestCreateProjection) {
 #ifdef NDEBUG
 TEST(TestKeyEncoder, BenchmarkSimpleKey) {
   faststring fs;
-  Schema schema(boost::assign::list_of
-                (ColumnSchema("col1", STRING)), 1);
+  Schema schema({ ColumnSchema("col1", STRING) }, 1);
 
   RowBuilder rb(schema);
   rb.AddString(Slice("hello world"));

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/schema.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema.cc b/src/kudu/common/schema.cc
index 7e33f8d..5364172 100644
--- a/src/kudu/common/schema.cc
+++ b/src/kudu/common/schema.cc
@@ -30,8 +30,8 @@
 namespace kudu {
 
 using std::set;
-using std::tr1::unordered_set;
-using std::tr1::unordered_map;
+using std::unordered_map;
+using std::unordered_set;
 
 // In a new schema, we typically would start assigning column IDs at 0. However, this
 // makes it likely that in many test cases, the column IDs and the column indexes are

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/schema.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/schema.h b/src/kudu/common/schema.h
index 4470208..ab45ef3 100644
--- a/src/kudu/common/schema.h
+++ b/src/kudu/common/schema.h
@@ -20,10 +20,10 @@
 #include <boost/foreach.hpp>
 #include <functional>
 #include <glog/logging.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
-#include <tr1/unordered_set>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -52,8 +52,8 @@
 namespace kudu {
 
 using std::vector;
-using std::tr1::unordered_map;
-using std::tr1::unordered_set;
+using std::unordered_map;
+using std::unordered_set;
 
 // The ID of a column. Each column in a table has a unique ID.
 struct ColumnId {
@@ -280,8 +280,8 @@ class ColumnSchema {
   const TypeInfo *type_info_;
   bool is_nullable_;
   // use shared_ptr since the ColumnSchema is always copied around.
-  std::tr1::shared_ptr<Variant> read_default_;
-  std::tr1::shared_ptr<Variant> write_default_;
+  std::shared_ptr<Variant> read_default_;
+  std::shared_ptr<Variant> write_default_;
   ColumnStorageAttributes attributes_;
 };
 
@@ -768,12 +768,12 @@ class Schema {
   // The map is instrumented with a counting allocator so that we can accurately
   // measure its memory footprint.
   int64_t name_to_index_bytes_;
-  typedef STLCountingAllocator<std::pair<StringPiece, size_t> > NameToIndexMapAllocator;
+  typedef STLCountingAllocator<std::pair<const StringPiece, size_t> > NameToIndexMapAllocator;
   typedef unordered_map<
       StringPiece,
       size_t,
-      __gnu_cxx::hash<StringPiece>,
-      __gnu_cxx::equal_to<StringPiece>,
+      std::hash<StringPiece>,
+      std::equal_to<StringPiece>,
       NameToIndexMapAllocator> NameToIndexMap;
   NameToIndexMap name_to_index_;
 
@@ -854,15 +854,14 @@ class SchemaBuilder {
 
 } // namespace kudu
 
-// Specialize std::tr1::hash for ColumnId
-namespace std { namespace tr1 {
+// Specialize std::hash for ColumnId
+namespace std {
 template<>
 struct hash<kudu::ColumnId> {
   int operator()(const kudu::ColumnId& col_id) const {
     return col_id;
   }
 };
-} // namespace tr1
 } // namespace std
 
 #endif

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/types.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/types.cc b/src/kudu/common/types.cc
index 2e8e6de..207efde 100644
--- a/src/kudu/common/types.cc
+++ b/src/kudu/common/types.cc
@@ -15,18 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include "kudu/common/types.h"
+
+#include <memory>
+#include <unordered_map>
 
 #include "kudu/gutil/singleton.h"
 
-#include "kudu/common/types.h"
+using std::shared_ptr;
+using std::unordered_map;
 
 namespace kudu {
 
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
-
 template<typename TypeTraitsClass>
 TypeInfo::TypeInfo(TypeTraitsClass t)
   : type_(TypeTraitsClass::type),
@@ -80,7 +80,7 @@ class TypeInfoResolver {
 
   unordered_map<DataType,
                 shared_ptr<const TypeInfo>,
-                std::tr1::hash<size_t> > mapping_;
+                std::hash<size_t> > mapping_;
 
   friend class Singleton<TypeInfoResolver>;
   DISALLOW_COPY_AND_ASSIGN(TypeInfoResolver);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/wire_protocol-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/common/wire_protocol-test-util.h b/src/kudu/common/wire_protocol-test-util.h
index 3c5c885..8e47c96 100644
--- a/src/kudu/common/wire_protocol-test-util.h
+++ b/src/kudu/common/wire_protocol-test-util.h
@@ -20,7 +20,6 @@
 
 #include "kudu/common/wire_protocol.h"
 
-#include <boost/assign/list_of.hpp>
 #include <string>
 
 #include "kudu/common/partial_row.h"
@@ -30,11 +29,10 @@
 namespace kudu {
 
 inline Schema GetSimpleTestSchema() {
-  return Schema(boost::assign::list_of
-      (ColumnSchema("key", INT32))
-      (ColumnSchema("int_val", INT32))
-      (ColumnSchema("string_val", STRING, true)),
-      1);
+  return Schema({ ColumnSchema("key", INT32),
+                  ColumnSchema("int_val", INT32),
+                  ColumnSchema("string_val", STRING, true) },
+                1);
 }
 
 inline void AddTestRowWithNullableStringToPB(RowOperationsPB::Type op_type,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/common/wire_protocol-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/common/wire_protocol-test.cc b/src/kudu/common/wire_protocol-test.cc
index d78482a..a9f6c1b 100644
--- a/src/kudu/common/wire_protocol-test.cc
+++ b/src/kudu/common/wire_protocol-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <gtest/gtest.h>
 #include "kudu/common/row.h"
 #include "kudu/common/rowblock.h"
@@ -31,10 +30,9 @@ namespace kudu {
 class WireProtocolTest : public KuduTest {
  public:
   WireProtocolTest()
-    : schema_(boost::assign::list_of
-              (ColumnSchema("col1", STRING))
-              (ColumnSchema("col2", STRING))
-              (ColumnSchema("col3", UINT32, true /* nullable */)),
+    : schema_({ ColumnSchema("col1", STRING),
+                ColumnSchema("col2", STRING),
+                ColumnSchema("col3", UINT32, true /* nullable */) },
               1) {
   }
 
@@ -233,8 +231,7 @@ TEST_F(WireProtocolTest, TestColumnarRowBlockToPBBenchmark) {
 // Test that trying to extract rows from an invalid block correctly returns
 // Corruption statuses.
 TEST_F(WireProtocolTest, TestInvalidRowBlock) {
-  Schema schema(boost::assign::list_of(ColumnSchema("col1", STRING)),
-                1);
+  Schema schema({ ColumnSchema("col1", STRING) }, 1);
   RowwiseRowBlockPB pb;
   vector<const uint8_t*> row_ptrs;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus-test-util.h b/src/kudu/consensus/consensus-test-util.h
index 1634380..a2c5596 100644
--- a/src/kudu/consensus/consensus-test-util.h
+++ b/src/kudu/consensus/consensus-test-util.h
@@ -19,11 +19,11 @@
 #include <boost/thread/locks.hpp>
 #include <gmock/gmock.h>
 #include <map>
+#include <memory>
 #include <string>
-#include <tr1/unordered_map>
-#include <tr1/memory>
-#include <vector>
+#include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "kudu/common/timestamp.h"
 #include "kudu/common/wire_protocol.h"
@@ -360,7 +360,7 @@ class NoOpTestPeerProxyFactory : public PeerProxyFactory {
   gscoped_ptr<ThreadPool> pool_;
 };
 
-typedef std::tr1::unordered_map<std::string, scoped_refptr<RaftConsensus> > TestPeerMap;
+typedef std::unordered_map<std::string, scoped_refptr<RaftConsensus> > TestPeerMap;
 
 // Thread-safe manager for list of peers being used in tests.
 class TestPeerMapManager {
@@ -693,7 +693,7 @@ class TestTransactionFactory : public ReplicaTransactionFactory {
 // If non-null, the passed hook instance will be called first for all methods.
 class CounterHooks : public Consensus::ConsensusFaultHooks {
  public:
-  explicit CounterHooks(const std::tr1::shared_ptr<Consensus::ConsensusFaultHooks>& current_hook)
+  explicit CounterHooks(const std::shared_ptr<Consensus::ConsensusFaultHooks>& current_hook)
       : current_hook_(current_hook),
         pre_start_calls_(0),
         post_start_calls_(0),
@@ -828,7 +828,7 @@ class CounterHooks : public Consensus::ConsensusFaultHooks {
   }
 
  private:
-  std::tr1::shared_ptr<Consensus::ConsensusFaultHooks> current_hook_;
+  std::shared_ptr<Consensus::ConsensusFaultHooks> current_hook_;
   int pre_start_calls_;
   int post_start_calls_;
   int pre_config_change_calls_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus.cc b/src/kudu/consensus/consensus.cc
index 9a1f12e..84dab04 100644
--- a/src/kudu/consensus/consensus.cc
+++ b/src/kudu/consensus/consensus.cc
@@ -28,7 +28,7 @@
 namespace kudu {
 namespace consensus {
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 
 ConsensusBootstrapInfo::ConsensusBootstrapInfo()
@@ -79,11 +79,11 @@ scoped_refptr<ConsensusRound> Consensus::NewRound(
   return make_scoped_refptr(new ConsensusRound(this, replicate_msg.Pass(), replicated_cb));
 }
 
-void Consensus::SetFaultHooks(const std::tr1::shared_ptr<ConsensusFaultHooks>& hooks) {
+void Consensus::SetFaultHooks(const shared_ptr<ConsensusFaultHooks>& hooks) {
   fault_hooks_ = hooks;
 }
 
-const std::tr1::shared_ptr<Consensus::ConsensusFaultHooks>& Consensus::GetFaultHooks() const {
+const shared_ptr<Consensus::ConsensusFaultHooks>& Consensus::GetFaultHooks() const {
   return fault_hooks_;
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus.h b/src/kudu/consensus/consensus.h
index 3ba86ca..aea8230 100644
--- a/src/kudu/consensus/consensus.h
+++ b/src/kudu/consensus/consensus.h
@@ -19,8 +19,8 @@
 
 #include <boost/optional/optional_fwd.hpp>
 #include <iosfwd>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/consensus/consensus.pb.h"
@@ -241,9 +241,9 @@ class Consensus : public RefCountedThreadSafe<Consensus> {
 
   virtual void DumpStatusHtml(std::ostream& out) const = 0;
 
-  void SetFaultHooks(const std::tr1::shared_ptr<ConsensusFaultHooks>& hooks);
+  void SetFaultHooks(const std::shared_ptr<ConsensusFaultHooks>& hooks);
 
-  const std::tr1::shared_ptr<ConsensusFaultHooks>& GetFaultHooks() const;
+  const std::shared_ptr<ConsensusFaultHooks>& GetFaultHooks() const;
 
   // Stops running the consensus algorithm.
   virtual void Shutdown() = 0;
@@ -261,7 +261,7 @@ class Consensus : public RefCountedThreadSafe<Consensus> {
   virtual ~Consensus() {}
 
   // Fault hooks for tests. In production code this will always be null.
-  std::tr1::shared_ptr<ConsensusFaultHooks> fault_hooks_;
+  std::shared_ptr<ConsensusFaultHooks> fault_hooks_;
 
   enum HookPoint {
     PRE_START,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_meta-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_meta-test.cc b/src/kudu/consensus/consensus_meta-test.cc
index 4b3cd43..be6d568 100644
--- a/src/kudu/consensus/consensus_meta-test.cc
+++ b/src/kudu/consensus/consensus_meta-test.cc
@@ -18,7 +18,6 @@
 
 #include <vector>
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
 
@@ -38,7 +37,6 @@
 namespace kudu {
 namespace consensus {
 
-using boost::assign::list_of;
 using std::string;
 using std::vector;
 
@@ -149,7 +147,7 @@ RaftConfigPB BuildConfig(const vector<string>& uuids) {
 
 // Test ConsensusMetadata active role calculation.
 TEST_F(ConsensusMetadataTest, TestActiveRole) {
-  vector<string> uuids = list_of("a")("b")("c")("d");
+  vector<string> uuids = { "a", "b", "c", "d" };
   string peer_uuid = "e";
   RaftConfigPB config1 = BuildConfig(uuids); // We aren't a member of this config...
   config1.set_opid_index(1);
@@ -194,7 +192,7 @@ TEST_F(ConsensusMetadataTest, TestActiveRole) {
 // Ensure that invocations of ToConsensusStatePB() return the expected state
 // in the returned object.
 TEST_F(ConsensusMetadataTest, TestToConsensusStatePB) {
-  vector<string> uuids = list_of("a")("b")("c")("d");
+  vector<string> uuids = { "a", "b", "c", "d" };
   string peer_uuid = "e";
 
   RaftConfigPB committed_config = BuildConfig(uuids); // We aren't a member of this config...
@@ -250,7 +248,7 @@ static void AssertConsensusMergeExpected(const gscoped_ptr<ConsensusMetadata>& c
 
 // Ensure that MergeCommittedConsensusStatePB() works as advertised.
 TEST_F(ConsensusMetadataTest, TestMergeCommittedConsensusStatePB) {
-  vector<string> uuids = list_of("a")("b")("c")("d");
+  vector<string> uuids = { "a", "b", "c", "d" };
 
   RaftConfigPB committed_config = BuildConfig(uuids); // We aren't a member of this config...
   committed_config.set_opid_index(1);
@@ -267,19 +265,19 @@ TEST_F(ConsensusMetadataTest, TestMergeCommittedConsensusStatePB) {
   // Keep the term and votes because the merged term is lower.
   ConsensusStatePB remote_state;
   remote_state.set_current_term(0);
-  *remote_state.mutable_config() = BuildConfig(list_of("x")("y")("z"));
+  *remote_state.mutable_config() = BuildConfig({ "x", "y", "z" });
   cmeta->MergeCommittedConsensusStatePB(remote_state);
   NO_FATALS(AssertConsensusMergeExpected(cmeta, remote_state, 1, "e"));
 
   // Same as above because the merged term is the same as the cmeta term.
   remote_state.set_current_term(1);
-  *remote_state.mutable_config() = BuildConfig(list_of("f")("g")("h"));
+  *remote_state.mutable_config() = BuildConfig({ "f", "g", "h" });
   cmeta->MergeCommittedConsensusStatePB(remote_state);
   NO_FATALS(AssertConsensusMergeExpected(cmeta, remote_state, 1, "e"));
 
   // Higher term, so wipe out the prior state.
   remote_state.set_current_term(2);
-  *remote_state.mutable_config() = BuildConfig(list_of("i")("j")("k"));
+  *remote_state.mutable_config() = BuildConfig({ "i", "j", "k" });
   cmeta->set_pending_config(pending_config);
   cmeta->MergeCommittedConsensusStatePB(remote_state);
   NO_FATALS(AssertConsensusMergeExpected(cmeta, remote_state, 2, ""));

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_peers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index 271e71c..93fff35 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include "kudu/consensus/consensus.proxy.h"
+
 #include <algorithm>
 #include <boost/bind.hpp>
 #include <gflags/gflags.h>
@@ -25,7 +27,6 @@
 
 #include "kudu/common/wire_protocol.h"
 #include "kudu/consensus/consensus_peers.h"
-#include "kudu/consensus/consensus.proxy.h"
 #include "kudu/consensus/consensus_queue.h"
 #include "kudu/consensus/log.h"
 #include "kudu/gutil/map-util.h"
@@ -67,7 +68,7 @@ namespace consensus {
 
 using log::Log;
 using log::LogEntryBatch;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using rpc::Messenger;
 using rpc::RpcController;
 using strings::Substitute;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_peers.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.h b/src/kudu/consensus/consensus_peers.h
index 8b491d4..ddb8b1e 100644
--- a/src/kudu/consensus/consensus_peers.h
+++ b/src/kudu/consensus/consensus_peers.h
@@ -18,8 +18,8 @@
 #ifndef KUDU_CONSENSUS_CONSENSUS_PEERS_H_
 #define KUDU_CONSENSUS_CONSENSUS_PEERS_H_
 
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <vector>
 
 #include "kudu/consensus/consensus.pb.h"
@@ -305,20 +305,20 @@ class RpcPeerProxy : public PeerProxy {
 // PeerProxyFactory implementation that generates RPCPeerProxies
 class RpcPeerProxyFactory : public PeerProxyFactory {
  public:
-  explicit RpcPeerProxyFactory(const std::tr1::shared_ptr<rpc::Messenger>& messenger);
+  explicit RpcPeerProxyFactory(const std::shared_ptr<rpc::Messenger>& messenger);
 
   virtual Status NewProxy(const RaftPeerPB& peer_pb,
                           gscoped_ptr<PeerProxy>* proxy) OVERRIDE;
 
   virtual ~RpcPeerProxyFactory();
  private:
-  std::tr1::shared_ptr<rpc::Messenger> messenger_;
+  std::shared_ptr<rpc::Messenger> messenger_;
 };
 
 // Query the consensus service at last known host/port that is
 // specified in 'remote_peer' and set the 'permanent_uuid' field based
 // on the response.
-Status SetPermanentUuidForRemotePeer(const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+Status SetPermanentUuidForRemotePeer(const std::shared_ptr<rpc::Messenger>& messenger,
                                      RaftPeerPB* remote_peer);
 
 }  // namespace consensus

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_queue-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue-test.cc b/src/kudu/consensus/consensus_queue-test.cc
index d11da94..9eb90cb 100644
--- a/src/kudu/consensus/consensus_queue-test.cc
+++ b/src/kudu/consensus/consensus_queue-test.cc
@@ -17,7 +17,6 @@
 
 #include <gtest/gtest.h>
 #include <gflags/gflags.h>
-#include <tr1/memory>
 
 #include "kudu/common/schema.h"
 #include "kudu/common/wire_protocol-test-util.h"
@@ -39,8 +38,6 @@ DECLARE_int32(consensus_max_batch_size_bytes);
 
 METRIC_DECLARE_entity(tablet);
 
-using std::tr1::shared_ptr;
-
 namespace kudu {
 namespace consensus {
 
@@ -631,8 +628,8 @@ TEST_F(ConsensusQueueTest, TestQueueMovesWatermarksBackward) {
   // Now rewrite some of the operations and wait for the log to append.
   Synchronizer synch;
   CHECK_OK(queue_->AppendOperations(
-      boost::assign::list_of(make_scoped_refptr(new RefCountedReplicate(
-          CreateDummyReplicate(2, 5, clock_->Now(), 0).release()))),
+        { make_scoped_refptr(new RefCountedReplicate(
+              CreateDummyReplicate(2, 5, clock_->Now(), 0).release())) },
       synch.AsStatusCallback()));
 
   // Wait for the operation to be in the log.
@@ -642,8 +639,8 @@ TEST_F(ConsensusQueueTest, TestQueueMovesWatermarksBackward) {
   // in log cache.
   synch.Reset();
   CHECK_OK(queue_->AppendOperations(
-      boost::assign::list_of(make_scoped_refptr(new RefCountedReplicate(
-          CreateDummyReplicate(2, 6, clock_->Now(), 0).release()))),
+        { make_scoped_refptr(new RefCountedReplicate(
+              CreateDummyReplicate(2, 6, clock_->Now(), 0).release())) },
       synch.AsStatusCallback()));
 
   // Wait for the operation to be in the log.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_queue.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.cc b/src/kudu/consensus/consensus_queue.cc
index ded92aa..019911f 100644
--- a/src/kudu/consensus/consensus_queue.cc
+++ b/src/kudu/consensus/consensus_queue.cc
@@ -17,13 +17,11 @@
 #include "kudu/consensus/consensus_queue.h"
 
 #include <algorithm>
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <boost/thread/locks.hpp>
 #include <gflags/gflags.h>
 #include <iostream>
 #include <string>
-#include <tr1/memory>
 #include <utility>
 
 #include "kudu/common/wire_protocol.h"
@@ -72,8 +70,6 @@ namespace consensus {
 using log::AsyncLogReader;
 using log::Log;
 using rpc::Messenger;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
 using strings::Substitute;
 
 METRIC_DEFINE_gauge_int64(tablet, majority_done_ops, "Leader Operations Acked by Majority",
@@ -244,7 +240,7 @@ void PeerMessageQueue::LocalPeerAppendFinished(const OpId& id,
 }
 
 Status PeerMessageQueue::AppendOperation(const ReplicateRefPtr& msg) {
-  return AppendOperations(boost::assign::list_of(msg), Bind(DoNothingStatusCB));
+  return AppendOperations({ msg }, Bind(DoNothingStatusCB));
 }
 
 Status PeerMessageQueue::AppendOperations(const vector<ReplicateRefPtr>& msgs,

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/consensus_queue.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.h b/src/kudu/consensus/consensus_queue.h
index 2882e44..69c08d8 100644
--- a/src/kudu/consensus/consensus_queue.h
+++ b/src/kudu/consensus/consensus_queue.h
@@ -21,7 +21,7 @@
 #include <iosfwd>
 #include <map>
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -334,7 +334,7 @@ class PeerMessageQueue {
                                            int64_t term,
                                            const std::string& reason);
 
-  typedef std::tr1::unordered_map<std::string, TrackedPeer*> PeersMap;
+  typedef std::unordered_map<std::string, TrackedPeer*> PeersMap;
 
   std::string ToStringUnlocked() const;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/leader_election-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election-test.cc b/src/kudu/consensus/leader_election-test.cc
index b3ef61a..e1a1a18 100644
--- a/src/kudu/consensus/leader_election-test.cc
+++ b/src/kudu/consensus/leader_election-test.cc
@@ -17,7 +17,6 @@
 
 #include "kudu/consensus/leader_election.h"
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <string>
 #include <vector>
@@ -35,7 +34,7 @@ namespace kudu {
 namespace consensus {
 
 using std::string;
-using std::tr1::unordered_map;
+using std::unordered_map;
 using std::vector;
 using strings::Substitute;
 
@@ -265,7 +264,7 @@ scoped_refptr<LeaderElection> LeaderElectionTest::SetUpElectionWithGrantDenyErro
 // All peers respond "yes", no failures.
 TEST_F(LeaderElectionTest, TestPerfectElection) {
   // Try configuration sizes of 1, 3, 5.
-  vector<int> config_sizes = boost::assign::list_of(1)(3)(5);
+  vector<int> config_sizes = { 1, 3, 5 };
   BOOST_FOREACH(int num_voters, config_sizes) {
     LOG(INFO) << "Testing election with config size of " << num_voters;
     int majority_size = (num_voters / 2) + 1;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/leader_election.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election.cc b/src/kudu/consensus/leader_election.cc
index 42322c7..6d7131e 100644
--- a/src/kudu/consensus/leader_election.cc
+++ b/src/kudu/consensus/leader_election.cc
@@ -39,7 +39,6 @@ namespace kudu {
 namespace consensus {
 
 using std::string;
-using std::tr1::unordered_map;
 using strings::Substitute;
 
 ///////////////////////////////////////////////////

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/leader_election.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election.h b/src/kudu/consensus/leader_election.h
index e824cfc..c44f1ae 100644
--- a/src/kudu/consensus/leader_election.h
+++ b/src/kudu/consensus/leader_election.h
@@ -20,8 +20,7 @@
 
 #include <map>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <vector>
 
 #include "kudu/consensus/consensus.h"
@@ -149,7 +148,7 @@ struct ElectionResult {
 class LeaderElection : public RefCountedThreadSafe<LeaderElection> {
  public:
   typedef Callback<void(const ElectionResult&)> ElectionDecisionCallback;
-  typedef std::tr1::unordered_map<std::string, PeerProxy*> ProxyMap;
+  typedef std::unordered_map<std::string, PeerProxy*> ProxyMap;
 
   // Set up a new leader election driver.
   //
@@ -179,7 +178,7 @@ class LeaderElection : public RefCountedThreadSafe<LeaderElection> {
     VoteResponsePB response;
   };
 
-  typedef std::tr1::unordered_map<std::string, VoterState*> VoterStateMap;
+  typedef std::unordered_map<std::string, VoterState*> VoterStateMap;
   typedef simple_spinlock Lock;
 
   // This class is refcounted.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/local_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/local_consensus.cc b/src/kudu/consensus/local_consensus.cc
index 9053993..892a507 100644
--- a/src/kudu/consensus/local_consensus.cc
+++ b/src/kudu/consensus/local_consensus.cc
@@ -18,7 +18,6 @@
 #include "kudu/consensus/local_consensus.h"
 
 #include <boost/thread/locks.hpp>
-#include <boost/assign/list_of.hpp>
 #include <iostream>
 
 #include "kudu/consensus/log.h"
@@ -36,7 +35,6 @@ namespace consensus {
 using base::subtle::Barrier_AtomicIncrement;
 using log::Log;
 using log::LogEntryBatch;
-using std::tr1::shared_ptr;
 using strings::Substitute;
 
 LocalConsensus::LocalConsensus(const ConsensusOptions& options,
@@ -128,8 +126,7 @@ Status LocalConsensus::Replicate(const scoped_refptr<ConsensusRound>& round) {
     // It's important that we do this under the same lock as we generate
     // the op id, so that we log things in-order.
     gscoped_ptr<log::LogEntryBatchPB> entry_batch;
-    log::CreateBatchFromAllocatedOperations(
-        boost::assign::list_of(round->replicate_scoped_refptr()), &entry_batch);
+    log::CreateBatchFromAllocatedOperations({ round->replicate_scoped_refptr() }, &entry_batch);
 
     RETURN_NOT_OK(log_->Reserve(log::REPLICATE, entry_batch.Pass(),
                                 &reserved_entry_batch));

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-test-base.h b/src/kudu/consensus/log-test-base.h
index c1dae9a..067e843 100644
--- a/src/kudu/consensus/log-test-base.h
+++ b/src/kudu/consensus/log-test-base.h
@@ -19,7 +19,6 @@
 
 #include "kudu/consensus/log.h"
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <glog/logging.h>
 #include <gtest/gtest.h>
@@ -221,15 +220,13 @@ class LogTestBase : public KuduTest {
                             bool sync = APPEND_SYNC) {
     if (sync) {
       Synchronizer s;
-      ASSERT_OK(log_->AsyncAppendReplicates(boost::assign::list_of(replicate),
-                                                   s.AsStatusCallback()));
+      ASSERT_OK(log_->AsyncAppendReplicates({ replicate }, s.AsStatusCallback()));
       ASSERT_OK(s.Wait());
     } else {
       // AsyncAppendReplicates does not free the ReplicateMsg on completion, so we
       // need to pass it through to our callback.
-      ASSERT_OK(log_->AsyncAppendReplicates(boost::assign::list_of(replicate),
-                                                   Bind(&LogTestBase::CheckReplicateResult,
-                                                        replicate)));
+      ASSERT_OK(log_->AsyncAppendReplicates({ replicate },
+                                            Bind(&LogTestBase::CheckReplicateResult, replicate)));
     }
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-test.cc b/src/kudu/consensus/log-test.cc
index 4c382fa..703e5fa 100644
--- a/src/kudu/consensus/log-test.cc
+++ b/src/kudu/consensus/log-test.cc
@@ -39,8 +39,7 @@ DECLARE_int32(log_min_segments_to_retain);
 namespace kudu {
 namespace log {
 
-using std::tr1::shared_ptr;
-using std::tr1::unordered_map;
+using std::shared_ptr;
 using consensus::MakeOpId;
 using strings::Substitute;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log.cc b/src/kudu/consensus/log.cc
index 237c460..fac45d9 100644
--- a/src/kudu/consensus/log.cc
+++ b/src/kudu/consensus/log.cc
@@ -42,10 +42,10 @@
 #include "kudu/util/path_util.h"
 #include "kudu/util/pb_util.h"
 #include "kudu/util/random.h"
+#include "kudu/util/stopwatch.h"
 #include "kudu/util/thread.h"
 #include "kudu/util/threadpool.h"
 #include "kudu/util/trace.h"
-#include "kudu/util/stopwatch.h"
 
 // Log retention configuration.
 // -----------------------------
@@ -114,8 +114,8 @@ using consensus::CommitMsg;
 using consensus::OpId;
 using consensus::ReplicateRefPtr;
 using env_util::OpenFileForRandom;
+using std::shared_ptr;
 using strings::Substitute;
-using std::tr1::shared_ptr;
 
 // This class is responsible for managing the thread that appends to
 // the log file.

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log.h b/src/kudu/consensus/log.h
index ad89b3f..8c4b1e7 100644
--- a/src/kudu/consensus/log.h
+++ b/src/kudu/consensus/log.h
@@ -20,6 +20,7 @@
 
 #include <boost/thread/shared_mutex.hpp>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -43,11 +44,11 @@ class ThreadPool;
 
 namespace log {
 
+struct LogEntryBatchLogicalSize;
+struct LogMetrics;
+class LogEntryBatch;
 class LogIndex;
 class LogReader;
-class LogEntryBatch;
-struct LogMetrics;
-struct LogEntryBatchLogicalSize;
 
 typedef BlockingQueue<LogEntryBatch*, LogEntryBatchLogicalSize> LogEntryBatchQueue;
 
@@ -218,7 +219,7 @@ class Log : public RefCountedThreadSafe<Log> {
   // Returns this Log's FsManager.
   FsManager* GetFsManager();
 
-  void SetLogFaultHooksForTests(const std::tr1::shared_ptr<LogFaultHooks> &hooks) {
+  void SetLogFaultHooksForTests(const std::shared_ptr<LogFaultHooks> &hooks) {
     log_hooks_ = hooks;
   }
 
@@ -273,7 +274,7 @@ class Log : public RefCountedThreadSafe<Log> {
   // created for the segment.
   Status CreatePlaceholderSegment(const WritableFileOptions& opts,
                                   std::string* result_path,
-                                  std::tr1::shared_ptr<WritableFile>* out);
+                                  std::shared_ptr<WritableFile>* out);
 
   // Creates a new WAL segment on disk, writes the next_segment_header_ to
   // disk as the header, and sets active_segment_ to point to this new segment.
@@ -339,7 +340,7 @@ class Log : public RefCountedThreadSafe<Log> {
   uint64_t active_segment_sequence_number_;
 
   // The writable file for the next allocated segment
-  std::tr1::shared_ptr<WritableFile> next_segment_file_;
+  std::shared_ptr<WritableFile> next_segment_file_;
 
   // The path for the next allocated segment.
   std::string next_segment_path_;
@@ -397,7 +398,7 @@ class Log : public RefCountedThreadSafe<Log> {
   scoped_refptr<MetricEntity> metric_entity_;
   gscoped_ptr<LogMetrics> metrics_;
 
-  std::tr1::shared_ptr<LogFaultHooks> log_hooks_;
+  std::shared_ptr<LogFaultHooks> log_hooks_;
 
   DISALLOW_COPY_AND_ASSIGN(Log);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log_cache-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_cache-test.cc b/src/kudu/consensus/log_cache-test.cc
index 92d66b4..b9a71f1 100644
--- a/src/kudu/consensus/log_cache-test.cc
+++ b/src/kudu/consensus/log_cache-test.cc
@@ -16,8 +16,8 @@
 // under the License.
 
 #include <gtest/gtest.h>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 
 #include "kudu/common/wire_protocol-test-util.h"
 #include "kudu/consensus/consensus-test-util.h"
@@ -31,7 +31,7 @@
 #include "kudu/util/metrics.h"
 #include "kudu/util/test_util.h"
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 DECLARE_int32(log_cache_size_limit_mb);
 DECLARE_int32(global_log_cache_size_limit_mb);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log_cache.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_cache.h b/src/kudu/consensus/log_cache.h
index 67ef82f..ba6739c 100644
--- a/src/kudu/consensus/log_cache.h
+++ b/src/kudu/consensus/log_cache.h
@@ -18,9 +18,8 @@
 #define KUDU_CONSENSUS_LOG_CACHE_H
 
 #include <map>
+#include <memory>
 #include <string>
-#include <tr1/memory>
-#include <tr1/unordered_set>
 #include <vector>
 
 #include "kudu/consensus/consensus.pb.h"
@@ -194,10 +193,10 @@ class LogCache {
   // the parent tracker can be deleted if all log caches are
   // deleted (e.g., if all tablets are deleted from a server, or if
   // the server is shutdown).
-  std::tr1::shared_ptr<MemTracker> parent_tracker_;
+  std::shared_ptr<MemTracker> parent_tracker_;
 
   // A MemTracker for this instance.
-  std::tr1::shared_ptr<MemTracker> tracker_;
+  std::shared_ptr<MemTracker> tracker_;
 
   struct Metrics {
     explicit Metrics(const scoped_refptr<MetricEntity>& metric_entity);

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_util.cc b/src/kudu/consensus/log_util.cc
index 00c3491..815a080 100644
--- a/src/kudu/consensus/log_util.cc
+++ b/src/kudu/consensus/log_util.cc
@@ -18,11 +18,11 @@
 #include "kudu/consensus/log_util.h"
 
 #include <algorithm>
-#include <boost/foreach.hpp>
 #include <iostream>
 #include <limits>
 #include <utility>
 
+#include <boost/foreach.hpp>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 
@@ -31,11 +31,11 @@
 #include "kudu/fs/fs_manager.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/stl_util.h"
+#include "kudu/gutil/strings/split.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/gutil/strings/util.h"
-#include "kudu/gutil/strings/split.h"
-#include "kudu/util/coding.h"
 #include "kudu/util/coding-inl.h"
+#include "kudu/util/coding.h"
 #include "kudu/util/crc.h"
 #include "kudu/util/debug/trace_event.h"
 #include "kudu/util/env_util.h"
@@ -64,7 +64,7 @@ namespace log {
 using consensus::OpId;
 using env_util::ReadFully;
 using std::vector;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using strings::Substitute;
 using strings::SubstituteAndAppend;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/log_util.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_util.h b/src/kudu/consensus/log_util.h
index dcc213d..6bac7c2 100644
--- a/src/kudu/consensus/log_util.h
+++ b/src/kudu/consensus/log_util.h
@@ -18,11 +18,11 @@
 #ifndef KUDU_CONSENSUS_LOG_UTIL_H_
 #define KUDU_CONSENSUS_LOG_UTIL_H_
 
-#include <iosfwd>
 #include <gtest/gtest.h>
+#include <iosfwd>
 #include <map>
+#include <memory>
 #include <string>
-#include <tr1/memory>
 #include <utility>
 #include <vector>
 
@@ -95,7 +95,7 @@ class ReadableLogSegment : public RefCountedThreadSafe<ReadableLogSegment> {
 
   // Build a readable segment to read entries from the provided path.
   ReadableLogSegment(const std::string &path,
-                     const std::tr1::shared_ptr<RandomAccessFile>& readable_file);
+                     const std::shared_ptr<RandomAccessFile>& readable_file);
 
   // Initialize the ReadableLogSegment.
   // This initializer provides methods for avoiding disk IO when creating a
@@ -167,7 +167,7 @@ class ReadableLogSegment : public RefCountedThreadSafe<ReadableLogSegment> {
     return footer_;
   }
 
-  const std::tr1::shared_ptr<RandomAccessFile> readable_file() const {
+  const std::shared_ptr<RandomAccessFile> readable_file() const {
     return readable_file_;
   }
 
@@ -272,7 +272,7 @@ class ReadableLogSegment : public RefCountedThreadSafe<ReadableLogSegment> {
   AtomicInt<int64_t> readable_to_offset_;
 
   // a readable file for a log segment (used on replay)
-  const std::tr1::shared_ptr<RandomAccessFile> readable_file_;
+  const std::shared_ptr<RandomAccessFile> readable_file_;
 
   bool is_initialized_;
 
@@ -293,7 +293,7 @@ class ReadableLogSegment : public RefCountedThreadSafe<ReadableLogSegment> {
 class WritableLogSegment {
  public:
   WritableLogSegment(const std::string &path,
-                     const std::tr1::shared_ptr<WritableFile>& writable_file);
+                     const std::shared_ptr<WritableFile>& writable_file);
 
   // Opens the segment by writing the header.
   Status WriteHeaderAndOpen(const LogSegmentHeaderPB& new_header);
@@ -354,7 +354,7 @@ class WritableLogSegment {
 
  private:
 
-  const std::tr1::shared_ptr<WritableFile>& writable_file() const {
+  const std::shared_ptr<WritableFile>& writable_file() const {
     return writable_file_;
   }
 
@@ -362,7 +362,7 @@ class WritableLogSegment {
   const std::string path_;
 
   // The writable file to which this LogSegment will be written.
-  const std::tr1::shared_ptr<WritableFile> writable_file_;
+  const std::shared_ptr<WritableFile> writable_file_;
 
   bool is_header_written_;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/mt-log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/mt-log-test.cc b/src/kudu/consensus/mt-log-test.cc
index 78503b6..bf8f6f1 100644
--- a/src/kudu/consensus/mt-log-test.cc
+++ b/src/kudu/consensus/mt-log-test.cc
@@ -18,7 +18,6 @@
 #include "kudu/consensus/log-test-base.h"
 
 #include <boost/thread/locks.hpp>
-#include <boost/assign/list_of.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 
@@ -39,7 +38,6 @@ DEFINE_int32(num_ops_per_batch_avg, 5, "Target average number of ops per batch")
 namespace kudu {
 namespace log {
 
-using std::tr1::shared_ptr;
 using std::vector;
 using consensus::ReplicateRefPtr;
 using consensus::make_scoped_refptr_replicate;
@@ -170,7 +168,7 @@ TEST_F(MultiThreadedLogTest, TestAppends) {
   EntriesToIdList(&ids);
   DVLOG(1) << "Wrote total of " << current_index_ - start_current_id << " ops";
   ASSERT_EQ(current_index_ - start_current_id, ids.size());
-  ASSERT_TRUE(util::gtl::is_sorted(ids.begin(), ids.end()));
+  ASSERT_TRUE(std::is_sorted(ids.begin(), ids.end()));
 }
 
 } // namespace log

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/peer_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/peer_manager.h b/src/kudu/consensus/peer_manager.h
index 08c1a7e..c1dc86f 100644
--- a/src/kudu/consensus/peer_manager.h
+++ b/src/kudu/consensus/peer_manager.h
@@ -24,7 +24,7 @@
 #include "kudu/util/status.h"
 
 #include <string>
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 namespace kudu {
 
@@ -72,7 +72,7 @@ class PeerManager {
  private:
   std::string GetLogPrefix() const;
 
-  typedef std::tr1::unordered_map<std::string, Peer*> PeersMap;
+  typedef std::unordered_map<std::string, Peer*> PeersMap;
   const std::string tablet_id_;
   const std::string local_uuid_;
   PeerProxyFactory* peer_proxy_factory_;

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus-test.cc b/src/kudu/consensus/raft_consensus-test.cc
index 6e743f8..0df4d50 100644
--- a/src/kudu/consensus/raft_consensus-test.cc
+++ b/src/kudu/consensus/raft_consensus-test.cc
@@ -37,8 +37,8 @@ DECLARE_bool(enable_leader_failure_detection);
 
 METRIC_DECLARE_entity(tablet);
 
+using std::shared_ptr;
 using std::string;
-using std::tr1::shared_ptr;
 
 namespace kudu {
 namespace consensus {

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 6b18bbe..06952d1 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -18,7 +18,6 @@
 #include "kudu/consensus/raft_consensus.h"
 
 #include <algorithm>
-#include <boost/assign/list_of.hpp>
 #include <boost/optional.hpp>
 #include <gflags/gflags.h>
 #include <iostream>
@@ -137,8 +136,7 @@ namespace kudu {
 namespace consensus {
 
 using log::LogEntryBatch;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
+using std::shared_ptr;
 using strings::Substitute;
 using tserver::TabletServerErrorPB;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.h b/src/kudu/consensus/raft_consensus.h
index a84dac1..cb10223 100644
--- a/src/kudu/consensus/raft_consensus.h
+++ b/src/kudu/consensus/raft_consensus.h
@@ -19,10 +19,10 @@
 #define KUDU_CONSENSUS_RAFT_CONSENSUS_H_
 
 #include <boost/thread/locks.hpp>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
-#include <tr1/memory>
 
 #include "kudu/consensus/consensus.h"
 #include "kudu/consensus/consensus.pb.h"
@@ -69,9 +69,9 @@ class RaftConsensus : public Consensus,
     const scoped_refptr<MetricEntity>& metric_entity,
     const scoped_refptr<server::Clock>& clock,
     ReplicaTransactionFactory* txn_factory,
-    const std::tr1::shared_ptr<rpc::Messenger>& messenger,
+    const std::shared_ptr<rpc::Messenger>& messenger,
     const scoped_refptr<log::Log>& log,
-    const std::tr1::shared_ptr<MemTracker>& parent_mem_tracker,
+    const std::shared_ptr<MemTracker>& parent_mem_tracker,
     const Callback<void(const std::string& reason)>& mark_dirty_clbk);
 
   RaftConsensus(const ConsensusOptions& options,
@@ -85,7 +85,7 @@ class RaftConsensus : public Consensus,
                 const scoped_refptr<server::Clock>& clock,
                 ReplicaTransactionFactory* txn_factory,
                 const scoped_refptr<log::Log>& log,
-                const std::tr1::shared_ptr<MemTracker>& parent_mem_tracker,
+                const std::shared_ptr<MemTracker>& parent_mem_tracker,
                 const Callback<void(const std::string& reason)>& mark_dirty_clbk);
 
   virtual ~RaftConsensus();
@@ -456,7 +456,7 @@ class RaftConsensus : public Consensus,
   scoped_refptr<Counter> follower_memory_pressure_rejections_;
   scoped_refptr<AtomicGauge<int64_t> > term_metric_;
 
-  std::tr1::shared_ptr<MemTracker> parent_mem_tracker_;
+  std::shared_ptr<MemTracker> parent_mem_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(RaftConsensus);
 };

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus_quorum-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc
index 078abb8..a835ee4 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
 
@@ -54,7 +53,7 @@ METRIC_DECLARE_entity(tablet);
 #define REPLICATE_SEQUENCE_OF_MESSAGES(a, b, c, d, e, f, g) \
   ASSERT_NO_FATAL_FAILURE(ReplicateSequenceOfMessages(a, b, c, d, e, f, g))
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace kudu {
 
@@ -120,7 +119,7 @@ class RaftConsensusQuorumTest : public KuduTest {
       FsManagerOpts opts;
       opts.parent_mem_tracker = parent_mem_tracker;
       opts.wal_path = test_path;
-      opts.data_paths = boost::assign::list_of(test_path);
+      opts.data_paths = { test_path };
       gscoped_ptr<FsManager> fs_manager(new FsManager(env_.get(), opts));
       RETURN_NOT_OK(fs_manager->CreateInitialFileSystemLayout());
       RETURN_NOT_OK(fs_manager->Open());

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus_state-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_state-test.cc b/src/kudu/consensus/raft_consensus_state-test.cc
index 1b0722a..a699861 100644
--- a/src/kudu/consensus/raft_consensus_state-test.cc
+++ b/src/kudu/consensus/raft_consensus_state-test.cc
@@ -16,7 +16,6 @@
 // under the License.
 #include "kudu/consensus/raft_consensus_state.h"
 
-#include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <gtest/gtest.h>
 #include <vector>
@@ -31,7 +30,6 @@
 namespace kudu {
 namespace consensus {
 
-using boost::assign::list_of;
 using std::vector;
 
 // TODO: Share a test harness with ConsensusMetadataTest?

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus_state.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_state.cc b/src/kudu/consensus/raft_consensus_state.cc
index 5c80b94..2a03187 100644
--- a/src/kudu/consensus/raft_consensus_state.cc
+++ b/src/kudu/consensus/raft_consensus_state.cc
@@ -34,8 +34,6 @@ namespace kudu {
 namespace consensus {
 
 using std::string;
-using std::tr1::shared_ptr;
-using std::tr1::unordered_set;
 using strings::Substitute;
 using strings::SubstituteAndAppend;
 

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/9806863e/src/kudu/consensus/raft_consensus_state.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus_state.h b/src/kudu/consensus/raft_consensus_state.h
index 6d44f1f..20a98c5 100644
--- a/src/kudu/consensus/raft_consensus_state.h
+++ b/src/kudu/consensus/raft_consensus_state.h
@@ -20,8 +20,6 @@
 #include <map>
 #include <set>
 #include <string>
-#include <tr1/unordered_set>
-#include <tr1/unordered_map>
 #include <utility>
 #include <vector>
 



Mime
View raw message