Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 82356c3f authored by David Anderson's avatar David Anderson
Browse files

libsnapshot: Rename and clarify some methods in ICowOpIter. 

Done and RDone are not exactly symmetrical, so rename them to match
their underlying STL behavior. Done becomes "AtEnd" and RDone becomes
"AtBegin".

Bug: 280529365
Test: builds
Change-Id: I876f858a7bef84d8b37c1c822fb42941fbcded25
parent 35935025

fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h

+9 −6
Original line number Diff line number Diff line
@@ -67,13 +67,14 @@ class ICowReader { 
                             size_t ignore_bytes = 0) = 0;

};



// Iterate over a sequence of COW operations.

// Iterate over a sequence of COW operations. The iterator is bidirectional.

class ICowOpIter {

  public:

    virtual ~ICowOpIter() {}



    // True if there are no more items to read forward, false otherwise.

    virtual bool Done() = 0;

    // Returns true if the iterator is at the end of the operation list.

    // If true, Get() and Next() must not be called.

    virtual bool AtEnd() = 0;



    // Read the current operation.

    virtual const CowOperation& Get() = 0;
@@ -81,11 +82,13 @@ class ICowOpIter { 
    // Advance to the next item.

    virtual void Next() = 0;



    // Returns true if the iterator is at the beginning of the operation list.

    // If true, Prev() must not be called; Get() however will be valid if

    // AtEnd() is not true.

    virtual bool AtBegin() = 0;



    // Advance to the previous item.

    virtual void Prev() = 0;



    // True if there are no more items to read backwards, false otherwise

    virtual bool RDone() = 0;

};



class CowReader final : public ICowReader {

fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp

+66 −66
Original line number Diff line number Diff line
@@ -76,10 +76,10 @@ TEST_F(CowTest, CopyContiguous) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());



    size_t i = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        auto op = &iter->Get();

        ASSERT_EQ(op->type, kCowCopyOp);

        ASSERT_EQ(op->compression, kCowCompressNone);
@@ -125,7 +125,7 @@ TEST_F(CowTest, ReadWrite) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();



    ASSERT_EQ(op->type, kCowCopyOp);
@@ -137,7 +137,7 @@ TEST_F(CowTest, ReadWrite) { 
    std::string sink(data.size(), '\0');



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowReplaceOp);
@@ -148,7 +148,7 @@ TEST_F(CowTest, ReadWrite) { 
    ASSERT_EQ(sink, data);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    // Note: the zero operation gets split into two blocks.
@@ -159,7 +159,7 @@ TEST_F(CowTest, ReadWrite) { 
    ASSERT_EQ(op->source, 0);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowZeroOp);
@@ -169,7 +169,7 @@ TEST_F(CowTest, ReadWrite) { 
    ASSERT_EQ(op->source, 0);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, ReadWriteXor) {
@@ -204,7 +204,7 @@ TEST_F(CowTest, ReadWriteXor) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();



    ASSERT_EQ(op->type, kCowCopyOp);
@@ -216,7 +216,7 @@ TEST_F(CowTest, ReadWriteXor) { 
    std::string sink(data.size(), '\0');



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowXorOp);
@@ -228,7 +228,7 @@ TEST_F(CowTest, ReadWriteXor) { 
    ASSERT_EQ(sink, data);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    // Note: the zero operation gets split into two blocks.
@@ -239,7 +239,7 @@ TEST_F(CowTest, ReadWriteXor) { 
    ASSERT_EQ(op->source, 0);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowZeroOp);
@@ -249,7 +249,7 @@ TEST_F(CowTest, ReadWriteXor) { 
    ASSERT_EQ(op->source, 0);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, CompressGz) {
@@ -273,7 +273,7 @@ TEST_F(CowTest, CompressGz) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();



    std::string sink(data.size(), '\0');
@@ -286,7 +286,7 @@ TEST_F(CowTest, CompressGz) { 
    ASSERT_EQ(sink, data);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



class CompressionTest : public CowTest, public testing::WithParamInterface<const char*> {};
@@ -328,7 +328,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) { 
    ASSERT_NE(iter, nullptr);



    int total_blocks = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        auto op = &iter->Get();



        if (op->type == kCowXorOp) {
@@ -402,7 +402,7 @@ TEST_P(CompressionTest, NoBatchWrites) { 
    ASSERT_NE(iter, nullptr);



    int total_blocks = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        auto op = &iter->Get();



        if (op->type == kCowReplaceOp) {
@@ -518,7 +518,7 @@ TEST_F(CowTest, ClusterCompressGz) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();



    std::string sink(data.size(), '\0');
@@ -531,13 +531,13 @@ TEST_F(CowTest, ClusterCompressGz) { 
    ASSERT_EQ(sink, data);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowClusterOp);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    sink = {};
@@ -549,13 +549,13 @@ TEST_F(CowTest, ClusterCompressGz) { 
    ASSERT_EQ(sink, data2);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();



    ASSERT_EQ(op->type, kCowClusterOp);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, CompressTwoBlocks) {
@@ -579,9 +579,9 @@ TEST_F(CowTest, CompressTwoBlocks) { 


    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());



    std::string sink(options.block_size, '\0');
@@ -658,7 +658,7 @@ TEST_F(CowTest, AppendLabelSmall) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));
@@ -668,21 +668,21 @@ TEST_F(CowTest, AppendLabelSmall) { 
    sink = {};

    sink.resize(data2.size(), '\0');



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 3);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));

    ASSERT_EQ(sink, data2);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, AppendLabelMissing) {
@@ -721,20 +721,20 @@ TEST_F(CowTest, AppendLabelMissing) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 0);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowZeroOp);



    iter->Next();



    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, AppendExtendedCorrupted) {
@@ -779,13 +779,13 @@ TEST_F(CowTest, AppendExtendedCorrupted) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 5);



    iter->Next();

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, AppendbyLabel) {
@@ -830,7 +830,7 @@ TEST_F(CowTest, AppendbyLabel) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));
@@ -840,7 +840,7 @@ TEST_F(CowTest, AppendbyLabel) { 
    sink = {};

    sink.resize(options.block_size, '\0');



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));
@@ -848,32 +848,32 @@ TEST_F(CowTest, AppendbyLabel) { 


    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 4);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowZeroOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowZeroOp);



    iter->Next();

    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 5);



    iter->Next();



    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, ClusterTest) {
@@ -911,7 +911,7 @@ TEST_F(CowTest, ClusterTest) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));
@@ -919,58 +919,58 @@ TEST_F(CowTest, ClusterTest) { 


    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 4);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowZeroOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowClusterOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowZeroOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 5);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowCopyOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowClusterOp);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 6);



    iter->Next();



    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, ClusterAppendTest) {
@@ -1010,14 +1010,14 @@ TEST_F(CowTest, ClusterAppendTest) { 
    auto iter = reader.GetOpIter();

    ASSERT_NE(iter, nullptr);



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    auto op = &iter->Get();

    ASSERT_EQ(op->type, kCowLabelOp);

    ASSERT_EQ(op->source, 50);



    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_TRUE(ReadData(reader, *op, sink.data(), sink.size()));
@@ -1025,13 +1025,13 @@ TEST_F(CowTest, ClusterAppendTest) { 


    iter->Next();



    ASSERT_FALSE(iter->Done());

    ASSERT_FALSE(iter->AtEnd());

    op = &iter->Get();

    ASSERT_EQ(op->type, kCowClusterOp);



    iter->Next();



    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, AppendAfterFinalize) {
@@ -1118,7 +1118,7 @@ TEST_F(CowTest, ResumeMidCluster) { 
    size_t max_in_cluster = 0;

    size_t num_in_cluster = 0;

    size_t num_clusters = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        const auto& op = iter->Get();



        num_in_cluster++;
@@ -1179,7 +1179,7 @@ TEST_F(CowTest, ResumeEndCluster) { 
    size_t max_in_cluster = 0;

    size_t num_in_cluster = 0;

    size_t num_clusters = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        const auto& op = iter->Get();



        num_in_cluster++;
@@ -1231,7 +1231,7 @@ TEST_F(CowTest, DeleteMidCluster) { 
    size_t max_in_cluster = 0;

    size_t num_in_cluster = 0;

    size_t num_clusters = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        const auto& op = iter->Get();



        num_in_cluster++;
@@ -1275,14 +1275,14 @@ TEST_F(CowTest, BigSeqOp) { 
    auto iter = reader.GetRevMergeOpIter();



    for (int i = 0; i < seq_len; i++) {

        ASSERT_TRUE(!iter->Done());

        ASSERT_TRUE(!iter->AtEnd());

        const auto& op = iter->Get();



        ASSERT_EQ(op.new_block, seq_len - i);



        iter->Next();

    }

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, MissingSeqOp) {
@@ -1326,7 +1326,7 @@ TEST_F(CowTest, ResumeSeqOp) { 
    auto reader = std::make_unique<CowReader>();

    ASSERT_TRUE(reader->Parse(cow_->fd, 1));

    auto itr = reader->GetRevMergeOpIter();

    ASSERT_TRUE(itr->Done());

    ASSERT_TRUE(itr->AtEnd());



    writer = std::make_unique<CowWriter>(options);

    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
@@ -1341,8 +1341,8 @@ TEST_F(CowTest, ResumeSeqOp) { 
    auto iter = reader->GetRevMergeOpIter();



    uint64_t expected_block = 10;

    while (!iter->Done() && expected_block > 0) {

        ASSERT_FALSE(iter->Done());

    while (!iter->AtEnd() && expected_block > 0) {

        ASSERT_FALSE(iter->AtEnd());

        const auto& op = iter->Get();



        ASSERT_EQ(op.new_block, expected_block);
@@ -1351,7 +1351,7 @@ TEST_F(CowTest, ResumeSeqOp) { 
        expected_block--;

    }

    ASSERT_EQ(expected_block, 0);

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, RevMergeOpItrTest) {
@@ -1392,7 +1392,7 @@ TEST_F(CowTest, RevMergeOpItrTest) { 
    auto iter = reader.GetRevMergeOpIter();

    auto expected_new_block = revMergeOpSequence.begin();



    while (!iter->Done() && expected_new_block != revMergeOpSequence.end()) {

    while (!iter->AtEnd() && expected_new_block != revMergeOpSequence.end()) {

        const auto& op = iter->Get();



        ASSERT_EQ(op.new_block, *expected_new_block);
@@ -1401,7 +1401,7 @@ TEST_F(CowTest, RevMergeOpItrTest) { 
        expected_new_block++;

    }

    ASSERT_EQ(expected_new_block, revMergeOpSequence.end());

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, LegacyRevMergeOpItrTest) {
@@ -1441,7 +1441,7 @@ TEST_F(CowTest, LegacyRevMergeOpItrTest) { 
    auto iter = reader.GetRevMergeOpIter();

    auto expected_new_block = revMergeOpSequence.begin();



    while (!iter->Done() && expected_new_block != revMergeOpSequence.end()) {

    while (!iter->AtEnd() && expected_new_block != revMergeOpSequence.end()) {

        const auto& op = iter->Get();



        ASSERT_EQ(op.new_block, *expected_new_block);
@@ -1450,7 +1450,7 @@ TEST_F(CowTest, LegacyRevMergeOpItrTest) { 
        expected_new_block++;

    }

    ASSERT_EQ(expected_new_block, revMergeOpSequence.end());

    ASSERT_TRUE(iter->Done());

    ASSERT_TRUE(iter->AtEnd());

}



TEST_F(CowTest, InvalidMergeOrderTest) {

fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp

+22 −22
Original line number Diff line number Diff line
@@ -509,7 +509,7 @@ bool CowReader::PrepMergeOps() { 
bool CowReader::VerifyMergeOps() {

    auto itr = GetMergeOpIter(true);

    std::unordered_map<uint64_t, CowOperation> overwritten_blocks;

    while (!itr->Done()) {

    while (!itr->AtEnd()) {

        CowOperation op = itr->Get();

        uint64_t block;

        bool offset;
@@ -560,12 +560,12 @@ class CowOpIter final : public ICowOpIter { 
  public:

    CowOpIter(std::shared_ptr<std::vector<CowOperation>>& ops, uint64_t start);



    bool Done() override;

    bool AtEnd() override;

    const CowOperation& Get() override;

    void Next() override;



    void Prev() override;

    bool RDone() override;

    bool AtBegin() override;



  private:

    std::shared_ptr<std::vector<CowOperation>> ops_;
@@ -577,26 +577,26 @@ CowOpIter::CowOpIter(std::shared_ptr<std::vector<CowOperation>>& ops, uint64_t s 
    op_iter_ = ops_->begin() + start;

}



bool CowOpIter::RDone() {

bool CowOpIter::AtBegin() {

    return op_iter_ == ops_->begin();

}



void CowOpIter::Prev() {

    CHECK(!RDone());

    CHECK(!AtBegin());

    op_iter_--;

}



bool CowOpIter::Done() {

bool CowOpIter::AtEnd() {

    return op_iter_ == ops_->end();

}



void CowOpIter::Next() {

    CHECK(!Done());

    CHECK(!AtEnd());

    op_iter_++;

}



const CowOperation& CowOpIter::Get() {

    CHECK(!Done());

    CHECK(!AtEnd());

    return (*op_iter_);

}
@@ -605,12 +605,12 @@ class CowRevMergeOpIter final : public ICowOpIter { 
    explicit CowRevMergeOpIter(std::shared_ptr<std::vector<CowOperation>> ops,

                               std::shared_ptr<std::vector<int>> block_pos_index, uint64_t start);



    bool Done() override;

    bool AtEnd() override;

    const CowOperation& Get() override;

    void Next() override;



    void Prev() override;

    bool RDone() override;

    bool AtBegin() override;



  private:

    std::shared_ptr<std::vector<CowOperation>> ops_;
@@ -624,12 +624,12 @@ class CowMergeOpIter final : public ICowOpIter { 
    explicit CowMergeOpIter(std::shared_ptr<std::vector<CowOperation>> ops,

                            std::shared_ptr<std::vector<int>> block_pos_index, uint64_t start);



    bool Done() override;

    bool AtEnd() override;

    const CowOperation& Get() override;

    void Next() override;



    void Prev() override;

    bool RDone() override;

    bool AtBegin() override;



  private:

    std::shared_ptr<std::vector<CowOperation>> ops_;
@@ -646,26 +646,26 @@ CowMergeOpIter::CowMergeOpIter(std::shared_ptr<std::vector<CowOperation>> ops, 
    block_iter_ = cow_op_index_vec_->begin() + start;

}



bool CowMergeOpIter::RDone() {

bool CowMergeOpIter::AtBegin() {

    return block_iter_ == cow_op_index_vec_->begin();

}



void CowMergeOpIter::Prev() {

    CHECK(!RDone());

    CHECK(!AtBegin());

    block_iter_--;

}



bool CowMergeOpIter::Done() {

bool CowMergeOpIter::AtEnd() {

    return block_iter_ == cow_op_index_vec_->end();

}



void CowMergeOpIter::Next() {

    CHECK(!Done());

    CHECK(!AtEnd());

    block_iter_++;

}



const CowOperation& CowMergeOpIter::Get() {

    CHECK(!Done());

    CHECK(!AtEnd());

    return ops_->data()[*block_iter_];

}
@@ -678,26 +678,26 @@ CowRevMergeOpIter::CowRevMergeOpIter(std::shared_ptr<std::vector<CowOperation>> 
    block_riter_ = cow_op_index_vec_->rbegin();

}



bool CowRevMergeOpIter::RDone() {

bool CowRevMergeOpIter::AtBegin() {

    return block_riter_ == cow_op_index_vec_->rbegin();

}



void CowRevMergeOpIter::Prev() {

    CHECK(!RDone());

    CHECK(!AtBegin());

    block_riter_--;

}



bool CowRevMergeOpIter::Done() {

bool CowRevMergeOpIter::AtEnd() {

    return block_riter_ == cow_op_index_vec_->rend() - start_;

}



void CowRevMergeOpIter::Next() {

    CHECK(!Done());

    CHECK(!AtEnd());

    block_riter_++;

}



const CowOperation& CowRevMergeOpIter::Get() {

    CHECK(!Done());

    CHECK(!AtEnd());

    return ops_->data()[*block_riter_];

}

fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -406,7 +406,7 @@ bool CowWriter::OpenForAppend(uint64_t label) { 


    auto iter = reader->GetOpIter();



    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        AddOperation(iter->Get());

        iter->Next();

    }

fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp

+1 −1
Original line number Diff line number Diff line
@@ -136,7 +136,7 @@ static bool Inspect(const std::string& path, Options opt) { 


    bool success = true;

    uint64_t xor_ops = 0, copy_ops = 0, replace_ops = 0, zero_ops = 0;

    while (!iter->Done()) {

    while (!iter->AtEnd()) {

        const CowOperation& op = iter->Get();



        if (!opt.silent && opt.show_ops) std::cout << op << "\n";