common: modernize and refactor occurrences of bufferlist::buffers_t.

Signed-off-by: Radoslaw Zarzynski <rzarzyns@redhat.com>

diff --git a/src/common/buffer.cc b/src/common/buffer.cc
index 49c8d015a5626b1bfa4dd335b9819d0c09038934..40143964d47dd189667175d0b88a7bf01d6a9dad 100644 (file)
--- a/src/common/buffer.cc
+++ b/src/common/buffer.cc
@@ -1085,13 +1085,11 @@ using namespace ceph;
     if (p == ls->end())
       seek(off);
     unsigned left = len;
-    for (buffers_t::const_iterator i = otherl._buffers.begin();
-        i != otherl._buffers.end();
-        ++i) {
-      unsigned l = (*i).length();
+    for (const auto& node : otherl._buffers) {
+      unsigned l = node.length();
       if (left < l)
        l = left;
-      copy_in(l, i->c_str());
+      copy_in(l, node.c_str());
       left -= l;
       if (left == 0)
        break;
@@ -1127,10 +1125,10 @@ using namespace ceph;
 
     // buffer-wise comparison
     if (true) {
-      buffers_t::const_iterator a = _buffers.begin();
-      buffers_t::const_iterator b = other._buffers.begin();
+      auto a = std::cbegin(_buffers);
+      auto b = std::cbegin(other._buffers);
       unsigned aoff = 0, boff = 0;
-      while (a != _buffers.end()) {
+      while (a != std::cend(_buffers)) {
        unsigned len = a->length() - aoff;
        if (len > b->length() - boff)
          len = b->length() - boff;
@@ -1147,7 +1145,7 @@ using namespace ceph;
          ++b;
        }
       }
-      ceph_assert(b == other._buffers.end());
+      ceph_assert(b == std::cend(other._buffers));
       return true;
     }
 
@@ -1165,50 +1163,49 @@ using namespace ceph;
     }
   }
 
-  bool buffer::list::is_provided_buffer(const char *dst) const
+  bool buffer::list::is_provided_buffer(const char* const dst) const
   {
-    if (_buffers.empty())
+    if (_buffers.empty()) {
       return false;
+    }
     return (is_contiguous() && (_buffers.front().c_str() == dst));
   }
 
-  bool buffer::list::is_aligned(unsigned align) const
+  bool buffer::list::is_aligned(const unsigned align) const
   {
-    for (buffers_t::const_iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) 
-      if (!it->is_aligned(align))
+    for (const auto& node : _buffers) {
+      if (!node.is_aligned(align)) {
        return false;
+      }
+    }
     return true;
   }
 
-  bool buffer::list::is_n_align_sized(unsigned align) const
+  bool buffer::list::is_n_align_sized(const unsigned align) const
   {
-    for (buffers_t::const_iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) 
-      if (!it->is_n_align_sized(align))
+    for (const auto& node : _buffers) {
+      if (!node.is_n_align_sized(align)) {
        return false;
+      }
+    }
     return true;
   }
 
-  bool buffer::list::is_aligned_size_and_memory(unsigned align_size,
-                                                 unsigned align_memory) const
+  bool buffer::list::is_aligned_size_and_memory(
+    const unsigned align_size,
+    const unsigned align_memory) const
   {
-    for (buffers_t::const_iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) {
-      if (!it->is_aligned(align_memory) || !it->is_n_align_sized(align_size))
+    for (const auto& node : _buffers) {
+      if (!node.is_aligned(align_memory) || !node.is_n_align_sized(align_size)) {
        return false;
+      }
     }
     return true;
   }
 
   bool buffer::list::is_zero() const {
-    for (buffers_t::const_iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) {
-      if (!it->is_zero()) {
+    for (const auto& node : _buffers) {
+      if (!node.is_zero()) {
        return false;
       }
     }
@@ -1217,41 +1214,39 @@ using namespace ceph;
 
   void buffer::list::zero()
   {
-    for (buffers_t::iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it)
-      it->zero();
+    for (auto& node : _buffers) {
+      node.zero();
+    }
   }
 
-  void buffer::list::zero(unsigned o, unsigned l)
+  void buffer::list::zero(const unsigned o, const unsigned l)
   {
     ceph_assert(o+l <= _len);
     unsigned p = 0;
-    for (buffers_t::iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) {
-      if (p + it->length() > o) {
-        if (p >= o && p+it->length() <= o+l) {
+    for (auto& node : _buffers) {
+      if (p + node.length() > o) {
+        if (p >= o && p+node.length() <= o+l) {
           // 'o'------------- l -----------|
-          //      'p'-- it->length() --|
-         it->zero();
+          //      'p'-- node.length() --|
+         node.zero();
         } else if (p >= o) {
           // 'o'------------- l -----------|
-          //    'p'------- it->length() -------|
-         it->zero(0, o+l-p);
-        } else if (p + it->length() <= o+l) {
+          //    'p'------- node.length() -------|
+         node.zero(0, o+l-p);
+        } else if (p + node.length() <= o+l) {
           //     'o'------------- l -----------|
-          // 'p'------- it->length() -------|
-         it->zero(o-p, it->length()-(o-p));
+          // 'p'------- node.length() -------|
+         node.zero(o-p, node.length()-(o-p));
         } else {
           //       'o'----------- l -----------|
-          // 'p'---------- it->length() ----------|
-          it->zero(o-p, l);
+          // 'p'---------- node.length() ----------|
+          node.zero(o-p, l);
         }
       }
-      p += it->length();
-      if (o+l <= p)
+      p += node.length();
+      if (o+l <= p) {
        break;  // done
+      }
     }
   }
 
@@ -1341,11 +1336,9 @@ using namespace ceph;
   void buffer::list::rebuild(ptr& nb)
   {
     unsigned pos = 0;
-    for (buffers_t::iterator it = _buffers.begin();
-        it != _buffers.end();
-        ++it) {
-      nb.copy_in(pos, it->length(), it->c_str(), false);
-      pos += it->length();
+    for (auto& node : _buffers) {
+      nb.copy_in(pos, node.length(), node.c_str(), false);
+      pos += node.length();
     }
     _memcopy_count += pos;
     _buffers.clear();
@@ -1370,8 +1363,8 @@ using namespace ceph;
        && _len > (max_buffers * align_size)) {
       align_size = round_up_to(round_up_to(_len, max_buffers) / max_buffers, align_size);
     }
-    buffers_t::iterator p = _buffers.begin();
-    while (p != _buffers.end()) {
+    auto p = std::begin(_buffers);
+    while (p != std::end(_buffers)) {
       // keep anything that's already align and sized aligned
       if (p->is_aligned(align_memory) && p->is_n_align_sized(align_size)) {
         /*cout << " segment " << (void*)p->c_str()
@@ -1396,7 +1389,7 @@ using namespace ceph;
         offset += p->length();
         unaligned.push_back(*p);
         p = _buffers.erase(p);
-      } while (p != _buffers.end() &&
+      } while (p != std::end(_buffers) &&
             (!p->is_aligned(align_memory) ||
              !p->is_n_align_sized(align_size) ||
              (offset % align_size)));
@@ -1439,7 +1432,7 @@ using namespace ceph;
     _len += bl._len;
     if (!(flags & CLAIM_ALLOW_NONSHAREABLE))
       bl.make_shareable();
-    std::move(bl._buffers.begin(), bl._buffers.end(),
+    std::move(std::begin(bl._buffers), std::end(bl._buffers),
       std::back_inserter(_buffers));
     bl._buffers.clear();
     bl._len = 0;
@@ -1449,9 +1442,8 @@ using namespace ceph;
   void buffer::list::claim_append_piecewise(list& bl)
   {
     // steal the other guy's buffers
-    for (buffers_t::const_iterator i = bl.buffers().begin();
-        i != bl.buffers().end(); ++i) {
-      append(*i, 0, i->length());
+    for (const auto& node : bl.buffers()) {
+      append(node, 0, node.length());
     }
     bl.clear();
   }
@@ -1569,10 +1561,9 @@ using namespace ceph;
   void buffer::list::append(const list& bl)
   {
     _len += bl._len;
-    for (buffers_t::const_iterator p = bl._buffers.begin();
-        p != bl._buffers.end();
-        ++p) 
-      _buffers.push_back(*p);
+    for (const auto& node : bl._buffers) {
+      _buffers.push_back(node);
+    }
   }
 
   void buffer::list::append(std::istream& in)
@@ -1637,14 +1628,12 @@ using namespace ceph;
     if (n >= _len)
       throw end_of_buffer();
     
-    for (buffers_t::const_iterator p = _buffers.begin();
-        p != _buffers.end();
-        ++p) {
-      if (n >= p->length()) {
-       n -= p->length();
+    for (const auto& node : _buffers) {
+      if (n >= node.length()) {
+       n -= node.length();
        continue;
       }
-      return (*p)[n];
+      return node[n];
     }
     ceph_abort();
   }
@@ -1657,22 +1646,21 @@ using namespace ceph;
     if (_buffers.empty())
       return 0;                         // no buffers
 
-    buffers_t::const_iterator iter = _buffers.begin();
+    auto iter = std::cbegin(_buffers);
     ++iter;
 
-    if (iter != _buffers.end())
+    if (iter != std::cend(_buffers)) {
       rebuild();
+    }
     return _buffers.front().c_str();  // good, we're already contiguous.
   }
 
   string buffer::list::to_str() const {
     string s;
     s.reserve(length());
-    for (buffers_t::const_iterator p = _buffers.begin();
-        p != _buffers.end();
-        ++p) {
-      if (p->length()) {
-       s.append(p->c_str(), p->length());
+    for (const auto& node : _buffers) {
+      if (node.length()) {
+       s.append(node.c_str(), node.length());
       }
     }
     return s;
@@ -1686,15 +1674,14 @@ using namespace ceph;
     clear();
 
     // skip off
-    buffers_t::const_iterator curbuf = other._buffers.begin();
-    while (off > 0 &&
-          off >= curbuf->length()) {
+    auto curbuf = std::cbegin(other._buffers);
+    while (off > 0 && off >= curbuf->length()) {
       // skip this buffer
       //cout << "skipping over " << *curbuf << std::endl;
       off -= (*curbuf).length();
       ++curbuf;
     }
-    ceph_assert(len == 0 || curbuf != other._buffers.end());
+    ceph_assert(len == 0 || curbuf != std::cend(other._buffers));
     
     while (len > 0) {
       // partial?
@@ -1729,9 +1716,9 @@ using namespace ceph;
     //cout << "splice off " << off << " len " << len << " ... mylen = " << length() << std::endl;
       
     // skip off
-    buffers_t::iterator curbuf = _buffers.begin();
+    auto curbuf = std::begin(_buffers);
     while (off > 0) {
-      ceph_assert(curbuf != _buffers.end());
+      ceph_assert(curbuf != std::end(_buffers));
       if (off >= (*curbuf).length()) {
        // skip this buffer
        //cout << "off = " << off << " skipping over " << *curbuf << std::endl;
@@ -1785,19 +1772,11 @@ using namespace ceph;
   {
     list s;
     s.substr_of(*this, off, len);
-    for (buffers_t::const_iterator it = s._buffers.begin(); 
-        it != s._buffers.end(); 
-        ++it)
-      if (it->length())
-       out.write(it->c_str(), it->length());
-    /*iterator p(this, off);
-      while (len > 0 && !p.end()) {
-      int l = p.left_in_this_buf();
-      if (l > len)
-      l = len;
-      out.write(p.c_str(), l);
-      len -= l;
-      }*/
+    for (const auto& node : s._buffers) {
+      if (node.length()) {
+       out.write(node.c_str(), node.length());
+      }
+    }
   }
   
 void buffer::list::encode_base64(buffer::list& o)
@@ -1951,8 +1930,8 @@ int buffer::list::write_fd(int fd) const
   int iovlen = 0;
   ssize_t bytes = 0;
 
-  buffers_t::const_iterator p = _buffers.begin();
-  while (p != _buffers.end()) {
+  auto p = std::cbegin(_buffers);
+  while (p != std::cend(_buffers)) {
     if (p->length() > 0) {
       iov[iovlen].iov_base = (void *)p->c_str();
       iov[iovlen].iov_len = p->length();
@@ -2000,8 +1979,8 @@ int buffer::list::write_fd(int fd, uint64_t offset) const
 {
   iovec iov[IOV_MAX];
 
-  buffers_t::const_iterator p = _buffers.begin();
-  uint64_t left_pbrs = _buffers.size();
+  auto p = std::cbegin(_buffers);
+  uint64_t left_pbrs = std::size(_buffers);
   while (left_pbrs) {
     ssize_t bytes = 0;
     unsigned iovlen = 0;
@@ -2030,12 +2009,10 @@ __u32 buffer::list::crc32c(__u32 crc) const
   int cache_hits = 0;
   int cache_adjusts = 0;
 
-  for (buffers_t::const_iterator it = _buffers.begin();
-       it != _buffers.end();
-       ++it) {
-    if (it->length()) {
-      raw *r = it->get_raw();
-      pair<size_t, size_t> ofs(it->offset(), it->offset() + it->length());
+  for (const auto& node : _buffers) {
+    if (node.length()) {
+      raw* const r = node.get_raw();
+      pair<size_t, size_t> ofs(node.offset(), node.offset() + node.length());
       pair<uint32_t, uint32_t> ccrc;
       if (r->get_crc(ofs, &ccrc)) {
        if (ccrc.first == crc) {
@@ -2051,13 +2028,13 @@ __u32 buffer::list::crc32c(__u32 crc) const
           * http://crcutil.googlecode.com/files/crc-doc.1.0.pdf
           * note, u for our crc32c implementation is 0
           */
-         crc = ccrc.second ^ ceph_crc32c(ccrc.first ^ crc, NULL, it->length());
+         crc = ccrc.second ^ ceph_crc32c(ccrc.first ^ crc, NULL, node.length());
          cache_adjusts++;
        }
       } else {
        cache_misses++;
        uint32_t base = crc;
-       crc = ceph_crc32c(crc, (unsigned char*)it->c_str(), it->length());
+       crc = ceph_crc32c(crc, (unsigned char*)node.c_str(), node.length());
        r->set_crc(ofs, make_pair(base, crc));
       }
     }
@@ -2077,8 +2054,8 @@ __u32 buffer::list::crc32c(__u32 crc) const
 
 void buffer::list::invalidate_crc()
 {
-  for (buffers_t::const_iterator p = _buffers.begin(); p != _buffers.end(); ++p) {
-    raw *r = p->get_raw();
+  for (const auto& node : _buffers) {
+    raw* const r = node.get_raw();
     if (r) {
       r->invalidate_crc();
     }
@@ -2104,9 +2081,9 @@ sha1_digest_t buffer::list::sha1()
  */
 void buffer::list::write_stream(std::ostream &out) const
 {
-  for (buffers_t::const_iterator p = _buffers.begin(); p != _buffers.end(); ++p) {
-    if (p->length() > 0) {
-      out.write(p->c_str(), p->length());
+  for (const auto& node : _buffers) {
+    if (node.length() > 0) {
+      out.write(node.c_str(), node.length());
     }
   }
 }
@@ -2221,11 +2198,11 @@ std::ostream& buffer::operator<<(std::ostream& out, const buffer::ptr& bp) {
 std::ostream& buffer::operator<<(std::ostream& out, const buffer::list& bl) {
   out << "buffer::list(len=" << bl.length() << "," << std::endl;
 
-  buffer::list::buffers_t::const_iterator it = bl.buffers().begin();
-  while (it != bl.buffers().end()) {
-    out << "\t" << *it;
-    if (++it == bl.buffers().end()) break;
-    out << "," << std::endl;
+  for (const auto& node : bl.buffers()) {
+    out << "\t" << node;
+    if (&node != &bl.buffers().back()) {
+      out << "," << std::endl;
+    }
   }
   out << std::endl << ")";
   return out;

diff --git a/src/kv/LevelDBStore.cc b/src/kv/LevelDBStore.cc
index 75fdaa2cd5fdd3038f45dd771df28a915e88d676..a02aacf23ffe738bfdc06af7e0bdb0e34094997d 100644 (file)
--- a/src/kv/LevelDBStore.cc
+++ b/src/kv/LevelDBStore.cc
@@ -255,10 +255,9 @@ void LevelDBStore::LevelDBTransactionImpl::set(
     // make sure the buffer isn't too large or we might crash here...    
     char* slicebuf = (char*) alloca(bllen);
     leveldb::Slice newslice(slicebuf, bllen);
-    ceph::bufferlist::buffers_t::const_iterator pb;
-    for (pb = to_set_bl.buffers().begin(); pb != to_set_bl.buffers().end(); ++pb) {
-      size_t ptrlen = (*pb).length();
-      memcpy((void*)slicebuf, (*pb).c_str(), ptrlen);
+    for (const auto& node : to_set_bl.buffers()) {
+      const size_t ptrlen = node.length();
+      memcpy(static_cast<void*>(slicebuf), node.c_str(), ptrlen);
       slicebuf += ptrlen;
     } 
     bat.Put(leveldb::Slice(key), newslice);

diff --git a/src/messages/MDataPing.h b/src/messages/MDataPing.h
index c45d3c768707f4522b21f0a0f89bf40ec4dd187a..8540d05f781f6feb3954c4e72456d9a101df7068 100644 (file)
--- a/src/messages/MDataPing.h
+++ b/src/messages/MDataPing.h
@@ -64,10 +64,8 @@ private:
        mdata_hook(&mp);
 
       if (free_data)  {
-       const ceph::bufferlist::buffers_t& buffers = data.buffers();
-       ceph::bufferlist::buffers_t::const_iterator pb;
-       for (pb = buffers.begin(); pb != buffers.end(); ++pb) {
-         free((void*) pb->c_str());
+       for (const auto& node : data.buffers()) {
+         free(const_cast<void*>(static_cast<const void*>(node.c_str())));
        }
       }
     }

diff --git a/src/msg/async/PosixStack.cc b/src/msg/async/PosixStack.cc
index 2f354a6db0061917feba786a308a2f7d1fd1cc2c..9411a31de311c38359e7da1ba87a065326cb087c 100644 (file)
--- a/src/msg/async/PosixStack.cc
+++ b/src/msg/async/PosixStack.cc
@@ -112,8 +112,8 @@ class PosixConnectedSocketImpl final : public ConnectedSocketImpl {
 
   ssize_t send(bufferlist &bl, bool more) override {
     size_t sent_bytes = 0;
-    ceph::bufferlist::buffers_t::const_iterator pb = bl.buffers().begin();
-    uint64_t left_pbrs = bl.buffers().size();
+    auto pb = std::cbegin(bl.buffers());
+    uint64_t left_pbrs = std::size(bl.buffers());
     while (left_pbrs) {
       struct msghdr msg;
       struct iovec msgvec[IOV_MAX];

diff --git a/src/msg/async/rdma/RDMAConnectedSocketImpl.cc b/src/msg/async/rdma/RDMAConnectedSocketImpl.cc
index 3776e70fa3cebb35de9e212102a4a80076018658..bf9d072ef9a55019ef557e6e119b1fc3f587f58c 100644 (file)
--- a/src/msg/async/rdma/RDMAConnectedSocketImpl.cc
+++ b/src/msg/async/rdma/RDMAConnectedSocketImpl.cc
@@ -446,9 +446,10 @@ ssize_t RDMAConnectedSocketImpl::submit(bool more)
   if (!bytes)
     return 0;
 
-  auto fill_tx_via_copy = [this](std::vector<Chunk*> &tx_buffers, unsigned bytes,
-                                 ceph::bufferlist::buffers_t::const_iterator &start,
-                                 ceph::bufferlist::buffers_t::const_iterator &end) -> unsigned {
+  auto fill_tx_via_copy = [this](std::vector<Chunk*> &tx_buffers,
+                                 unsigned bytes,
+                                 auto& start,
+                                 const auto& end) -> unsigned {
     ceph_assert(start != end);
     auto chunk_idx = tx_buffers.size();
     int ret = worker->get_reged_mem(this, tx_buffers, bytes);
@@ -481,8 +482,8 @@ ssize_t RDMAConnectedSocketImpl::submit(bool more)
   };
 
   std::vector<Chunk*> tx_buffers;
-  ceph::bufferlist::buffers_t::const_iterator it = pending_bl.buffers().begin();
-  ceph::bufferlist::buffers_t::const_iterator copy_it = it;
+  auto it = std::cbegin(pending_bl.buffers());
+  auto copy_it = it;
   unsigned total = 0;
   unsigned need_reserve_bytes = 0;
   while (it != pending_bl.buffers().end()) {

diff --git a/src/msg/simple/Pipe.cc b/src/msg/simple/Pipe.cc
index 0c65effc83ea2ede6433ae8a4208d4e2dac8c478..f0a2a4b1ca65d0e741fd946fd8051e5b163332a8 100644 (file)
--- a/src/msg/simple/Pipe.cc
+++ b/src/msg/simple/Pipe.cc
@@ -2408,7 +2408,7 @@ int Pipe::write_message(const ceph_msg_header& header, const ceph_msg_footer& fo
   msg.msg_iovlen++;
 
   // payload (front+data)
-  ceph::bufferlist::buffers_t::const_iterator pb = blist.buffers().begin();
+  auto pb = std::cbegin(blist.buffers());
   unsigned b_off = 0;  // carry-over buffer offset, if any
   unsigned bl_pos = 0; // blist pos
   unsigned left = blist.length();

diff --git a/src/os/filestore/FileJournal.cc b/src/os/filestore/FileJournal.cc
index e1b1fd4ecb7116ba1b71bf2bf70ce9082ec590f3..b17ddcc023506ebe19fad0f6bd49c75ff20025d9 100644 (file)
--- a/src/os/filestore/FileJournal.cc
+++ b/src/os/filestore/FileJournal.cc
@@ -1372,11 +1372,9 @@ int FileJournal::write_aio_bl(off64_t& pos, bufferlist& bl, uint64_t seq)
     iovec *iov = new iovec[max];
     int n = 0;
     unsigned len = 0;
-    for (ceph::bufferlist::buffers_t::const_iterator p = bl.buffers().begin();
-        n < max;
-        ++p, ++n) {
-      ceph_assert(p != bl.buffers().end());
-      iov[n].iov_base = (void *)p->c_str();
+    for (auto p = std::cbegin(bl.buffers()); n < max; ++p, ++n) {
+      ceph_assert(p != std::cend(bl.buffers()));
+      iov[n].iov_base = const_cast<void*>(static_cast<const void*>(p->c_str()));
       iov[n].iov_len = p->length();
       len += p->length();
     }

diff --git a/src/rgw/rgw_file.cc b/src/rgw/rgw_file.cc
index 1e5872656a70d19ccd0c94a34185cf40f763983f..16bf507bbb4bc98e90e3bc4576f20f5f21a65fb5 100644 (file)
--- a/src/rgw/rgw_file.cc
+++ b/src/rgw/rgw_file.cc
@@ -2186,7 +2186,7 @@ public:
 
   struct rgw_vio* get_vio() { return vio; }
 
-  const buffer::list::buffers_t& buffers() { return bl.buffers(); }
+  const auto& buffers() { return bl.buffers(); }
 
   unsigned /* XXX */ length() { return bl.length(); }