compact_*: support mempool allocated containers

Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>

diff --git a/src/include/compact_map.h b/src/include/compact_map.h
index 1fa286e89843b8b143618a16e7b7e823cb851d6c..52a7792adc8e0fb50c06b7bf8ce673051e40d316 100644 (file)
--- a/src/include/compact_map.h
+++ b/src/include/compact_map.h
@@ -12,23 +12,24 @@
 #ifndef CEPH_COMPACT_MAP_H
 #define CEPH_COMPACT_MAP_H
 
+#include "buffer.h"
+#include "encoding.h"
+
 #include <map>
+#include <memory>
 
 #include "include/encoding.h"
 
 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 {
@@ -156,14 +157,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();
@@ -184,8 +185,9 @@ public:
     if (map) {
       assert(this == p.map);
       map->erase(p.it);
-      if (map->empty())
-       free_internal();
+      if (map->empty()) {
+        free_internal();
+      }
     }
   }
   size_t erase (const Key& k) {
@@ -200,9 +202,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) {
@@ -327,8 +327,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();
@@ -336,33 +336,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;

diff --git a/src/include/compact_set.h b/src/include/compact_set.h
index dcbeec12a3e683284c2439aac0476dd047aaa85e..dd2ddd31165cd81ae5a94426a6f32a6cdf2c6408 100644 (file)
--- a/src/include/compact_set.h
+++ b/src/include/compact_set.h
@@ -12,25 +12,22 @@
 #ifndef CEPH_COMPACT_SET_H
 #define CEPH_COMPACT_SET_H
 
-#include <stdlib.h>
-
-#include "include/buffer.h"
-#include "include/encoding.h"
+#include "buffer.h"
+#include "encoding.h"
 
+#include <memory>
+#include <set>
 
 template <class T, class Set>
 class compact_set_base {
 protected:
-  Set *set;
+  std::unique_ptr<Set> set;
   void alloc_internal() {
     if (!set)
-      set = new Set;
+      set.reset(new Set);
   }
   void free_internal() {
-    if (set) {
-      delete set;
-      set = 0;
-    }
+    set.reset();
   }
   template <class It>
   class iterator_base {
@@ -118,14 +115,14 @@ public:
       }
   };
 
-  compact_set_base() : set(0) {}
-  compact_set_base(const compact_set_base& o) : set(0) {
+  compact_set_base() {}
+  compact_set_base(const compact_set_base& o) {
     if (o.set) {
       alloc_internal();
       *set = *o.set;
     }
   }
-  ~compact_set_base() { delete set; }
+  ~compact_set_base() {}
 
 
   bool empty() const {
@@ -148,7 +145,7 @@ public:
       assert(this == p.set);
       set->erase(p.it);
       if (set->empty())
-       free_internal();
+        free_internal();
     }
   }
   size_t erase (const T& t) {
@@ -156,16 +153,14 @@ public:
       return 0;
     size_t r = set->erase(t);
     if (set->empty())
-       free_internal();
+      free_internal();
     return r;
   }
   void clear() {
     free_internal();
   }
   void swap(compact_set_base& o) {
-    Set *tmp = set;
-    set = o.set;
-    o.set = tmp;
+    set.swap(o.set);
   }
   compact_set_base& operator=(const compact_set_base& o) {
     if (o.set) {
@@ -278,18 +273,19 @@ inline void decode(compact_set_base<T, Set>& m, bufferlist::iterator& p) {
   m.decode(p);
 }
 
-template <class T>
-class compact_set : public compact_set_base<T, std::set<T> > {
+template <class T, class Compare = std::less<T>, class Alloc = std::allocator<T> >
+class compact_set : public compact_set_base<T, std::set<T, Compare, Alloc> > {
 };
 
-template <class T>
-inline std::ostream& operator<<(std::ostream& out, const compact_set<T>& s)
+template <class T, class Compare = std::less<T>, class Alloc = std::allocator<T> >
+inline std::ostream& operator<<(std::ostream& out, const compact_set<T,Compare,Alloc>& s)
 {
-  for (typename compact_set<T>::const_iterator it = s.begin();
-       it != s.end(); ++it) {
-    if (it != s.begin())
+  bool first = true;
+  for (auto &v : s) {
+    if (!first)
       out << ",";
-    out << it->first << "=" << it->second;
+    out << v;
+    first = false;
   }
   return out;
 }

diff --git a/src/include/frag.h b/src/include/frag.h
index 0b7977acf1d09c04317394233f71b3f54781f5eb..4ca46cd03f599b5850ecf521b3ebab2f7aea2d6b 100644 (file)
--- a/src/include/frag.h
+++ b/src/include/frag.h
@@ -163,10 +163,10 @@ inline std::ostream& operator<<(std::ostream& out, const frag_t& hb)
   return out << '*';
 }
 
-inline void encode(frag_t f, bufferlist& bl) { encode_raw(f._enc, bl); }
-inline void decode(frag_t &f, bufferlist::iterator& p) { 
+inline void encode(const frag_t &f, bufferlist& bl) { encode_raw(f._enc, bl); }
+inline void decode(frag_t &f, bufferlist::iterator& p) {
   __u32 v;
-  decode_raw(v, p); 
+  decode_raw(v, p);
   f._enc = v;
 }
 

diff --git a/src/include/mempool.h b/src/include/mempool.h
index 99dbcc9738fcd8526b8ac12b3a10e81f42ae6861..60f6326d357dab4db111d21ffa2765d1931fde48 100644 (file)
--- a/src/include/mempool.h
+++ b/src/include/mempool.h
@@ -29,6 +29,8 @@
 
 #include <common/Formatter.h>
 #include "include/assert.h"
+#include "include/compact_map.h"
+#include "include/compact_set.h"
 
 
 /*
@@ -399,6 +401,13 @@ public:
     using map = std::map<k, v, cmp,                                    \
                         pool_allocator<std::pair<const k,v>>>;         \
                                                                         \
+    template<typename k,typename v, typename cmp = std::less<k> >       \
+    using compact_map = compact_map<k, v, cmp,                          \
+                        pool_allocator<std::pair<const k,v>>>;         \
+                                                                        \
+    template<typename k, typename cmp = std::less<k> >                  \
+    using compact_set = compact_set<k, cmp, pool_allocator<k>>;         \
+                                                                        \
     template<typename k,typename v, typename cmp = std::less<k> >      \
     using multimap = std::multimap<k,v,cmp,                            \
                                   pool_allocator<std::pair<const k,    \