cc/base/scoped_ptr_hash_map.h

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_BASE_SCOPED_PTR_HASH_MAP_H_
   6 #define CC_BASE_SCOPED_PTR_HASH_MAP_H_
   7
   8 #include <algorithm>
   9 #include <utility>
  10
  11 #include "base/basictypes.h"
  12 #include "base/hash_tables.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/stl_util.h"
  16
  17 namespace cc {
  18
  19 // This type acts like a hash_map<K, scoped_ptr<V> >, based on top of
  20 // base::hash_map. The ScopedPtrHashMap has ownership of all values in the data
  21 // structure.
  22 template <typename Key, typename Value>
  23 class ScopedPtrHashMap {
  24   typedef base::hash_map<Key, Value*> Container;
  25
  26  public:
  27   typedef typename Container::iterator iterator;
  28   typedef typename Container::const_iterator const_iterator;
  29
  30   ScopedPtrHashMap() {}
  31
  32   ~ScopedPtrHashMap() { clear(); }
  33
  34   void swap(ScopedPtrHashMap<Key, Value*>& other) {
  35     data_.swap(other.data_);
  36   }
  37
  38   std::pair<iterator, bool> insert(
  39       std::pair<Key, const scoped_ptr<Value> > pair) {
  40     return data_.insert(
  41         std::pair<Key, Value*>(pair.first, pair.second.release()));
  42   }
  43
  44   // Replaces value but not key if key is already present.
  45   std::pair<iterator, bool> set(Key key, scoped_ptr<Value> data) {
  46     iterator it = find(key);
  47     if (it != end())
  48       erase(it);
  49     Value* raw_ptr = data.release();
  50     return data_.insert(std::pair<Key, Value*>(key, raw_ptr));
  51   }
  52
  53   // Does nothing if key is already present
  54   std::pair<iterator, bool> add(Key key, scoped_ptr<Value> data) {
  55     Value* raw_ptr = data.release();
  56     return data_.insert(std::pair<Key, Value*>(key, raw_ptr));
  57   }
  58
  59   void erase(iterator it) {
  60     if (it->second)
  61       delete it->second;
  62     data_.erase(it);
  63   }
  64
  65   size_t erase(const Key& k) {
  66     iterator it = data_.find(k);
  67     if (it == data_.end())
  68       return 0;
  69     erase(it);
  70     return 1;
  71   }
  72
  73   scoped_ptr<Value> take(iterator it) {
  74     DCHECK(it != data_.end());
  75     if (it == data_.end())
  76       return scoped_ptr<Value>(NULL);
  77
  78     Key key = it->first;
  79     scoped_ptr<Value> ret(it->second);
  80     data_.erase(it);
  81     data_.insert(std::pair<Key, Value*>(key, static_cast<Value*>(NULL)));
  82     return ret.Pass();
  83   }
  84
  85   scoped_ptr<Value> take(const Key& k) {
  86     iterator it = find(k);
  87     if (it == data_.end())
  88       return scoped_ptr<Value>(NULL);
  89
  90     return take(it);
  91   }
  92
  93   scoped_ptr<Value> take_and_erase(iterator it) {
  94     DCHECK(it != data_.end());
  95     if (it == data_.end())
  96       return scoped_ptr<Value>(NULL);
  97
  98     scoped_ptr<Value> ret(it->second);
  99     data_.erase(it);
 100     return ret.Pass();
 101   }
 102
 103   scoped_ptr<Value> take_and_erase(const Key& k) {
 104     iterator it = find(k);
 105     if (it == data_.end())
 106       return scoped_ptr<Value>(NULL);
 107
 108     return take_and_erase(it);
 109   }
 110
 111   // Returns the first element in the hash_map that matches the given key.
 112   // If no such element exists it returns NULL.
 113   Value* get(const Key& k) const {
 114     const_iterator it = find(k);
 115     if (it == end())
 116       return 0;
 117     return it->second;
 118   }
 119
 120   inline bool contains(const Key& k) const { return data_.count(k) > 0; }
 121
 122   inline void clear() { STLDeleteValues(&data_); }
 123
 124   inline const_iterator find(const Key& k) const { return data_.find(k); }
 125   inline iterator find(const Key& k) { return data_.find(k); }
 126
 127   inline size_t count(const Key& k) const { return data_.count(k); }
 128   inline std::pair<const_iterator, const_iterator> equal_range(
 129       const Key& k) const {
 130     return data_.equal_range(k);
 131   }
 132   inline std::pair<iterator, iterator> equal_range(const Key& k) {
 133     return data_.equal_range(k);
 134   }
 135
 136   inline size_t size() const { return data_.size(); }
 137   inline size_t max_size() const { return data_.max_size(); }
 138
 139   inline bool empty() const { return data_.empty(); }
 140
 141   inline size_t bucket_count() const { return data_.bucket_count(); }
 142   inline void resize(size_t size) const { return data_.resize(size); }
 143
 144   inline iterator begin() { return data_.begin(); }
 145   inline const_iterator begin() const { return data_.begin(); }
 146   inline iterator end() { return data_.end(); }
 147   inline const_iterator end() const { return data_.end(); }
 148
 149  private:
 150   Container data_;
 151
 152   DISALLOW_COPY_AND_ASSIGN(ScopedPtrHashMap);
 153 };
 154
 155 }  // namespace cc
 156
 157 #endif  // CC_BASE_SCOPED_PTR_HASH_MAP_H_