update sources to v12.2.5

[ceph.git] / ceph / src / include / compact_map.h

diff --git a/ceph/src/include/compact_map.h b/ceph/src/include/compact_map.h
index 975baa064d3dd312464bbcdb8394445607f49901..7e0e293c0f2ae579a2b8a42862bd3df0552b447e 100644 (file)
--- a/ceph/src/include/compact_map.h
+++ b/ceph/src/include/compact_map.h
@@ -12,21 +12,22 @@
 #ifndef CEPH_COMPACT_MAP_H
 #define CEPH_COMPACT_MAP_H
 
+#include "buffer.h"
+#include "encoding.h"
+
 #include <map>
+#include <memory>
 
 template <class Key, class T, class Map>
 class compact_map_base {
 protected:
-  Map *map;
+  std::unique_ptr<Map> map;
   void alloc_internal() {
     if (!map)
-      map = new Map;
+      map.reset(new Map);
   }
   void free_internal() {
-    if (map) {
-      delete map;
-      map = 0;
-    }
+    map.reset();
   }
   template <class It>
   class const_iterator_base {
@@ -154,14 +155,14 @@ public:
       const_reverse_iterator(const compact_map_base* m, const typename Map::const_reverse_iterator& i)
        : const_iterator_base<typename Map::const_reverse_iterator>(m, i) { }
   };
-  compact_map_base() : map(0) {}
-  compact_map_base(const compact_map_base& o) : map(0) {
+  compact_map_base(const compact_map_base& o) {
     if (o.map) {
       alloc_internal();
       *map = *o.map;
     }
   }
-  ~compact_map_base() { delete map; }
+  compact_map_base() {}
+  ~compact_map_base() {}
 
   bool empty() const {
     return !map || map->empty();
@@ -178,12 +179,18 @@ public:
   size_t count (const Key& k) const {
     return map ? map->count(k) : 0;
   }
-  void erase (iterator p) {
+  iterator erase (iterator p) {
     if (map) {
       assert(this == p.map);
-      map->erase(p.it);
-      if (map->empty())
-       free_internal();
+      auto it = map->erase(p.it);
+      if (map->empty()) {
+        free_internal();
+        return iterator(this);
+      } else {
+        return iterator(this, it);
+      }
+    } else {
+      return iterator(this);
     }
   }
   size_t erase (const Key& k) {
@@ -198,9 +205,7 @@ public:
     free_internal();
   }
   void swap(compact_map_base& o) {
-    Map *tmp = map;
-    map = o.map;
-    o.map = tmp;
+    map.swap(o.map);
   }
   compact_map_base& operator=(const compact_map_base& o) {
     if (o.map) {
@@ -214,6 +219,12 @@ public:
     alloc_internal();
     return iterator(this, map->insert(val));
   }
+  template <class... Args>
+  std::pair<iterator,bool> emplace ( Args&&... args ) {
+    alloc_internal();
+    auto em = map->emplace(std::forward<Args>(args)...);
+    return std::pair<iterator,bool>(iterator(this, em.first), em.second);
+  }
   iterator begin() {
    if (!map)
      return iterator(this);
@@ -321,8 +332,8 @@ inline void decode(compact_map_base<Key, T, Map>& m, bufferlist::iterator& p) {
   m.decode(p);
 }
 
-template <class Key, class T>
-class compact_map : public compact_map_base<Key, T, std::map<Key,T> > {
+template <class Key, class T, class Compare = std::less<Key>, class Alloc = std::allocator< std::pair<const Key, T> > >
+class compact_map : public compact_map_base<Key, T, std::map<Key,T,Compare,Alloc> > {
 public:
   T& operator[](const Key& k) {
     this->alloc_internal();
@@ -330,33 +341,35 @@ public:
   }
 };
 
-template <class Key, class T>
-inline std::ostream& operator<<(std::ostream& out, const compact_map<Key, T>& m)
+template <class Key, class T, class Compare = std::less<Key>, class Alloc = std::allocator< std::pair<const Key, T> > >
+inline std::ostream& operator<<(std::ostream& out, const compact_map<Key, T, Compare, Alloc>& m)
 {
   out << "{";
-  for (typename compact_map<Key, T>::const_iterator it = m.begin();
-       it != m.end();
-       ++it) {
-    if (it != m.begin())
+  bool first = true;
+  for (const auto &p : m) {
+    if (!first)
       out << ",";
-    out << it->first << "=" << it->second;
+    out << p.first << "=" << p.second;
+    first = false;
   }
   out << "}";
   return out;
 }
 
-template <class Key, class T>
-class compact_multimap : public compact_map_base<Key, T, std::multimap<Key,T> > {
+template <class Key, class T, class Compare = std::less<Key>, class Alloc = std::allocator< std::pair<const Key, T> > >
+class compact_multimap : public compact_map_base<Key, T, std::multimap<Key,T,Compare,Alloc> > {
 };
 
-template <class Key, class T>
-inline std::ostream& operator<<(std::ostream& out, const compact_multimap<Key, T>& m)
+template <class Key, class T, class Compare = std::less<Key>, class Alloc = std::allocator< std::pair<const Key, T> > >
+inline std::ostream& operator<<(std::ostream& out, const compact_multimap<Key, T, Compare, Alloc>& m)
 {
   out << "{{";
-  for (typename compact_map<Key, T>::const_iterator it = m.begin(); !it.end(); ++it) {
-    if (it != m.begin())
+  bool first = true;
+  for (const auto &p : m) {
+    if (!first)
       out << ",";
-    out << it->first << "=" << it->second;
+    out << p.first << "=" << p.second;
+    first = false;
   }
   out << "}}";
   return out;