#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 {
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();
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) {
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) {
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);
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();
}
};
-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;