You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by to...@apache.org on 2016/02/23 01:10:56 UTC
[4/5] incubator-kudu git commit: Replace simpler instances of
foo.Pass() with std::move(foo)
Replace simpler instances of foo.Pass() with std::move(foo)
This commit was done primarily via this perl script:
perl -p -i -e 's,([\w_]+)\.Pass\(\),std::move(\1),g' \
$(find src -name \*.h -or -name \*.cc)
with one or two trivial manual fixups where the regex went wrong and
introduced a syntax error. Additionally, I reverted the changes to
gutil/callback* and gutil/bind* since those files are complicated
and seemed to cause a lot of trouble.
Change-Id: Ibff7624f2d21ee098dfba466ebfbb09fd2c9862d
Reviewed-on: http://gerrit.cloudera.org:8080/2246
Tested-by: Kudu Jenkins
Reviewed-by: Dan Burkert <da...@cloudera.com>
Project: http://git-wip-us.apache.org/repos/asf/incubator-kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-kudu/commit/d0a02cd4
Tree: http://git-wip-us.apache.org/repos/asf/incubator-kudu/tree/d0a02cd4
Diff: http://git-wip-us.apache.org/repos/asf/incubator-kudu/diff/d0a02cd4
Branch: refs/heads/master
Commit: d0a02cd42081d2182652fd1d246227ebae3543fd
Parents: ff36266
Author: Todd Lipcon <to...@apache.org>
Authored: Thu Feb 18 21:32:22 2016 -0800
Committer: Todd Lipcon <to...@apache.org>
Committed: Tue Feb 23 00:10:05 2016 +0000
----------------------------------------------------------------------
src/kudu/benchmarks/tpch/tpch_real_world.cc | 2 +-
src/kudu/cfile/bloomfile-test-base.h | 4 +--
src/kudu/cfile/bloomfile-test.cc | 8 +++---
src/kudu/cfile/bloomfile.cc | 14 +++++------
src/kudu/cfile/cfile-dump.cc | 2 +-
src/kudu/cfile/cfile-test-base.h | 4 +--
src/kudu/cfile/cfile-test.cc | 26 ++++++++++----------
src/kudu/cfile/cfile_reader.cc | 6 ++---
src/kudu/cfile/cfile_writer.cc | 6 ++---
src/kudu/client/batcher.cc | 8 +++---
src/kudu/client/client-test.cc | 6 ++---
src/kudu/client/error-internal.cc | 2 +-
src/kudu/consensus/consensus-test-util.h | 4 +--
src/kudu/consensus/consensus.cc | 2 +-
src/kudu/consensus/consensus_peers-test.cc | 2 +-
src/kudu/consensus/consensus_peers.cc | 10 ++++----
src/kudu/consensus/leader_election-test.cc | 10 ++++----
src/kudu/consensus/leader_election.cc | 2 +-
src/kudu/consensus/local_consensus.cc | 4 +--
src/kudu/consensus/log-test-base.h | 6 ++---
src/kudu/consensus/log-test.cc | 2 +-
src/kudu/consensus/log.cc | 13 +++++-----
src/kudu/consensus/mt-log-test.cc | 2 +-
src/kudu/consensus/peer_manager.cc | 2 +-
src/kudu/consensus/raft_consensus-test.cc | 16 ++++++------
src/kudu/consensus/raft_consensus.cc | 24 +++++++++---------
.../consensus/raft_consensus_quorum-test.cc | 14 +++++------
src/kudu/consensus/raft_consensus_state-test.cc | 2 +-
src/kudu/consensus/raft_consensus_state.cc | 2 +-
src/kudu/fs/block_manager-test.cc | 6 ++---
src/kudu/fs/block_manager_util-test.cc | 2 +-
src/kudu/fs/block_manager_util.h | 2 +-
src/kudu/fs/fs-test-util.h | 4 +--
src/kudu/fs/log_block_manager.cc | 18 +++++++-------
src/kudu/gutil/gscoped_ptr.h | 8 +++---
src/kudu/gutil/move.h | 4 +--
.../full_stack-insert-scan-test.cc | 4 +--
src/kudu/master/catalog_manager.cc | 2 +-
src/kudu/master/master.cc | 4 +--
src/kudu/master/sys_catalog.cc | 2 +-
src/kudu/rpc/connection.cc | 24 +++++++++---------
src/kudu/rpc/messenger.cc | 2 +-
src/kudu/rpc/mt-rpc-test.cc | 4 +--
src/kudu/rpc/outbound_call.cc | 2 +-
src/kudu/rpc/rpc-test-base.h | 6 ++---
src/kudu/rpc/rpc_context.cc | 2 +-
src/kudu/rpc/rpc_sidecar.h | 2 +-
src/kudu/rpc/sasl_rpc-test.cc | 4 +--
src/kudu/rpc/service_pool.cc | 2 +-
src/kudu/server/rpc_server.cc | 2 +-
src/kudu/server/server_base.cc | 2 +-
src/kudu/tablet/cfile_set.cc | 6 ++---
src/kudu/tablet/compaction.cc | 4 +--
src/kudu/tablet/delta_compaction-test.cc | 4 +--
src/kudu/tablet/delta_compaction.cc | 4 +--
src/kudu/tablet/delta_tracker.cc | 10 ++++----
src/kudu/tablet/deltafile-test.cc | 14 +++++------
src/kudu/tablet/deltafile.cc | 6 ++---
src/kudu/tablet/deltamemstore-test.cc | 2 +-
src/kudu/tablet/diskrowset-test.cc | 4 +--
src/kudu/tablet/diskrowset.cc | 8 +++---
src/kudu/tablet/memrowset.cc | 6 ++---
src/kudu/tablet/multi_column_writer.cc | 2 +-
src/kudu/tablet/row_op.cc | 2 +-
src/kudu/tablet/tablet-test.cc | 2 +-
src/kudu/tablet/tablet.cc | 6 ++---
src/kudu/tablet/tablet_bootstrap-test.cc | 10 ++++----
src/kudu/tablet/tablet_metadata.cc | 4 +--
src/kudu/tablet/tablet_peer.cc | 10 ++++----
.../tablet/transactions/transaction_driver.cc | 6 ++---
.../tablet/transactions/write_transaction.cc | 2 +-
src/kudu/tools/fs_tool.cc | 4 +--
src/kudu/tools/pbc-dump.cc | 2 +-
src/kudu/tserver/tablet_server.cc | 8 +++---
src/kudu/tserver/tablet_service.cc | 10 ++++----
src/kudu/twitter-demo/ingest_firehose.cc | 4 +--
src/kudu/util/callback_bind-test.cc | 2 +-
src/kudu/util/debug/trace_event_impl.cc | 14 +++++------
src/kudu/util/pb_util-test.cc | 12 ++++-----
src/kudu/util/pb_util.cc | 8 +++---
80 files changed, 245 insertions(+), 244 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/benchmarks/tpch/tpch_real_world.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/tpch_real_world.cc b/src/kudu/benchmarks/tpch/tpch_real_world.cc
index 4e6a2e5..e161ded 100644
--- a/src/kudu/benchmarks/tpch/tpch_real_world.cc
+++ b/src/kudu/benchmarks/tpch/tpch_real_world.cc
@@ -256,7 +256,7 @@ gscoped_ptr<RpcLineItemDAO> TpchRealWorld::GetInittedDAO() {
FLAGS_tpch_test_client_timeout_msec,
split_rows));
dao->Init();
- return dao.Pass();
+ return std::move(dao);
}
void TpchRealWorld::LoadLineItemsThread(int i) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/bloomfile-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/bloomfile-test-base.h b/src/kudu/cfile/bloomfile-test-base.h
index 61385b5..53a6eda 100644
--- a/src/kudu/cfile/bloomfile-test-base.h
+++ b/src/kudu/cfile/bloomfile-test-base.h
@@ -82,7 +82,7 @@ class BloomFileTestBase : public KuduTest {
<< "Invalid parameters: --n_keys isn't set large enough to fill even "
<< "one bloom filter of the requested --bloom_size_bytes";
- BloomFileWriter bfw(sink.Pass(), sizing);
+ BloomFileWriter bfw(std::move(sink), sizing);
ASSERT_OK(bfw.Start());
AppendBlooms(&bfw);
@@ -93,7 +93,7 @@ class BloomFileTestBase : public KuduTest {
gscoped_ptr<ReadableBlock> source;
RETURN_NOT_OK(fs_manager_->OpenBlock(block_id_, &source));
- return BloomFileReader::Open(source.Pass(), ReaderOptions(), &bfr_);
+ return BloomFileReader::Open(std::move(source), ReaderOptions(), &bfr_);
}
uint64_t ReadBenchmark() {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/bloomfile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/bloomfile-test.cc b/src/kudu/cfile/bloomfile-test.cc
index 185a174..693a875 100644
--- a/src/kudu/cfile/bloomfile-test.cc
+++ b/src/kudu/cfile/bloomfile-test.cc
@@ -98,13 +98,13 @@ TEST_F(BloomFileTest, TestLazyInit) {
ASSERT_OK(fs_manager_->OpenBlock(block_id_, &block));
size_t bytes_read = 0;
gscoped_ptr<ReadableBlock> count_block(
- new CountingReadableBlock(block.Pass(), &bytes_read));
+ new CountingReadableBlock(std::move(block), &bytes_read));
// Lazily opening the bloom file should not trigger any reads.
gscoped_ptr<BloomFileReader> reader;
ReaderOptions opts;
opts.parent_mem_tracker = tracker;
- ASSERT_OK(BloomFileReader::OpenNoInit(count_block.Pass(), opts, &reader));
+ ASSERT_OK(BloomFileReader::OpenNoInit(std::move(count_block), opts, &reader));
ASSERT_EQ(0, bytes_read);
int64_t lazy_mem_usage = tracker->consumption();
ASSERT_GT(lazy_mem_usage, initial_mem_usage);
@@ -122,8 +122,8 @@ TEST_F(BloomFileTest, TestLazyInit) {
// same number of bytes read.
ASSERT_OK(fs_manager_->OpenBlock(block_id_, &block));
bytes_read = 0;
- count_block.reset(new CountingReadableBlock(block.Pass(), &bytes_read));
- ASSERT_OK(BloomFileReader::Open(count_block.Pass(), ReaderOptions(), &reader));
+ count_block.reset(new CountingReadableBlock(std::move(block), &bytes_read));
+ ASSERT_OK(BloomFileReader::Open(std::move(count_block), ReaderOptions(), &reader));
ASSERT_EQ(bytes_read_after_init, bytes_read);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/bloomfile.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/bloomfile.cc b/src/kudu/cfile/bloomfile.cc
index f7a9af2..9390de3 100644
--- a/src/kudu/cfile/bloomfile.cc
+++ b/src/kudu/cfile/bloomfile.cc
@@ -54,7 +54,7 @@ BloomFileWriter::BloomFileWriter(gscoped_ptr<WritableBlock> block,
// bloom filters are high-entropy data structures by their nature.
opts.storage_attributes.encoding = PLAIN_ENCODING;
opts.storage_attributes.compression = NO_COMPRESSION;
- writer_.reset(new cfile::CFileWriter(opts, GetTypeInfo(BINARY), false, block.Pass()));
+ writer_.reset(new cfile::CFileWriter(opts, GetTypeInfo(BINARY), false, std::move(block)));
}
Status BloomFileWriter::Start() {
@@ -141,10 +141,10 @@ Status BloomFileReader::Open(gscoped_ptr<ReadableBlock> block,
const ReaderOptions& options,
gscoped_ptr<BloomFileReader> *reader) {
gscoped_ptr<BloomFileReader> bf_reader;
- RETURN_NOT_OK(OpenNoInit(block.Pass(), options, &bf_reader));
+ RETURN_NOT_OK(OpenNoInit(std::move(block), options, &bf_reader));
RETURN_NOT_OK(bf_reader->Init());
- *reader = bf_reader.Pass();
+ *reader = std::move(bf_reader);
return Status::OK();
}
@@ -152,20 +152,20 @@ Status BloomFileReader::OpenNoInit(gscoped_ptr<ReadableBlock> block,
const ReaderOptions& options,
gscoped_ptr<BloomFileReader> *reader) {
gscoped_ptr<CFileReader> cf_reader;
- RETURN_NOT_OK(CFileReader::OpenNoInit(block.Pass(), options, &cf_reader));
+ RETURN_NOT_OK(CFileReader::OpenNoInit(std::move(block), options, &cf_reader));
gscoped_ptr<BloomFileReader> bf_reader(new BloomFileReader(
- cf_reader.Pass(), options));
+ std::move(cf_reader), options));
if (!FLAGS_cfile_lazy_open) {
RETURN_NOT_OK(bf_reader->Init());
}
- *reader = bf_reader.Pass();
+ *reader = std::move(bf_reader);
return Status::OK();
}
BloomFileReader::BloomFileReader(gscoped_ptr<CFileReader> reader,
const ReaderOptions& options)
- : reader_(reader.Pass()),
+ : reader_(std::move(reader)),
mem_consumption_(options.parent_mem_tracker,
memory_footprint_excluding_reader()) {
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/cfile-dump.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile-dump.cc b/src/kudu/cfile/cfile-dump.cc
index ed33d1c..66c700f 100644
--- a/src/kudu/cfile/cfile-dump.cc
+++ b/src/kudu/cfile/cfile-dump.cc
@@ -52,7 +52,7 @@ Status DumpFile(const string& block_id_str) {
RETURN_NOT_OK(fs_manager.OpenBlock(block_id, &block));
gscoped_ptr<CFileReader> reader;
- RETURN_NOT_OK(CFileReader::Open(block.Pass(), ReaderOptions(), &reader));
+ RETURN_NOT_OK(CFileReader::Open(std::move(block), ReaderOptions(), &reader));
if (FLAGS_print_meta) {
cout << "Header:\n" << reader->header().DebugString() << endl;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/cfile-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile-test-base.h b/src/kudu/cfile/cfile-test-base.h
index 5419993..acff8fe 100644
--- a/src/kudu/cfile/cfile-test-base.h
+++ b/src/kudu/cfile/cfile-test-base.h
@@ -336,7 +336,7 @@ class CFileTestBase : public KuduTest {
opts.storage_attributes.encoding = encoding;
opts.storage_attributes.compression = compression;
CFileWriter w(opts, GetTypeInfo(DataGeneratorType::kDataType),
- DataGeneratorType::has_nulls(), sink.Pass());
+ DataGeneratorType::has_nulls(), std::move(sink));
ASSERT_OK(w.Start());
@@ -429,7 +429,7 @@ static void TimeReadFile(FsManager* fs_manager, const BlockId& block_id, size_t
gscoped_ptr<fs::ReadableBlock> source;
ASSERT_OK(fs_manager->OpenBlock(block_id, &source));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(source.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(source), ReaderOptions(), &reader));
gscoped_ptr<CFileIterator> iter;
ASSERT_OK(reader->NewIterator(&iter, CFileReader::CACHE_BLOCK));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/cfile-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile-test.cc b/src/kudu/cfile/cfile-test.cc
index 87a6bef..dcdaf48 100644
--- a/src/kudu/cfile/cfile-test.cc
+++ b/src/kudu/cfile/cfile-test.cc
@@ -67,7 +67,7 @@ class TestCFile : public CFileTestBase {
gscoped_ptr<ReadableBlock> block;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(block.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(block), ReaderOptions(), &reader));
BlockPointer ptr;
@@ -148,7 +148,7 @@ class TestCFile : public CFileTestBase {
gscoped_ptr<ReadableBlock> block;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(block.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(block), ReaderOptions(), &reader));
ASSERT_EQ(DataGeneratorType::kDataType, reader->type_info()->type());
gscoped_ptr<CFileIterator> iter;
@@ -215,7 +215,7 @@ class TestCFile : public CFileTestBase {
opts.write_validx = false;
opts.storage_attributes.cfile_block_size = FLAGS_cfile_test_block_size;
opts.storage_attributes.encoding = PLAIN_ENCODING;
- CFileWriter w(opts, GetTypeInfo(STRING), false, sink.Pass());
+ CFileWriter w(opts, GetTypeInfo(STRING), false, std::move(sink));
ASSERT_OK(w.Start());
for (uint32_t i = 0; i < num_entries; i++) {
vector<Slice> slices;
@@ -231,7 +231,7 @@ class TestCFile : public CFileTestBase {
gscoped_ptr<ReadableBlock> source;
ASSERT_OK(fs_manager_->OpenBlock(id, &source));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(source.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(source), ReaderOptions(), &reader));
gscoped_ptr<IndexTreeIterator> iter;
iter.reset(IndexTreeIterator::Create(reader.get(), reader->posidx_root()));
@@ -482,7 +482,7 @@ void TestCFile::TestReadWriteStrings(EncodingType encoding) {
gscoped_ptr<ReadableBlock> block;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(block.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(block), ReaderOptions(), &reader));
rowid_t reader_nrows;
ASSERT_OK(reader->CountRows(&reader_nrows));
@@ -595,7 +595,7 @@ TEST_P(TestCFileBothCacheTypes, TestMetadata) {
ASSERT_OK(fs_manager_->CreateNewBlock(&sink));
block_id = sink->id();
WriterOptions opts;
- CFileWriter w(opts, GetTypeInfo(INT32), false, sink.Pass());
+ CFileWriter w(opts, GetTypeInfo(INT32), false, std::move(sink));
w.AddMetadataPair("key_in_header", "header value");
ASSERT_OK(w.Start());
@@ -612,7 +612,7 @@ TEST_P(TestCFileBothCacheTypes, TestMetadata) {
gscoped_ptr<ReadableBlock> source;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &source));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(source.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(source), ReaderOptions(), &reader));
string val;
ASSERT_TRUE(reader->GetMetadataEntry("key_in_header", &val));
ASSERT_EQ(val, "header value");
@@ -713,7 +713,7 @@ TEST_P(TestCFileBothCacheTypes, TestReleaseBlock) {
ASSERT_OK(fs_manager_->CreateNewBlock(&sink));
ASSERT_EQ(WritableBlock::CLEAN, sink->state());
WriterOptions opts;
- CFileWriter w(opts, GetTypeInfo(STRING), false, sink.Pass());
+ CFileWriter w(opts, GetTypeInfo(STRING), false, std::move(sink));
ASSERT_OK(w.Start());
fs::ScopedWritableBlockCloser closer;
ASSERT_OK(w.FinishAndReleaseBlock(&closer));
@@ -751,14 +751,14 @@ TEST_P(TestCFileBothCacheTypes, TestLazyInit) {
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
size_t bytes_read = 0;
gscoped_ptr<ReadableBlock> count_block(
- new CountingReadableBlock(block.Pass(), &bytes_read));
+ new CountingReadableBlock(std::move(block), &bytes_read));
ASSERT_EQ(initial_mem_usage, tracker->consumption());
// Lazily opening the cfile should not trigger any reads.
ReaderOptions opts;
opts.parent_mem_tracker = tracker;
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::OpenNoInit(count_block.Pass(), opts, &reader));
+ ASSERT_OK(CFileReader::OpenNoInit(std::move(count_block), opts, &reader));
ASSERT_EQ(0, bytes_read);
int64_t lazy_mem_usage = tracker->consumption();
ASSERT_GT(lazy_mem_usage, initial_mem_usage);
@@ -776,8 +776,8 @@ TEST_P(TestCFileBothCacheTypes, TestLazyInit) {
// same number of bytes read.
ASSERT_OK(fs_manager_->OpenBlock(block_id, &block));
bytes_read = 0;
- count_block.reset(new CountingReadableBlock(block.Pass(), &bytes_read));
- ASSERT_OK(CFileReader::Open(count_block.Pass(), ReaderOptions(), &reader));
+ count_block.reset(new CountingReadableBlock(std::move(block), &bytes_read));
+ ASSERT_OK(CFileReader::Open(std::move(count_block), ReaderOptions(), &reader));
ASSERT_EQ(bytes_read_after_init, bytes_read);
}
@@ -805,7 +805,7 @@ TEST_P(TestCFileBothCacheTypes, TestCacheKeysAreStable) {
gscoped_ptr<ReadableBlock> source;
ASSERT_OK(fs_manager_->OpenBlock(block_id, &source));
gscoped_ptr<CFileReader> reader;
- ASSERT_OK(CFileReader::Open(source.Pass(), ReaderOptions(), &reader));
+ ASSERT_OK(CFileReader::Open(std::move(source), ReaderOptions(), &reader));
gscoped_ptr<IndexTreeIterator> iter;
iter.reset(IndexTreeIterator::Create(reader.get(), reader->posidx_root()));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/cfile_reader.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile_reader.cc b/src/kudu/cfile/cfile_reader.cc
index ebb107f..f2d8597 100644
--- a/src/kudu/cfile/cfile_reader.cc
+++ b/src/kudu/cfile/cfile_reader.cc
@@ -79,7 +79,7 @@ static Status ParseMagicAndLength(const Slice &data,
CFileReader::CFileReader(const ReaderOptions &options,
const uint64_t file_size,
gscoped_ptr<ReadableBlock> block) :
- block_(block.Pass()),
+ block_(std::move(block)),
file_size_(file_size),
mem_consumption_(options.parent_mem_tracker, memory_footprint()) {
}
@@ -88,7 +88,7 @@ Status CFileReader::Open(gscoped_ptr<ReadableBlock> block,
const ReaderOptions& options,
gscoped_ptr<CFileReader> *reader) {
gscoped_ptr<CFileReader> reader_local;
- RETURN_NOT_OK(OpenNoInit(block.Pass(), options, &reader_local));
+ RETURN_NOT_OK(OpenNoInit(std::move(block), options, &reader_local));
RETURN_NOT_OK(reader_local->Init());
reader->reset(reader_local.release());
@@ -101,7 +101,7 @@ Status CFileReader::OpenNoInit(gscoped_ptr<ReadableBlock> block,
uint64_t block_size;
RETURN_NOT_OK(block->Size(&block_size));
gscoped_ptr<CFileReader> reader_local(
- new CFileReader(options, block_size, block.Pass()));
+ new CFileReader(options, block_size, std::move(block)));
if (!FLAGS_cfile_lazy_open) {
RETURN_NOT_OK(reader_local->Init());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/cfile/cfile_writer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/cfile/cfile_writer.cc b/src/kudu/cfile/cfile_writer.cc
index db71e3c..8ceb97b 100644
--- a/src/kudu/cfile/cfile_writer.cc
+++ b/src/kudu/cfile/cfile_writer.cc
@@ -89,7 +89,7 @@ CFileWriter::CFileWriter(const WriterOptions &options,
const TypeInfo* typeinfo,
bool is_nullable,
gscoped_ptr<WritableBlock> block)
- : block_(block.Pass()),
+ : block_(std::move(block)),
off_(0),
value_count_(0),
options_(options),
@@ -243,11 +243,11 @@ Status CFileWriter::FinishAndReleaseBlock(ScopedWritableBlockCloser* closer) {
// Done with this block.
if (FLAGS_cfile_do_on_finish == "flush") {
RETURN_NOT_OK(block_->FlushDataAsync());
- closer->AddBlock(block_.Pass());
+ closer->AddBlock(std::move(block_));
} else if (FLAGS_cfile_do_on_finish == "close") {
RETURN_NOT_OK(block_->Close());
} else if (FLAGS_cfile_do_on_finish == "nothing") {
- closer->AddBlock(block_.Pass());
+ closer->AddBlock(std::move(block_));
} else {
LOG(FATAL) << "Unknown value for cfile_do_on_finish: "
<< FLAGS_cfile_do_on_finish;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/client/batcher.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/batcher.cc b/src/kudu/client/batcher.cc
index 2b3e583..f418bad 100644
--- a/src/kudu/client/batcher.cc
+++ b/src/kudu/client/batcher.cc
@@ -705,7 +705,7 @@ void Batcher::MarkInFlightOpFailedUnlocked(InFlightOp* op, const Status& s) {
CHECK_EQ(1, ops_.erase(op))
<< "Could not remove op " << op->ToString() << " from in-flight list";
gscoped_ptr<KuduError> error(new KuduError(op->write_op.release(), s));
- error_collector_->AddError(error.Pass());
+ error_collector_->AddError(std::move(error));
had_errors_ = true;
delete op;
}
@@ -844,7 +844,7 @@ void Batcher::ProcessWriteResponse(const WriteRpc& rpc,
// Mark each of the rows in the write op as failed, since the whole RPC failed.
for (InFlightOp* op : rpc.ops()) {
gscoped_ptr<KuduError> error(new KuduError(op->write_op.release(), s));
- error_collector_->AddError(error.Pass());
+ error_collector_->AddError(std::move(error));
}
MarkHadErrors();
@@ -874,12 +874,12 @@ void Batcher::ProcessWriteResponse(const WriteRpc& rpc,
<< rpc.resp().DebugString();
continue;
}
- gscoped_ptr<KuduWriteOperation> op = rpc.ops()[err_pb.row_index()]->write_op.Pass();
+ gscoped_ptr<KuduWriteOperation> op = std::move(rpc.ops()[err_pb.row_index()]->write_op);
VLOG(1) << "Error on op " << op->ToString() << ": "
<< err_pb.error().ShortDebugString();
Status op_status = StatusFromPB(err_pb.error());
gscoped_ptr<KuduError> error(new KuduError(op.release(), op_status));
- error_collector_->AddError(error.Pass());
+ error_collector_->AddError(std::move(error));
MarkHadErrors();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/client/client-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index 15d4266..df475b1 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -227,7 +227,7 @@ class ClientTest : public KuduTest {
CHECK_OK(row->SetInt32(1, index * 2));
CHECK_OK(row->SetStringCopy(2, Slice(StringPrintf("hello %d", index))));
CHECK_OK(row->SetInt32(3, index * 3));
- return insert.Pass();
+ return std::move(insert);
}
gscoped_ptr<KuduUpdate> UpdateTestRow(KuduTable* table, int index) {
@@ -236,14 +236,14 @@ class ClientTest : public KuduTest {
CHECK_OK(row->SetInt32(0, index));
CHECK_OK(row->SetInt32(1, index * 2 + 1));
CHECK_OK(row->SetStringCopy(2, Slice(StringPrintf("hello again %d", index))));
- return update.Pass();
+ return std::move(update);
}
gscoped_ptr<KuduDelete> DeleteTestRow(KuduTable* table, int index) {
gscoped_ptr<KuduDelete> del(table->NewDelete());
KuduPartialRow* row = del->mutable_row();
CHECK_OK(row->SetInt32(0, index));
- return del.Pass();
+ return std::move(del);
}
void DoTestScanWithoutPredicates() {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/client/error-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/error-internal.cc b/src/kudu/client/error-internal.cc
index 959d2e0..78a62c9 100644
--- a/src/kudu/client/error-internal.cc
+++ b/src/kudu/client/error-internal.cc
@@ -23,7 +23,7 @@ namespace client {
KuduError::Data::Data(gscoped_ptr<KuduWriteOperation> failed_op,
const Status& status) :
- failed_op_(failed_op.Pass()),
+ failed_op_(std::move(failed_op)),
status_(status) {
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 252246b..4a45634 100644
--- a/src/kudu/consensus/consensus-test-util.h
+++ b/src/kudu/consensus/consensus-test-util.h
@@ -67,7 +67,7 @@ static gscoped_ptr<ReplicateMsg> CreateDummyReplicate(int term,
msg->set_op_type(NO_OP);
msg->mutable_noop_request()->mutable_payload_for_tests()->resize(payload_size);
msg->set_timestamp(timestamp.ToUint64());
- return msg.Pass();
+ return std::move(msg);
}
// Returns RaftPeerPB with given UUID and obviously-fake hostname / port combo.
@@ -618,7 +618,7 @@ class TestDriver {
gscoped_ptr<CommitMsg> msg(new CommitMsg);
msg->set_op_type(round_->replicate_msg()->op_type());
msg->mutable_commited_op_id()->CopyFrom(round_->id());
- CHECK_OK(log_->AsyncAppendCommit(msg.Pass(),
+ CHECK_OK(log_->AsyncAppendCommit(std::move(msg),
Bind(&TestDriver::CommitCallback, Unretained(this))));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus.cc b/src/kudu/consensus/consensus.cc
index 886367e..04abe98 100644
--- a/src/kudu/consensus/consensus.cc
+++ b/src/kudu/consensus/consensus.cc
@@ -74,7 +74,7 @@ Status ConsensusRound::CheckBoundTerm(int64_t current_term) const {
scoped_refptr<ConsensusRound> Consensus::NewRound(
gscoped_ptr<ReplicateMsg> replicate_msg,
const ConsensusReplicatedCallback& replicated_cb) {
- return make_scoped_refptr(new ConsensusRound(this, replicate_msg.Pass(), replicated_cb));
+ return make_scoped_refptr(new ConsensusRound(this, std::move(replicate_msg), replicated_cb));
}
void Consensus::SetFaultHooks(const shared_ptr<ConsensusFaultHooks>& hooks) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/consensus_peers-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers-test.cc b/src/kudu/consensus/consensus_peers-test.cc
index 7e5d536..116ddea 100644
--- a/src/kudu/consensus/consensus_peers-test.cc
+++ b/src/kudu/consensus/consensus_peers-test.cc
@@ -91,7 +91,7 @@ class ConsensusPeersTest : public KuduTest {
kLeaderUuid,
message_queue_.get(),
pool_.get(),
- proxy.Pass(),
+ std::move(proxy),
peer));
return proxy_ptr;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/consensus_peers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index 37e8cb8..2d49939 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -84,7 +84,7 @@ Status Peer::NewRemotePeer(const RaftPeerPB& peer_pb,
gscoped_ptr<Peer> new_peer(new Peer(peer_pb,
tablet_id,
leader_uuid,
- proxy.Pass(),
+ std::move(proxy),
queue,
thread_pool));
RETURN_NOT_OK(new_peer->Init());
@@ -98,7 +98,7 @@ Peer::Peer(const RaftPeerPB& peer_pb, string tablet_id, string leader_uuid,
: tablet_id_(std::move(tablet_id)),
leader_uuid_(std::move(leader_uuid)),
peer_pb_(peer_pb),
- proxy_(proxy.Pass()),
+ proxy_(std::move(proxy)),
queue_(queue),
failed_attempts_(0),
sem_(1),
@@ -357,8 +357,8 @@ Peer::~Peer() {
RpcPeerProxy::RpcPeerProxy(gscoped_ptr<HostPort> hostport,
gscoped_ptr<ConsensusServiceProxy> consensus_proxy)
- : hostport_(hostport.Pass()),
- consensus_proxy_(consensus_proxy.Pass()) {
+ : hostport_(std::move(hostport)),
+ consensus_proxy_(std::move(consensus_proxy)) {
}
void RpcPeerProxy::UpdateAsync(const ConsensusRequestPB* request,
@@ -412,7 +412,7 @@ Status RpcPeerProxyFactory::NewProxy(const RaftPeerPB& peer_pb,
RETURN_NOT_OK(HostPortFromPB(peer_pb.last_known_addr(), hostport.get()));
gscoped_ptr<ConsensusServiceProxy> new_proxy;
RETURN_NOT_OK(CreateConsensusServiceProxyForHost(messenger_, *hostport, &new_proxy));
- proxy->reset(new RpcPeerProxy(hostport.Pass(), new_proxy.Pass()));
+ proxy->reset(new RpcPeerProxy(std::move(hostport), std::move(new_proxy)));
return Status::OK();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 cc2f568..93fa89f 100644
--- a/src/kudu/consensus/leader_election-test.cc
+++ b/src/kudu/consensus/leader_election-test.cc
@@ -161,7 +161,7 @@ gscoped_ptr<VoteCounter> LeaderElectionTest::InitVoteCounter(int num_voters, int
bool duplicate;
CHECK_OK(counter->RegisterVote(candidate_uuid_, VOTE_GRANTED, &duplicate));
CHECK(!duplicate);
- return counter.Pass();
+ return std::move(counter);
}
scoped_refptr<LeaderElection> LeaderElectionTest::SetUpElectionWithHighTermVoter(
@@ -196,7 +196,7 @@ scoped_refptr<LeaderElection> LeaderElectionTest::SetUpElectionWithHighTermVoter
request.set_tablet_id(tablet_id_);
scoped_refptr<LeaderElection> election(
- new LeaderElection(config_, proxy_factory_.get(), request, counter.Pass(),
+ new LeaderElection(config_, proxy_factory_.get(), request, std::move(counter),
MonoDelta::FromSeconds(kLeaderElectionTimeoutSecs),
Bind(&LeaderElectionTest::ElectionCallback,
Unretained(this))));
@@ -252,7 +252,7 @@ scoped_refptr<LeaderElection> LeaderElectionTest::SetUpElectionWithGrantDenyErro
request.set_tablet_id(tablet_id_);
scoped_refptr<LeaderElection> election(
- new LeaderElection(config_, proxy_factory_.get(), request, counter.Pass(),
+ new LeaderElection(config_, proxy_factory_.get(), request, std::move(counter),
MonoDelta::FromSeconds(kLeaderElectionTimeoutSecs),
Bind(&LeaderElectionTest::ElectionCallback,
Unretained(this))));
@@ -278,7 +278,7 @@ TEST_F(LeaderElectionTest, TestPerfectElection) {
request.set_tablet_id(tablet_id_);
scoped_refptr<LeaderElection> election(
- new LeaderElection(config_, proxy_factory_.get(), request, counter.Pass(),
+ new LeaderElection(config_, proxy_factory_.get(), request, std::move(counter),
MonoDelta::FromSeconds(kLeaderElectionTimeoutSecs),
Bind(&LeaderElectionTest::ElectionCallback,
Unretained(this))));
@@ -407,7 +407,7 @@ TEST_F(LeaderElectionTest, TestFailToCreateProxy) {
gscoped_ptr<VoteCounter> counter = InitVoteCounter(kNumVoters, kMajoritySize);
scoped_refptr<LeaderElection> election(
- new LeaderElection(config_, proxy_factory_.get(), request, counter.Pass(),
+ new LeaderElection(config_, proxy_factory_.get(), request, std::move(counter),
MonoDelta::FromSeconds(kLeaderElectionTimeoutSecs),
Bind(&LeaderElectionTest::ElectionCallback,
Unretained(this))));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/leader_election.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/leader_election.cc b/src/kudu/consensus/leader_election.cc
index 2c4066d..0133c04 100644
--- a/src/kudu/consensus/leader_election.cc
+++ b/src/kudu/consensus/leader_election.cc
@@ -158,7 +158,7 @@ LeaderElection::LeaderElection(const RaftConfigPB& config,
ElectionDecisionCallback decision_callback)
: has_responded_(false),
request_(request),
- vote_counter_(vote_counter.Pass()),
+ vote_counter_(std::move(vote_counter)),
timeout_(std::move(timeout)),
decision_callback_(std::move(decision_callback)) {
for (const RaftPeerPB& peer : config.peers()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/local_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/local_consensus.cc b/src/kudu/consensus/local_consensus.cc
index 9154032..e6d7b7d 100644
--- a/src/kudu/consensus/local_consensus.cc
+++ b/src/kudu/consensus/local_consensus.cc
@@ -44,7 +44,7 @@ LocalConsensus::LocalConsensus(ConsensusOptions options,
ReplicaTransactionFactory* txn_factory, Log* log)
: peer_uuid_(std::move(peer_uuid)),
options_(std::move(options)),
- cmeta_(cmeta.Pass()),
+ cmeta_(std::move(cmeta)),
txn_factory_(DCHECK_NOTNULL(txn_factory)),
log_(DCHECK_NOTNULL(log)),
clock_(clock),
@@ -127,7 +127,7 @@ Status LocalConsensus::Replicate(const scoped_refptr<ConsensusRound>& round) {
gscoped_ptr<log::LogEntryBatchPB> entry_batch;
log::CreateBatchFromAllocatedOperations({ round->replicate_scoped_refptr() }, &entry_batch);
- RETURN_NOT_OK(log_->Reserve(log::REPLICATE, entry_batch.Pass(),
+ RETURN_NOT_OK(log_->Reserve(log::REPLICATE, std::move(entry_batch),
&reserved_entry_batch));
// Local consensus transactions are always committed so we
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 080811d..89c5ddf 100644
--- a/src/kudu/consensus/log-test-base.h
+++ b/src/kudu/consensus/log-test-base.h
@@ -264,16 +264,16 @@ class LogTestBase : public KuduTest {
MemStoreTargetPB* target = mutate->add_mutated_stores();
target->set_dms_id(dms_id);
target->set_rs_id(rs_id);
- AppendCommit(commit.Pass(), sync);
+ AppendCommit(std::move(commit), sync);
}
void AppendCommit(gscoped_ptr<CommitMsg> commit, bool sync = APPEND_SYNC) {
if (sync) {
Synchronizer s;
- ASSERT_OK(log_->AsyncAppendCommit(commit.Pass(), s.AsStatusCallback()));
+ ASSERT_OK(log_->AsyncAppendCommit(std::move(commit), s.AsStatusCallback()));
ASSERT_OK(s.Wait());
} else {
- ASSERT_OK(log_->AsyncAppendCommit(commit.Pass(),
+ ASSERT_OK(log_->AsyncAppendCommit(std::move(commit),
Bind(&LogTestBase::CheckCommitResult)));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/log-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log-test.cc b/src/kudu/consensus/log-test.cc
index 1d4313d..1442afb 100644
--- a/src/kudu/consensus/log-test.cc
+++ b/src/kudu/consensus/log-test.cc
@@ -885,7 +885,7 @@ void LogTest::AppendTestSequence(const vector<TestLogSequenceElem>& seq) {
commit->set_op_type(NO_OP);
commit->mutable_commited_op_id()->CopyFrom(e.id);
Synchronizer s;
- ASSERT_OK(log_->AsyncAppendCommit(commit.Pass(), s.AsStatusCallback()));
+ ASSERT_OK(log_->AsyncAppendCommit(std::move(commit), s.AsStatusCallback()));
ASSERT_OK(s.Wait());
}
case TestLogSequenceElem::ROLL:
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/log.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log.cc b/src/kudu/consensus/log.cc
index 05abfd8..83572e1 100644
--- a/src/kudu/consensus/log.cc
+++ b/src/kudu/consensus/log.cc
@@ -402,7 +402,8 @@ Status Log::Reserve(LogEntryTypePB type,
#endif
int num_ops = entry_batch->entry_size();
- gscoped_ptr<LogEntryBatch> new_entry_batch(new LogEntryBatch(type, entry_batch.Pass(), num_ops));
+ gscoped_ptr<LogEntryBatch> new_entry_batch(new LogEntryBatch(
+ type, std::move(entry_batch), num_ops));
new_entry_batch->MarkReserved();
if (PREDICT_FALSE(!entry_batch_queue_.BlockingPut(new_entry_batch.get()))) {
@@ -440,7 +441,7 @@ Status Log::AsyncAppendReplicates(const vector<ReplicateRefPtr>& msgs,
CreateBatchFromAllocatedOperations(msgs, &batch);
LogEntryBatch* reserved_entry_batch;
- RETURN_NOT_OK(Reserve(REPLICATE, batch.Pass(), &reserved_entry_batch));
+ RETURN_NOT_OK(Reserve(REPLICATE, std::move(batch), &reserved_entry_batch));
// If we're able to reserve set the vector of replicate scoped ptrs in
// the LogEntryBatch. This will make sure there's a reference for each
// replicate while we're appending.
@@ -460,7 +461,7 @@ Status Log::AsyncAppendCommit(gscoped_ptr<consensus::CommitMsg> commit_msg,
entry->set_allocated_commit(commit_msg.release());
LogEntryBatch* reserved_entry_batch;
- RETURN_NOT_OK(Reserve(COMMIT, batch.Pass(), &reserved_entry_batch));
+ RETURN_NOT_OK(Reserve(COMMIT, std::move(batch), &reserved_entry_batch));
RETURN_NOT_OK(AsyncAppend(reserved_entry_batch, callback));
return Status::OK();
@@ -670,7 +671,7 @@ Status Log::GetSegmentsToGCUnlocked(int64_t min_op_idx, SegmentSequence* segment
Status Log::Append(LogEntryPB* phys_entry) {
gscoped_ptr<LogEntryBatchPB> entry_batch_pb(new LogEntryBatchPB);
entry_batch_pb->mutable_entry()->AddAllocated(phys_entry);
- LogEntryBatch entry_batch(phys_entry->type(), entry_batch_pb.Pass(), 1);
+ LogEntryBatch entry_batch(phys_entry->type(), std::move(entry_batch_pb), 1);
entry_batch.state_ = LogEntryBatch::kEntryReserved;
Status s = entry_batch.Serialize();
if (s.ok()) {
@@ -690,7 +691,7 @@ Status Log::WaitUntilAllFlushed() {
gscoped_ptr<LogEntryBatchPB> entry_batch(new LogEntryBatchPB);
entry_batch->add_entry()->set_type(log::FLUSH_MARKER);
LogEntryBatch* reserved_entry_batch;
- RETURN_NOT_OK(Reserve(FLUSH_MARKER, entry_batch.Pass(), &reserved_entry_batch));
+ RETURN_NOT_OK(Reserve(FLUSH_MARKER, std::move(entry_batch), &reserved_entry_batch));
Synchronizer s;
RETURN_NOT_OK(AsyncAppend(reserved_entry_batch, s.AsStatusCallback()));
return s.Wait();
@@ -969,7 +970,7 @@ Log::~Log() {
LogEntryBatch::LogEntryBatch(LogEntryTypePB type,
gscoped_ptr<LogEntryBatchPB> entry_batch_pb, size_t count)
: type_(type),
- entry_batch_pb_(entry_batch_pb.Pass()),
+ entry_batch_pb_(std::move(entry_batch_pb)),
total_size_bytes_(
PREDICT_FALSE(count == 1 && entry_batch_pb_->entry(0).type() == FLUSH_MARKER) ?
0 : entry_batch_pb_->ByteSize()),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 1b08c4d..f1532c8 100644
--- a/src/kudu/consensus/mt-log-test.cc
+++ b/src/kudu/consensus/mt-log-test.cc
@@ -116,7 +116,7 @@ class MultiThreadedLogTest : public LogTestBase {
CreateBatchFromAllocatedOperations(batch_replicates,
&entry_batch_pb);
- ASSERT_OK(log_->Reserve(REPLICATE, entry_batch_pb.Pass(), &entry_batch));
+ ASSERT_OK(log_->Reserve(REPLICATE, std::move(entry_batch_pb), &entry_batch));
} // lock_guard scope
auto cb = new CustomLatchCallback(&latch, &errors);
entry_batch->SetReplicates(batch_replicates);
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/peer_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/peer_manager.cc b/src/kudu/consensus/peer_manager.cc
index 8c9174d..4acbac7 100644
--- a/src/kudu/consensus/peer_manager.cc
+++ b/src/kudu/consensus/peer_manager.cc
@@ -76,7 +76,7 @@ Status PeerManager::UpdateRaftConfig(const RaftConfigPB& config) {
local_uuid_,
queue_,
thread_pool_,
- peer_proxy.Pass(),
+ std::move(peer_proxy),
&remote_peer));
InsertOrDie(&peers_, peer_pb.permanent_uuid(), remote_peer.release());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 76e19ad..e874d5d 100644
--- a/src/kudu/consensus/raft_consensus-test.cc
+++ b/src/kudu/consensus/raft_consensus-test.cc
@@ -114,11 +114,11 @@ class RaftConsensusSpy : public RaftConsensus {
const shared_ptr<MemTracker>& parent_mem_tracker,
const Callback<void(const std::string& reason)>& mark_dirty_clbk)
: RaftConsensus(options,
- cmeta.Pass(),
- proxy_factory.Pass(),
- queue.Pass(),
- peer_manager.Pass(),
- thread_pool.Pass(),
+ std::move(cmeta),
+ std::move(proxy_factory),
+ std::move(queue),
+ std::move(peer_manager),
+ std::move(thread_pool),
metric_entity,
peer_uuid,
clock,
@@ -213,11 +213,11 @@ class RaftConsensusTest : public KuduTest {
CHECK_OK(ThreadPoolBuilder("raft-pool") .Build(&thread_pool));
consensus_.reset(new RaftConsensusSpy(options_,
- cmeta.Pass(),
- proxy_factory.Pass(),
+ std::move(cmeta),
+ std::move(proxy_factory),
gscoped_ptr<PeerMessageQueue>(queue_),
gscoped_ptr<PeerManager>(peer_manager_),
- thread_pool.Pass(),
+ std::move(thread_pool),
metric_entity_,
peer_uuid,
clock_,
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/consensus/raft_consensus.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 6e15c84..473d91e 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -187,11 +187,11 @@ scoped_refptr<RaftConsensus> RaftConsensus::Create(
return make_scoped_refptr(new RaftConsensus(
options,
- cmeta.Pass(),
- rpc_factory.Pass(),
- queue.Pass(),
- peer_manager.Pass(),
- thread_pool.Pass(),
+ std::move(cmeta),
+ std::move(rpc_factory),
+ std::move(queue),
+ std::move(peer_manager),
+ std::move(thread_pool),
metric_entity,
peer_uuid,
clock,
@@ -211,12 +211,12 @@ RaftConsensus::RaftConsensus(
ReplicaTransactionFactory* txn_factory, const scoped_refptr<log::Log>& log,
shared_ptr<MemTracker> parent_mem_tracker,
Callback<void(const std::string& reason)> mark_dirty_clbk)
- : thread_pool_(thread_pool.Pass()),
+ : thread_pool_(std::move(thread_pool)),
log_(log),
clock_(clock),
- peer_proxy_factory_(proxy_factory.Pass()),
- peer_manager_(peer_manager.Pass()),
- queue_(queue.Pass()),
+ peer_proxy_factory_(std::move(proxy_factory)),
+ peer_manager_(std::move(peer_manager)),
+ queue_(std::move(queue)),
rng_(GetRandomSeed32()),
failure_monitor_(GetRandomSeed32(), GetFailureMonitorCheckMeanMs(),
GetFailureMonitorCheckStddevMs()),
@@ -234,7 +234,7 @@ RaftConsensus::RaftConsensus(
DCHECK_NOTNULL(log_.get());
state_.reset(new ReplicaState(options,
peer_uuid,
- cmeta.Pass(),
+ std::move(cmeta),
DCHECK_NOTNULL(txn_factory)));
}
@@ -401,7 +401,7 @@ Status RaftConsensus::StartElection(ElectionMode mode) {
election.reset(new LeaderElection(active_config,
peer_proxy_factory_.get(),
- request, counter.Pass(), timeout,
+ request, std::move(counter), timeout,
Bind(&RaftConsensus::ElectionCallback, this)));
}
@@ -1885,7 +1885,7 @@ void RaftConsensus::NonTxRoundReplicationFinished(ConsensusRound* round,
commit_msg->set_op_type(round->replicate_msg()->op_type());
*commit_msg->mutable_commited_op_id() = round->id();
- WARN_NOT_OK(log_->AsyncAppendCommit(commit_msg.Pass(), Bind(&DoNothingStatusCB)),
+ WARN_NOT_OK(log_->AsyncAppendCommit(std::move(commit_msg), Bind(&DoNothingStatusCB)),
"Unable to append commit message");
client_cb.Run(status);
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 1e63861..edc66fa 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -172,11 +172,11 @@ class RaftConsensusQuorumTest : public KuduTest {
scoped_refptr<RaftConsensus> peer(
new RaftConsensus(options_,
- cmeta.Pass(),
+ std::move(cmeta),
gscoped_ptr<PeerProxyFactory>(proxy_factory).Pass(),
- queue.Pass(),
- peer_manager.Pass(),
- thread_pool.Pass(),
+ std::move(queue),
+ std::move(peer_manager),
+ std::move(thread_pool),
metric_entity_,
config_.peers(i).permanent_uuid(),
clock_,
@@ -247,7 +247,7 @@ class RaftConsensusQuorumTest : public KuduTest {
// Use a latch in place of a Transaction callback.
gscoped_ptr<Synchronizer> sync(new Synchronizer());
- *round = peer->NewRound(msg.Pass(), sync->AsStatusCallback());
+ *round = peer->NewRound(std::move(msg), sync->AsStatusCallback());
InsertOrDie(&syncs_, round->get(), sync.release());
RETURN_NOT_OK_PREPEND(peer->Replicate(round->get()),
Substitute("Unable to replicate to peer $0", peer_idx));
@@ -272,7 +272,7 @@ class RaftConsensusQuorumTest : public KuduTest {
gscoped_ptr<CommitMsg> msg(new CommitMsg());
msg->set_op_type(NO_OP);
msg->mutable_commited_op_id()->CopyFrom(round->id());
- CHECK_OK(logs_[peer_idx]->AsyncAppendCommit(msg.Pass(), commit_callback));
+ CHECK_OK(logs_[peer_idx]->AsyncAppendCommit(std::move(msg), commit_callback));
return Status::OK();
}
@@ -533,7 +533,7 @@ class RaftConsensusQuorumTest : public KuduTest {
string peer_uuid = Substitute("peer-$0", peer_index);
gscoped_ptr<ConsensusMetadata> cmeta;
CHECK_OK(ConsensusMetadata::Load(fs_managers_[peer_index], kTestTablet, peer_uuid, &cmeta));
- return cmeta.Pass();
+ return std::move(cmeta);
}
// Assert that the durable term == term and that the peer that got the vote == voted_for.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 31a3215..9cc68ae 100644
--- a/src/kudu/consensus/raft_consensus_state-test.cc
+++ b/src/kudu/consensus/raft_consensus_state-test.cc
@@ -54,7 +54,7 @@ class RaftConsensusStateTest : public KuduTest {
gscoped_ptr<ConsensusMetadata> cmeta;
ASSERT_OK(ConsensusMetadata::Create(&fs_manager_, kTabletId, fs_manager_.uuid(),
config_, kMinimumTerm, &cmeta));
- state_.reset(new ReplicaState(ConsensusOptions(), fs_manager_.uuid(), cmeta.Pass(),
+ state_.reset(new ReplicaState(ConsensusOptions(), fs_manager_.uuid(), std::move(cmeta),
txn_factory_.get()));
// Start up the ReplicaState.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 6a2c34e..e9f907e 100644
--- a/src/kudu/consensus/raft_consensus_state.cc
+++ b/src/kudu/consensus/raft_consensus_state.cc
@@ -45,7 +45,7 @@ ReplicaState::ReplicaState(ConsensusOptions options, string peer_uuid,
ReplicaTransactionFactory* txn_factory)
: options_(std::move(options)),
peer_uuid_(std::move(peer_uuid)),
- cmeta_(cmeta.Pass()),
+ cmeta_(std::move(cmeta)),
next_index_(0),
txn_factory_(txn_factory),
last_received_op_id_(MinimumOpId()),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 6f3d0a4..d206515 100644
--- a/src/kudu/fs/block_manager-test.cc
+++ b/src/kudu/fs/block_manager-test.cc
@@ -161,7 +161,7 @@ void BlockManagerTest<LogBlockManager>::RunMultipathTest(const vector<string>& p
gscoped_ptr<WritableBlock> block;
ASSERT_OK(bm_->CreateBlock(&block));
ASSERT_OK(block->Append(kTestData));
- closer.AddBlock(block.Pass());
+ closer.AddBlock(std::move(block));
}
ASSERT_OK(closer.CloseBlocks());
}
@@ -237,7 +237,7 @@ void BlockManagerTest<LogBlockManager>::RunLogMetricsTest() {
data[i] = rand.Next();
}
b->Append(Slice(data, sizeof(data)));
- closer.AddBlock(b.Pass());
+ closer.AddBlock(std::move(b));
}
ASSERT_NO_FATAL_FAILURE(CheckLogMetrics(entity, 0, 1, 10, 0));
@@ -709,7 +709,7 @@ TEST_F(LogBlockManagerTest, TestReuseBlockIds) {
gscoped_ptr<WritableBlock> writer;
ASSERT_OK(bm_->CreateBlock(&writer));
block_ids.push_back(writer->id());
- closer.AddBlock(writer.Pass());
+ closer.AddBlock(std::move(writer));
}
ASSERT_OK(closer.CloseBlocks());
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 cc68380..e5144e8 100644
--- a/src/kudu/fs/block_manager_util-test.cc
+++ b/src/kudu/fs/block_manager_util-test.cc
@@ -113,7 +113,7 @@ static void RunCheckIntegrityTest(Env* env,
metadata->set_block_manager_type("asdf");
metadata->set_filesystem_block_size_bytes(1);
metadata->mutable_path_set()->CopyFrom(ps);
- instance->SetMetadataForTests(metadata.Pass());
+ instance->SetMetadataForTests(std::move(metadata));
instances.push_back(instance.release());
i++;
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/fs/block_manager_util.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/block_manager_util.h b/src/kudu/fs/block_manager_util.h
index e1136b7..099a23c 100644
--- a/src/kudu/fs/block_manager_util.h
+++ b/src/kudu/fs/block_manager_util.h
@@ -68,7 +68,7 @@ class PathInstanceMetadataFile {
Status Unlock();
void SetMetadataForTests(gscoped_ptr<PathInstanceMetadataPB> metadata) {
- metadata_ = metadata.Pass();
+ metadata_ = std::move(metadata);
}
std::string path() const { return DirName(filename_); }
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/fs/fs-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/fs/fs-test-util.h b/src/kudu/fs/fs-test-util.h
index 15c702c..e3bf626 100644
--- a/src/kudu/fs/fs-test-util.h
+++ b/src/kudu/fs/fs-test-util.h
@@ -35,7 +35,7 @@ namespace fs {
// gscoped_ptr<ReadableBlock> block;
// fs_manager->OpenBlock("some block id", &block);
// size_t bytes_read = 0;
-// gscoped_ptr<ReadableBlock> tr_block(new CountingReadableBlock(block.Pass(), &bytes_read));
+// gscoped_ptr<ReadableBlock> tr_block(new CountingReadableBlock(std::move(block), &bytes_read));
// tr_block->Read(0, 100, ...);
// tr_block->Read(0, 200, ...);
// ASSERT_EQ(300, bytes_read);
@@ -43,7 +43,7 @@ namespace fs {
class CountingReadableBlock : public ReadableBlock {
public:
CountingReadableBlock(gscoped_ptr<ReadableBlock> block, size_t* bytes_read)
- : block_(block.Pass()),
+ : block_(std::move(block)),
bytes_read_(bytes_read) {
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 3f48aa2..e207793 100644
--- a/src/kudu/fs/log_block_manager.cc
+++ b/src/kudu/fs/log_block_manager.cc
@@ -314,8 +314,8 @@ LogBlockContainer::LogBlockContainer(
gscoped_ptr<RWFile> data_file)
: block_manager_(block_manager),
path_(std::move(path)),
- metadata_pb_writer_(metadata_writer.Pass()),
- data_file_(data_file.Pass()),
+ metadata_pb_writer_(std::move(metadata_writer)),
+ data_file_(std::move(data_file)),
total_bytes_written_(0),
metrics_(block_manager->metrics()),
instance_(instance) {}
@@ -359,13 +359,13 @@ Status LogBlockContainer::Create(LogBlockManager* block_manager,
data_status.IsAlreadyPresent()));
if (metadata_status.ok() && data_status.ok()) {
gscoped_ptr<WritablePBContainerFile> metadata_pb_writer(
- new WritablePBContainerFile(metadata_writer.Pass()));
+ new WritablePBContainerFile(std::move(metadata_writer)));
RETURN_NOT_OK(metadata_pb_writer->Init(BlockRecordPB()));
container->reset(new LogBlockContainer(block_manager,
instance,
common_path,
- metadata_pb_writer.Pass(),
- data_file.Pass()));
+ std::move(metadata_pb_writer),
+ std::move(data_file)));
VLOG(1) << "Created log block container " << (*container)->ToString();
}
@@ -389,7 +389,7 @@ Status LogBlockContainer::Open(LogBlockManager* block_manager,
metadata_path,
&metadata_writer));
gscoped_ptr<WritablePBContainerFile> metadata_pb_writer(
- new WritablePBContainerFile(metadata_writer.Pass()));
+ new WritablePBContainerFile(std::move(metadata_writer)));
// No call to metadata_pb_writer->Init() because we're reopening an
// existing pb container (that should already have a valid header).
@@ -405,8 +405,8 @@ Status LogBlockContainer::Open(LogBlockManager* block_manager,
gscoped_ptr<LogBlockContainer> open_container(new LogBlockContainer(block_manager,
instance,
common_path,
- metadata_pb_writer.Pass(),
- data_file.Pass()));
+ std::move(metadata_pb_writer),
+ std::move(data_file)));
VLOG(1) << "Opened log block container " << open_container->ToString();
container->reset(open_container.release());
return Status::OK();
@@ -416,7 +416,7 @@ Status LogBlockContainer::ReadContainerRecords(deque<BlockRecordPB>* records) co
string metadata_path = StrCat(path_, kMetadataFileSuffix);
gscoped_ptr<RandomAccessFile> metadata_reader;
RETURN_NOT_OK(block_manager()->env()->NewRandomAccessFile(metadata_path, &metadata_reader));
- ReadablePBContainerFile pb_reader(metadata_reader.Pass());
+ ReadablePBContainerFile pb_reader(std::move(metadata_reader));
RETURN_NOT_OK(pb_reader.Init());
uint64_t data_file_size;
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/gutil/gscoped_ptr.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/gscoped_ptr.h b/src/kudu/gutil/gscoped_ptr.h
index cda7349..eee1ec7 100644
--- a/src/kudu/gutil/gscoped_ptr.h
+++ b/src/kudu/gutil/gscoped_ptr.h
@@ -50,15 +50,15 @@
// return gscoped_ptr<Foo>(new Foo("new"));
// }
// gscoped_ptr<Foo> PassThru(gscoped_ptr<Foo> arg) {
-// return arg.Pass();
+// return std::move(arg);
// }
//
// {
// gscoped_ptr<Foo> ptr(new Foo("yay")); // ptr manages Foo("yay").
-// TakesOwnership(ptr.Pass()); // ptr no longer owns Foo("yay").
+// TakesOwnership(std::move(ptr)); // ptr no longer owns Foo("yay").
// gscoped_ptr<Foo> ptr2 = CreateFoo(); // ptr2 owns the return Foo.
// gscoped_ptr<Foo> ptr3 = // ptr3 now owns what was in ptr2.
-// PassThru(ptr2.Pass()); // ptr2 is correspondingly NULL.
+// PassThru(std::move(ptr2)); // ptr2 is correspondingly NULL.
// }
//
// Notice that if you do not call Pass() when returning from PassThru(), or
@@ -72,7 +72,7 @@
// gscoped_ptr<Child> to gscoped_ptr<Parent>:
//
// gscoped_ptr<Foo> foo(new Foo());
-// gscoped_ptr<FooParent> parent = foo.Pass();
+// gscoped_ptr<FooParent> parent = std::move(foo);
//
// PassAs<>() should be used to upcast return value in return statement:
//
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/gutil/move.h
----------------------------------------------------------------------
diff --git a/src/kudu/gutil/move.h b/src/kudu/gutil/move.h
index 1c67155..1765108 100644
--- a/src/kudu/gutil/move.h
+++ b/src/kudu/gutil/move.h
@@ -105,8 +105,8 @@
//
//
// Foo f(MakeFoo()); // R-value so alternate conversion executed.
-// Foo f_copy(f.Pass()); // R-value so alternate conversion executed.
-// f = f_copy.Pass(); // R-value so alternate conversion executed.
+// Foo f_copy(std::move(f)); // R-value so alternate conversion executed.
+// f = std::move(f_copy); // R-value so alternate conversion executed.
//
//
// IMPLEMENTATION SUBTLETIES WITH RValue
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/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 3a07af1..09fc2e8 100644
--- a/src/kudu/integration-tests/full_stack-insert-scan-test.cc
+++ b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
@@ -322,8 +322,8 @@ void FullStackInsertScanTest::DoTestScans() {
NO_FATALS(ScanProjection(Int32ColumnNames(), "Int32 projection, 4 col"));
NO_FATALS(ScanProjection(Int64ColumnNames(), "Int64 projection, 4 col"));
- NO_FATALS(InterruptNotNull(record.Pass()));
- NO_FATALS(InterruptNotNull(stat.Pass()));
+ NO_FATALS(InterruptNotNull(std::move(record)));
+ NO_FATALS(InterruptNotNull(std::move(stat)));
}
void FullStackInsertScanTest::FlushToDisk() {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/master/catalog_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 016aab5..ecf85d3 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -1785,7 +1785,7 @@ class RetryingTSRpcTask : public MonitoredTask {
const scoped_refptr<TableInfo>& table)
: master_(master),
callback_pool_(callback_pool),
- replica_picker_(replica_picker.Pass()),
+ replica_picker_(std::move(replica_picker)),
table_(table),
start_ts_(MonoTime::Now(MonoTime::FINE)),
attempt_(0),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/master/master.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/master.cc b/src/kudu/master/master.cc
index c3c46f3..8261653 100644
--- a/src/kudu/master/master.cc
+++ b/src/kudu/master/master.cc
@@ -113,8 +113,8 @@ Status Master::StartAsync() {
gscoped_ptr<ServiceIf> consensus_service(new ConsensusServiceImpl(metric_entity(),
catalog_manager_.get()));
- RETURN_NOT_OK(ServerBase::RegisterService(impl.Pass()));
- RETURN_NOT_OK(ServerBase::RegisterService(consensus_service.Pass()));
+ RETURN_NOT_OK(ServerBase::RegisterService(std::move(impl)));
+ RETURN_NOT_OK(ServerBase::RegisterService(std::move(consensus_service)));
RETURN_NOT_OK(ServerBase::Start());
// Now that we've bound, construct our ServerRegistrationPB.
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/master/sys_catalog.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/sys_catalog.cc b/src/kudu/master/sys_catalog.cc
index caf47dd..c443ea6 100644
--- a/src/kudu/master/sys_catalog.cc
+++ b/src/kudu/master/sys_catalog.cc
@@ -315,7 +315,7 @@ Status SysCatalogTable::SyncWrite(const WriteRequestPB *req, WriteResponsePB *re
gscoped_ptr<tablet::TransactionCompletionCallback> txn_callback(
new LatchTransactionCompletionCallback<WriteResponsePB>(&latch, resp));
auto tx_state = new tablet::WriteTransactionState(tablet_peer_.get(), req, resp);
- tx_state->set_completion_callback(txn_callback.Pass());
+ tx_state->set_completion_callback(std::move(txn_callback));
RETURN_NOT_OK(tablet_peer_->SubmitWrite(tx_state));
latch.Wait();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/connection.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/connection.cc b/src/kudu/rpc/connection.cc
index 5dad5c3..f1626ea 100644
--- a/src/kudu/rpc/connection.cc
+++ b/src/kudu/rpc/connection.cc
@@ -301,7 +301,7 @@ struct ResponseTransferCallbacks : public TransferCallbacks {
public:
ResponseTransferCallbacks(gscoped_ptr<InboundCall> call,
Connection *conn) :
- call_(call.Pass()),
+ call_(std::move(call)),
conn_(conn)
{}
@@ -332,12 +332,12 @@ class QueueTransferTask : public ReactorTask {
public:
QueueTransferTask(gscoped_ptr<OutboundTransfer> transfer,
Connection *conn)
- : transfer_(transfer.Pass()),
+ : transfer_(std::move(transfer)),
conn_(conn)
{}
virtual void Run(ReactorThread *thr) OVERRIDE {
- conn_->QueueOutbound(transfer_.Pass());
+ conn_->QueueOutbound(std::move(transfer_));
delete this;
}
@@ -365,11 +365,11 @@ void Connection::QueueResponseForCall(gscoped_ptr<InboundCall> call) {
std::vector<Slice> slices;
call->SerializeResponseTo(&slices);
- TransferCallbacks *cb = new ResponseTransferCallbacks(call.Pass(), this);
+ TransferCallbacks *cb = new ResponseTransferCallbacks(std::move(call), this);
// After the response is sent, can delete the InboundCall object.
gscoped_ptr<OutboundTransfer> t(new OutboundTransfer(slices, cb));
- QueueTransferTask *task = new QueueTransferTask(t.Pass(), this);
+ QueueTransferTask *task = new QueueTransferTask(std::move(t), this);
reactor_thread_->reactor()->ScheduleReactorTask(task);
}
@@ -409,9 +409,9 @@ void Connection::ReadHandler(ev::io &watcher, int revents) {
DVLOG(3) << ToString() << ": finished reading " << inbound_->data().size() << " bytes";
if (direction_ == CLIENT) {
- HandleCallResponse(inbound_.Pass());
+ HandleCallResponse(std::move(inbound_));
} else if (direction_ == SERVER) {
- HandleIncomingCall(inbound_.Pass());
+ HandleIncomingCall(std::move(inbound_));
} else {
LOG(FATAL) << "Invalid direction: " << direction_;
}
@@ -431,7 +431,7 @@ void Connection::HandleIncomingCall(gscoped_ptr<InboundTransfer> transfer) {
DCHECK(reactor_thread_->IsCurrentThread());
gscoped_ptr<InboundCall> call(new InboundCall(this));
- Status s = call->ParseFrom(transfer.Pass());
+ Status s = call->ParseFrom(std::move(transfer));
if (!s.ok()) {
LOG(WARNING) << ToString() << ": received bad data: " << s.ToString();
// TODO: shutdown? probably, since any future stuff on this socket will be
@@ -448,13 +448,13 @@ void Connection::HandleIncomingCall(gscoped_ptr<InboundTransfer> transfer) {
return;
}
- reactor_thread_->reactor()->messenger()->QueueInboundCall(call.Pass());
+ reactor_thread_->reactor()->messenger()->QueueInboundCall(std::move(call));
}
void Connection::HandleCallResponse(gscoped_ptr<InboundTransfer> transfer) {
DCHECK(reactor_thread_->IsCurrentThread());
gscoped_ptr<CallResponse> resp(new CallResponse);
- CHECK_OK(resp->ParseFrom(transfer.Pass()));
+ CHECK_OK(resp->ParseFrom(std::move(transfer)));
CallAwaitingResponse *car_ptr =
EraseKeyReturnValuePtr(&awaiting_response_, resp->call_id());
@@ -473,7 +473,7 @@ void Connection::HandleCallResponse(gscoped_ptr<InboundTransfer> transfer) {
return;
}
- car->call->SetResponse(resp.Pass());
+ car->call->SetResponse(std::move(resp));
}
void Connection::WriteHandler(ev::io &watcher, int revents) {
@@ -543,7 +543,7 @@ Status Connection::InitSaslServer() {
// Right now we just enable PLAIN with a "dummy" auth store, which allows everyone in.
RETURN_NOT_OK(sasl_server().Init(kSaslProtoName));
gscoped_ptr<AuthStore> auth_store(new DummyAuthStore());
- RETURN_NOT_OK(sasl_server().EnablePlain(auth_store.Pass()));
+ RETURN_NOT_OK(sasl_server().EnablePlain(std::move(auth_store)));
return Status::OK();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/messenger.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/messenger.cc b/src/kudu/rpc/messenger.cc
index dfad386..a3349b6 100644
--- a/src/kudu/rpc/messenger.cc
+++ b/src/kudu/rpc/messenger.cc
@@ -219,7 +219,7 @@ void Messenger::QueueInboundCall(gscoped_ptr<InboundCall> call) {
}
// The RpcService will respond to the client on success or failure.
- WARN_NOT_OK((*service)->QueueInboundCall(call.Pass()), "Unable to handle RPC call");
+ WARN_NOT_OK((*service)->QueueInboundCall(std::move(call)), "Unable to handle RPC call");
}
void Messenger::RegisterInboundSocket(Socket *new_socket, const Sockaddr &remote) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/mt-rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/mt-rpc-test.cc b/src/kudu/rpc/mt-rpc-test.cc
index 6b05784..73e3a13 100644
--- a/src/kudu/rpc/mt-rpc-test.cc
+++ b/src/kudu/rpc/mt-rpc-test.cc
@@ -154,7 +154,7 @@ class BogusServicePool : public ServicePool {
BogusServicePool(gscoped_ptr<ServiceIf> service,
const scoped_refptr<MetricEntity>& metric_entity,
size_t service_queue_length)
- : ServicePool(service.Pass(), metric_entity, service_queue_length) {
+ : ServicePool(std::move(service), metric_entity, service_queue_length) {
}
virtual Status Init(int num_threads) OVERRIDE {
// Do nothing
@@ -191,7 +191,7 @@ TEST_F(MultiThreadedRpcTest, TestBlowOutServiceQueue) {
gscoped_ptr<ServiceIf> service(new GenericCalculatorService());
service_name_ = service->service_name();
- service_pool_ = new BogusServicePool(service.Pass(),
+ service_pool_ = new BogusServicePool(std::move(service),
server_messenger_->metric_entity(),
kMaxConcurrency);
ASSERT_OK(service_pool_->Init(n_worker_threads_));
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/outbound_call.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/outbound_call.cc b/src/kudu/rpc/outbound_call.cc
index 8c2ef57..b63e69a 100644
--- a/src/kudu/rpc/outbound_call.cc
+++ b/src/kudu/rpc/outbound_call.cc
@@ -190,7 +190,7 @@ void OutboundCall::CallCallback() {
}
void OutboundCall::SetResponse(gscoped_ptr<CallResponse> resp) {
- call_response_ = resp.Pass();
+ call_response_ = std::move(resp);
Slice r(call_response_->serialized_response());
if (call_response_->is_success()) {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/rpc-test-base.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc-test-base.h b/src/kudu/rpc/rpc-test-base.h
index cf02fa4..0e0df7d 100644
--- a/src/kudu/rpc/rpc-test-base.h
+++ b/src/kudu/rpc/rpc-test-base.h
@@ -132,9 +132,9 @@ class GenericCalculatorService : public ServiceIf {
SendTwoStringsResponsePB resp;
int idx1, idx2;
CHECK_OK(incoming->AddRpcSidecar(
- make_gscoped_ptr(new RpcSidecar(first.Pass())), &idx1));
+ make_gscoped_ptr(new RpcSidecar(std::move(first))), &idx1));
CHECK_OK(incoming->AddRpcSidecar(
- make_gscoped_ptr(new RpcSidecar(second.Pass())), &idx2));
+ make_gscoped_ptr(new RpcSidecar(std::move(second))), &idx2));
resp.set_sidecar1(idx1);
resp.set_sidecar2(idx2);
@@ -404,7 +404,7 @@ class RpcTestBase : public KuduTest {
gscoped_ptr<ServiceIf> service(new ServiceClass(metric_entity_));
service_name_ = service->service_name();
scoped_refptr<MetricEntity> metric_entity = server_messenger_->metric_entity();
- service_pool_ = new ServicePool(service.Pass(), metric_entity, 50);
+ service_pool_ = new ServicePool(std::move(service), metric_entity, 50);
server_messenger_->RegisterService(service_name_, service_pool_);
ASSERT_OK(service_pool_->Init(n_worker_threads_));
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/rpc_context.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc_context.cc b/src/kudu/rpc/rpc_context.cc
index 5111000..a3a870b 100644
--- a/src/kudu/rpc/rpc_context.cc
+++ b/src/kudu/rpc/rpc_context.cc
@@ -136,7 +136,7 @@ void RpcContext::RespondApplicationError(int error_ext_id, const std::string& me
}
Status RpcContext::AddRpcSidecar(gscoped_ptr<RpcSidecar> car, int* idx) {
- return call_->AddRpcSidecar(car.Pass(), idx);
+ return call_->AddRpcSidecar(std::move(car), idx);
}
const UserCredentials& RpcContext::user_credentials() const {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/rpc_sidecar.h
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/rpc_sidecar.h b/src/kudu/rpc/rpc_sidecar.h
index 5f3ea0b..da7e00f 100644
--- a/src/kudu/rpc/rpc_sidecar.h
+++ b/src/kudu/rpc/rpc_sidecar.h
@@ -52,7 +52,7 @@ namespace rpc {
class RpcSidecar {
public:
// Generates a sidecar with the parameter faststring as its data.
- explicit RpcSidecar(gscoped_ptr<faststring> data) : data_(data.Pass()) {}
+ explicit RpcSidecar(gscoped_ptr<faststring> data) : data_(std::move(data)) {}
// Returns a Slice representation of the sidecar's data.
Slice AsSlice() const { return *data_; }
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/sasl_rpc-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/sasl_rpc-test.cc b/src/kudu/rpc/sasl_rpc-test.cc
index 1e46380..6697a0b 100644
--- a/src/kudu/rpc/sasl_rpc-test.cc
+++ b/src/kudu/rpc/sasl_rpc-test.cc
@@ -115,7 +115,7 @@ static void RunPlainNegotiationServer(Socket* conn) {
gscoped_ptr<AuthStore> authstore(new AuthStore());
CHECK_OK(authstore->Add("danger", "burrito"));
CHECK_OK(sasl_server.Init(kSaslAppName));
- CHECK_OK(sasl_server.EnablePlain(authstore.Pass()));
+ CHECK_OK(sasl_server.EnablePlain(std::move(authstore)));
CHECK_OK(sasl_server.Negotiate());
}
@@ -138,7 +138,7 @@ static void RunPlainFailingNegotiationServer(Socket* conn) {
gscoped_ptr<AuthStore> authstore(new AuthStore());
CHECK_OK(authstore->Add("danger", "burrito"));
CHECK_OK(sasl_server.Init(kSaslAppName));
- CHECK_OK(sasl_server.EnablePlain(authstore.Pass()));
+ CHECK_OK(sasl_server.EnablePlain(std::move(authstore)));
Status s = sasl_server.Negotiate();
ASSERT_TRUE(s.IsNotAuthorized()) << "Expected auth failure! Got: " << s.ToString();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/rpc/service_pool.cc
----------------------------------------------------------------------
diff --git a/src/kudu/rpc/service_pool.cc b/src/kudu/rpc/service_pool.cc
index 8a10b6f..55a2791 100644
--- a/src/kudu/rpc/service_pool.cc
+++ b/src/kudu/rpc/service_pool.cc
@@ -60,7 +60,7 @@ namespace rpc {
ServicePool::ServicePool(gscoped_ptr<ServiceIf> service,
const scoped_refptr<MetricEntity>& entity,
size_t service_queue_length)
- : service_(service.Pass()),
+ : service_(std::move(service)),
service_queue_(service_queue_length),
incoming_queue_time_(METRIC_rpc_incoming_queue_time.Instantiate(entity)),
rpcs_timed_out_in_queue_(METRIC_rpcs_timed_out_in_queue.Instantiate(entity)),
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/server/rpc_server.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/rpc_server.cc b/src/kudu/server/rpc_server.cc
index aab4220..25c497c 100644
--- a/src/kudu/server/rpc_server.cc
+++ b/src/kudu/server/rpc_server.cc
@@ -118,7 +118,7 @@ Status RpcServer::RegisterService(gscoped_ptr<rpc::ServiceIf> service) {
const scoped_refptr<MetricEntity>& metric_entity = messenger_->metric_entity();
string service_name = service->service_name();
scoped_refptr<rpc::ServicePool> service_pool =
- new rpc::ServicePool(service.Pass(), metric_entity, options_.service_queue_length);
+ new rpc::ServicePool(std::move(service), metric_entity, options_.service_queue_length);
RETURN_NOT_OK(service_pool->Init(options_.num_service_threads));
RETURN_NOT_OK(messenger_->RegisterService(service_name, service_pool));
return Status::OK();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/server/server_base.cc
----------------------------------------------------------------------
diff --git a/src/kudu/server/server_base.cc b/src/kudu/server/server_base.cc
index edcf56f..32ca92d 100644
--- a/src/kudu/server/server_base.cc
+++ b/src/kudu/server/server_base.cc
@@ -236,7 +236,7 @@ Status ServerBase::DumpServerInfo(const string& path,
}
Status ServerBase::RegisterService(gscoped_ptr<rpc::ServiceIf> rpc_impl) {
- return rpc_server_->RegisterService(rpc_impl.Pass());
+ return rpc_server_->RegisterService(std::move(rpc_impl));
}
Status ServerBase::StartMetricsLogging() {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/tablet/cfile_set.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/cfile_set.cc b/src/kudu/tablet/cfile_set.cc
index 0f64e08..d950e6a 100644
--- a/src/kudu/tablet/cfile_set.cc
+++ b/src/kudu/tablet/cfile_set.cc
@@ -58,7 +58,7 @@ static Status OpenReader(const shared_ptr<RowSetMetadata>& rowset_metadata,
// TODO: somehow pass reader options in schema
ReaderOptions opts;
- return CFileReader::OpenNoInit(block.Pass(), opts, new_reader);
+ return CFileReader::OpenNoInit(std::move(block), opts, new_reader);
}
////////////////////////////////////////////////////////////
@@ -113,7 +113,7 @@ Status CFileSet::OpenAdHocIndexReader() {
RETURN_NOT_OK(fs->OpenBlock(rowset_metadata_->adhoc_index_block(), &block));
ReaderOptions opts;
- return CFileReader::Open(block.Pass(), opts, &ad_hoc_idx_reader_);
+ return CFileReader::Open(std::move(block), opts, &ad_hoc_idx_reader_);
}
@@ -127,7 +127,7 @@ Status CFileSet::OpenBloomReader() {
RETURN_NOT_OK(fs->OpenBlock(rowset_metadata_->bloom_block(), &block));
ReaderOptions opts;
- Status s = BloomFileReader::OpenNoInit(block.Pass(), opts, &bloom_reader_);
+ Status s = BloomFileReader::OpenNoInit(std::move(block), opts, &bloom_reader_);
if (!s.ok()) {
LOG(WARNING) << "Unable to open bloom file in " << rowset_metadata_->ToString() << ": "
<< s.ToString();
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/tablet/compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/compaction.cc b/src/kudu/tablet/compaction.cc
index 3a99ef7..76bf0ec 100644
--- a/src/kudu/tablet/compaction.cc
+++ b/src/kudu/tablet/compaction.cc
@@ -136,7 +136,7 @@ class DiskRowSetCompactionInput : public CompactionInput {
DiskRowSetCompactionInput(gscoped_ptr<RowwiseIterator> base_iter,
shared_ptr<DeltaIterator> redo_delta_iter,
shared_ptr<DeltaIterator> undo_delta_iter)
- : base_iter_(base_iter.Pass()),
+ : base_iter_(std::move(base_iter)),
redo_delta_iter_(std::move(redo_delta_iter)),
undo_delta_iter_(std::move(undo_delta_iter)),
arena_(32 * 1024, 128 * 1024),
@@ -546,7 +546,7 @@ Status CompactionInput::Create(const DiskRowSet &rowset,
MvccSnapshot::CreateSnapshotIncludingNoTransactions(),
&undo_deltas), "Could not open UNDOs");
- out->reset(new DiskRowSetCompactionInput(base_iter.Pass(), redo_deltas, undo_deltas));
+ out->reset(new DiskRowSetCompactionInput(std::move(base_iter), redo_deltas, undo_deltas));
return Status::OK();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/tablet/delta_compaction-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction-test.cc b/src/kudu/tablet/delta_compaction-test.cc
index 6d67d3e..85f077b 100644
--- a/src/kudu/tablet/delta_compaction-test.cc
+++ b/src/kudu/tablet/delta_compaction-test.cc
@@ -69,7 +69,7 @@ class TestDeltaCompaction : public KuduTest {
gscoped_ptr<WritableBlock> block;
RETURN_NOT_OK(fs_manager_->CreateNewBlock(&block));
*block_id = block->id();
- dfw->reset(new DeltaFileWriter(block.Pass()));
+ dfw->reset(new DeltaFileWriter(std::move(block)));
RETURN_NOT_OK((*dfw)->Start());
return Status::OK();
}
@@ -79,7 +79,7 @@ class TestDeltaCompaction : public KuduTest {
gscoped_ptr<ReadableBlock> block;
RETURN_NOT_OK(fs_manager_->OpenBlock(block_id, &block));
shared_ptr<DeltaFileReader> delta_reader;
- return DeltaFileReader::Open(block.Pass(), block_id, dfr, REDO);
+ return DeltaFileReader::Open(std::move(block), block_id, dfr, REDO);
}
virtual void SetUp() OVERRIDE {
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/tablet/delta_compaction.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_compaction.cc b/src/kudu/tablet/delta_compaction.cc
index 8defcfb..321cccf 100644
--- a/src/kudu/tablet/delta_compaction.cc
+++ b/src/kudu/tablet/delta_compaction.cc
@@ -235,7 +235,7 @@ Status MajorDeltaCompaction::OpenRedoDeltaFileWriter() {
RETURN_NOT_OK_PREPEND(fs_manager_->CreateNewBlock(&block),
"Unable to create REDO delta output block");
new_redo_delta_block_ = block->id();
- new_redo_delta_writer_.reset(new DeltaFileWriter(block.Pass()));
+ new_redo_delta_writer_.reset(new DeltaFileWriter(std::move(block)));
return new_redo_delta_writer_->Start();
}
@@ -244,7 +244,7 @@ Status MajorDeltaCompaction::OpenUndoDeltaFileWriter() {
RETURN_NOT_OK_PREPEND(fs_manager_->CreateNewBlock(&block),
"Unable to create UNDO delta output block");
new_undo_delta_block_ = block->id();
- new_undo_delta_writer_.reset(new DeltaFileWriter(block.Pass()));
+ new_undo_delta_writer_.reset(new DeltaFileWriter(std::move(block)));
return new_undo_delta_writer_->Start();
}
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/d0a02cd4/src/kudu/tablet/delta_tracker.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/delta_tracker.cc b/src/kudu/tablet/delta_tracker.cc
index 41ba17a..4eb9070 100644
--- a/src/kudu/tablet/delta_tracker.cc
+++ b/src/kudu/tablet/delta_tracker.cc
@@ -65,7 +65,7 @@ Status DeltaTracker::OpenDeltaReaders(const vector<BlockId>& blocks,
}
shared_ptr<DeltaFileReader> dfr;
- s = DeltaFileReader::OpenNoInit(block.Pass(), block_id, &dfr, type);
+ s = DeltaFileReader::OpenNoInit(std::move(block), block_id, &dfr, type);
if (!s.ok()) {
LOG(ERROR) << "Failed to open " << DeltaType_Name(type)
<< " delta file reader " << block_id.ToString() << ": "
@@ -217,7 +217,7 @@ Status DeltaTracker::CompactStores(int start_idx, int end_idx) {
// Merge and compact the stores and write and output to "data_writer"
vector<shared_ptr<DeltaStore> > compacted_stores;
vector<BlockId> compacted_blocks;
- RETURN_NOT_OK(DoCompactStores(start_idx, end_idx, block.Pass(),
+ RETURN_NOT_OK(DoCompactStores(start_idx, end_idx, std::move(block),
&compacted_stores, &compacted_blocks));
// Update delta_stores_, removing the compacted delta files and inserted the new
@@ -257,7 +257,7 @@ Status DeltaTracker::DoCompactStores(size_t start_idx, size_t end_idx,
RETURN_NOT_OK(MakeDeltaIteratorMergerUnlocked(start_idx, end_idx, &empty_schema, compacted_stores,
compacted_blocks, &inputs_merge));
LOG(INFO) << "Compacting " << (end_idx - start_idx + 1) << " delta files.";
- DeltaFileWriter dfw(block.Pass());
+ DeltaFileWriter dfw(std::move(block));
RETURN_NOT_OK(dfw.Start());
RETURN_NOT_OK(WriteDeltaIteratorToFile<REDO>(inputs_merge.get(),
ITERATE_OVER_ALL_ROWS,
@@ -399,7 +399,7 @@ Status DeltaTracker::FlushDMS(DeltaMemStore* dms,
"Unable to allocate new delta data writable_block");
BlockId block_id(writable_block->id());
- DeltaFileWriter dfw(writable_block.Pass());
+ DeltaFileWriter dfw(std::move(writable_block));
RETURN_NOT_OK_PREPEND(dfw.Start(),
Substitute("Unable to start writing to delta block $0",
block_id.ToString()));
@@ -412,7 +412,7 @@ Status DeltaTracker::FlushDMS(DeltaMemStore* dms,
// Now re-open for read
gscoped_ptr<ReadableBlock> readable_block;
RETURN_NOT_OK(fs->OpenBlock(block_id, &readable_block));
- RETURN_NOT_OK(DeltaFileReader::OpenNoInit(readable_block.Pass(), block_id, dfr, REDO));
+ RETURN_NOT_OK(DeltaFileReader::OpenNoInit(std::move(readable_block), block_id, dfr, REDO));
LOG(INFO) << "Reopened delta block for read: " << block_id.ToString();
RETURN_NOT_OK(rowset_metadata_->CommitRedoDeltaDataBlock(dms->id(), block_id));