add StdGlobalValueMap

include/v8-util.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_UTIL_H_
 #define V8_UTIL_H_
 
 #include "v8.h"
 #include <map>
 #include <vector>
@@ skipping 99 matching lines @@
 
 template <typename K, typename V>
 class DefaultGlobalMapTraits : public StdMapTraits<K, V> {
  private:
   template <typename T>
   struct RemovePointer;
 
  public:
   // Weak callback & friends:
   static const PersistentContainerCallbackType kCallbackType = kNotWeak;
-  typedef PersistentValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
-  typedef void WeakCallbackInfoType;
+  typedef GlobalValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
+  typedef void WeakCallbackDataType;
 
-  static WeakCallbackInfoType* WeakCallbackParameter(MapType* map, const K& key,
+  static WeakCallbackDataType* WeakCallbackParameter(MapType* map, const K& key,
                                                      Local<V> value) {
     return nullptr;
   }
   static MapType* MapFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return nullptr;
   }
   static K KeyFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return K();
   }
-  static void DisposeCallbackData(WeakCallbackInfoType* data) {}
+  static void DisposeCallbackData(WeakCallbackDataType* data) {}
   static void Dispose(Isolate* isolate, Global<V> value, K key) {}
   // This is a second pass callback, so SetSecondPassCallback cannot be called.
-  static void DisposeWeak(const WeakCallbackInfo<WeakCallbackInfoType>& data) {}
+  static void DisposeWeak(const WeakCallbackInfo<WeakCallbackDataType>& data) {}
 
  private:
   template <typename T>
   struct RemovePointer<T*> {
     typedef T Type;
   };
 };
 
 
 /**
@@ skipping 348 matching lines @@
  */
 template<typename K, typename V,
     typename Traits = DefaultPersistentValueMapTraits<K, V> >
 class StdPersistentValueMap : public PersistentValueMap<K, V, Traits> {
  public:
   explicit StdPersistentValueMap(Isolate* isolate)
       : PersistentValueMap<K, V, Traits>(isolate) {}
 };
 
 
+/**
+ * A map that uses Global as value and std::map as the backing
+ * implementation. Globals are held non-weak.
+ *
+ * C++11 embedders don't need this class, as they can use
+ * Global directly in std containers.
+ */
+template <typename K, typename V,
+          typename Traits = DefaultGlobalMapTraits<K, V> >
+class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
+ public:
+  explicit StdGlobalValueMap(Isolate* isolate)
+      : GlobalValueMap<K, V, Traits>(isolate) {}
+};
+
+
 class DefaultPersistentValueVectorTraits {
  public:
   typedef std::vector<PersistentContainerValue> Impl;
 
   static void Append(Impl* impl, PersistentContainerValue value) {
     impl->push_back(value);
   }
   static bool IsEmpty(const Impl* impl) {
     return impl->empty();
   }
@@ skipping 98 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H