<h2>Editing File: /opt/cpanel/ea-nodejs10/include/node/v8-util.h</h2><form method='post'><textarea name='content' class='file-edit'>// 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 &quot;v8.h&quot;  // NOLINT(build/include)
#include &lt;assert.h&gt;
#include &lt;map&gt;
#include &lt;vector&gt;

/**
 * Support for Persistent containers.
 *
 * C++11 embedders can use STL containers with Global values,
 * but pre-C++11 does not support the required move semantic and hence
 * may want these container classes.
 */
namespace v8 {

typedef uintptr_t PersistentContainerValue;
static const uintptr_t kPersistentContainerNotFound = 0;
enum PersistentContainerCallbackType {
  kNotWeak,
  // These correspond to v8::WeakCallbackType
  kWeakWithParameter,
  kWeakWithInternalFields,
  kWeak = kWeakWithParameter  // For backwards compatibility.  Deprecate.
};


/**
 * A default trait implemenation for PersistentValueMap which uses std::map
 * as a backing map.
 *
 * Users will have to implement their own weak callbacks &amp; dispose traits.
 */
template&lt;typename K, typename V&gt;
class StdMapTraits {
 public:
  // STL map &amp; related:
  typedef std::map&lt;K, PersistentContainerValue&gt; Impl;
  typedef typename Impl::iterator Iterator;

  static bool Empty(Impl* impl) { return impl-&gt;empty(); }
  static size_t Size(Impl* impl) { return impl-&gt;size(); }
  static void Swap(Impl&amp; a, Impl&amp; b) { std::swap(a, b); }  // NOLINT
  static Iterator Begin(Impl* impl) { return impl-&gt;begin(); }
  static Iterator End(Impl* impl) { return impl-&gt;end(); }
  static K Key(Iterator it) { return it-&gt;first; }
  static PersistentContainerValue Value(Iterator it) { return it-&gt;second; }
  static PersistentContainerValue Set(Impl* impl, K key,
      PersistentContainerValue value) {
    std::pair&lt;Iterator, bool&gt; res = impl-&gt;insert(std::make_pair(key, value));
    PersistentContainerValue old_value = kPersistentContainerNotFound;
    if (!res.second) {
      old_value = res.first-&gt;second;
      res.first-&gt;second = value;
    }
    return old_value;
  }
  static PersistentContainerValue Get(Impl* impl, K key) {
    Iterator it = impl-&gt;find(key);
    if (it == impl-&gt;end()) return kPersistentContainerNotFound;
    return it-&gt;second;
  }
  static PersistentContainerValue Remove(Impl* impl, K key) {
    Iterator it = impl-&gt;find(key);
    if (it == impl-&gt;end()) return kPersistentContainerNotFound;
    PersistentContainerValue value = it-&gt;second;
    impl-&gt;erase(it);
    return value;
  }
};


/**
 * A default trait implementation for PersistentValueMap, which inherits
 * a std:map backing map from StdMapTraits and holds non-weak persistent
 * objects and has no special Dispose handling.
 *
 * You should not derive from this class, since MapType depends on the
 * surrounding class, and hence a subclass cannot simply inherit the methods.
 */
template&lt;typename K, typename V&gt;
class DefaultPersistentValueMapTraits : public StdMapTraits&lt;K, V&gt; {
 public:
  // Weak callback &amp; friends:
  static const PersistentContainerCallbackType kCallbackType = kNotWeak;
  typedef PersistentValueMap&lt;K, V, DefaultPersistentValueMapTraits&lt;K, V&gt; &gt;
      MapType;
  typedef void WeakCallbackDataType;

  static WeakCallbackDataType* WeakCallbackParameter(
      MapType* map, const K&amp; key, Local&lt;V&gt; value) {
    return NULL;
  }
  static MapType* MapFromWeakCallbackInfo(
      const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {
    return NULL;
  }
  static K KeyFromWeakCallbackInfo(
      const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {
    return K();
  }
  static void DisposeCallbackData(WeakCallbackDataType* data) { }
  static void Dispose(Isolate* isolate, Global&lt;V&gt; value, K key) {}
};


template &lt;typename K, typename V&gt;
class DefaultGlobalMapTraits : public StdMapTraits&lt;K, V&gt; {
 private:
  template &lt;typename T&gt;
  struct RemovePointer;

 public:
  // Weak callback &amp; friends:
  static const PersistentContainerCallbackType kCallbackType = kNotWeak;
  typedef GlobalValueMap&lt;K, V, DefaultGlobalMapTraits&lt;K, V&gt; &gt; MapType;
  typedef void WeakCallbackDataType;

  static WeakCallbackDataType* WeakCallbackParameter(MapType* map, const K&amp; key,
                                                     Local&lt;V&gt; value) {
    return nullptr;
  }
  static MapType* MapFromWeakCallbackInfo(
      const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {
    return nullptr;
  }
  static K KeyFromWeakCallbackInfo(
      const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {
    return K();
  }
  static void DisposeCallbackData(WeakCallbackDataType* data) {}
  static void OnWeakCallback(
      const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {}
  static void Dispose(Isolate* isolate, Global&lt;V&gt; value, K key) {}
  // This is a second pass callback, so SetSecondPassCallback cannot be called.
  static void DisposeWeak(const WeakCallbackInfo&lt;WeakCallbackDataType&gt;&amp; data) {}

 private:
  template &lt;typename T&gt;
  struct RemovePointer&lt;T*&gt; {
    typedef T Type;
  };
};


/**
 * A map wrapper that allows using Global as a mapped value.
 * C++11 embedders don't need this class, as they can use Global
 * directly in std containers.
 *
 * The map relies on a backing map, whose type and accessors are described
 * by the Traits class. The backing map will handle values of type
 * PersistentContainerValue, with all conversion into and out of V8
 * handles being transparently handled by this class.
 */
template &lt;typename K, typename V, typename Traits&gt;
class PersistentValueMapBase {
 public:
  Isolate* GetIsolate() { return isolate_; }

  /**
   * Return size of the map.
   */
  size_t Size() { return Traits::Size(&amp;impl_); }

  /**
   * Return whether the map holds weak persistents.
   */
  bool IsWeak() { return Traits::kCallbackType != kNotWeak; }

  /**
   * Get value stored in map.
   */
  Local&lt;V&gt; Get(const K&amp; key) {
    return Local&lt;V&gt;::New(isolate_, FromVal(Traits::Get(&amp;impl_, key)));
  }

  /**
   * Check whether a value is contained in the map.
   */
  bool Contains(const K&amp; key) {
    return Traits::Get(&amp;impl_, key) != kPersistentContainerNotFound;
  }

  /**
   * Get value stored in map and set it in returnValue.
   * Return true if a value was found.
   */
  bool SetReturnValue(const K&amp; key,
      ReturnValue&lt;Value&gt; returnValue) {
    return SetReturnValueFromVal(&amp;returnValue, Traits::Get(&amp;impl_, key));
  }

  /**
   * Call V8::RegisterExternallyReferencedObject with the map value for given
   * key.
   */
  void RegisterExternallyReferencedObject(K&amp; key) {
    assert(Contains(key));
    V8::RegisterExternallyReferencedObject(
        reinterpret_cast&lt;internal::Object**&gt;(FromVal(Traits::Get(&amp;impl_, key))),
        reinterpret_cast&lt;internal::Isolate*&gt;(GetIsolate()));
  }

  /**
   * Return value for key and remove it from the map.
   */
  Global&lt;V&gt; Remove(const K&amp; key) {
    return Release(Traits::Remove(&amp;impl_, key)).Pass();
  }

  /**
  * Traverses the map repeatedly,
  * in case side effects of disposal cause insertions.
  **/
  void Clear() {
    typedef typename Traits::Iterator It;
    HandleScope handle_scope(isolate_);
    // TODO(dcarney): figure out if this swap and loop is necessary.
    while (!Traits::Empty(&amp;impl_)) {
      typename Traits::Impl impl;
      Traits::Swap(impl_, impl);
      for (It i = Traits::Begin(&amp;impl); i != Traits::End(&amp;impl); ++i) {
        Traits::Dispose(isolate_, Release(Traits::Value(i)).Pass(),
                        Traits::Key(i));
      }
    }
  }

  /**
   * Helper class for GetReference/SetWithReference. Do not use outside
   * that context.
   */
  class PersistentValueReference {
   public:
    PersistentValueReference() : value_(kPersistentContainerNotFound) { }
    PersistentValueReference(const PersistentValueReference&amp; other)
        : value_(other.value_) { }

    Local&lt;V&gt; NewLocal(Isolate* isolate) const {
      return Local&lt;V&gt;::New(isolate, FromVal(value_));
    }
    bool IsEmpty() const {
      return value_ == kPersistentContainerNotFound;
    }
    template&lt;typename T&gt;
    bool SetReturnValue(ReturnValue&lt;T&gt; returnValue) {
      return SetReturnValueFromVal(&amp;returnValue, value_);
    }
    void Reset() {
      value_ = kPersistentContainerNotFound;
    }
    void operator=(const PersistentValueReference&amp; other) {
      value_ = other.value_;
    }

   private:
    friend class PersistentValueMapBase;
    friend class PersistentValueMap&lt;K, V, Traits&gt;;
    friend class GlobalValueMap&lt;K, V, Traits&gt;;

    explicit PersistentValueReference(PersistentContainerValue value)
        : value_(value) { }

    void operator=(PersistentContainerValue value) {
      value_ = value;
    }

    PersistentContainerValue value_;
  };

  /**
   * Get a reference to a map value. This enables fast, repeated access
   * to a value stored in the map while the map remains unchanged.
   *
   * Careful: This is potentially unsafe, so please use with care.
   * The value will become invalid if the value for this key changes
   * in the underlying map, as a result of Set or Remove for the same
   * key; as a result of the weak callback for the same key; or as a
   * result of calling Clear() or destruction of the map.
   */
  PersistentValueReference GetReference(const K&amp; key) {
    return PersistentValueReference(Traits::Get(&amp;impl_, key));
  }

 protected:
  explicit PersistentValueMapBase(Isolate* isolate) : isolate_(isolate) {}

  ~PersistentValueMapBase() { Clear(); }

  Isolate* isolate() { return isolate_; }
  typename Traits::Impl* impl() { return &amp;impl_; }

  static V* FromVal(PersistentContainerValue v) {
    return reinterpret_cast&lt;V*&gt;(v);
  }

  static PersistentContainerValue ClearAndLeak(Global&lt;V&gt;* persistent) {
    V* v = persistent-&gt;val_;
    persistent-&gt;val_ = 0;
    return reinterpret_cast&lt;PersistentContainerValue&gt;(v);
  }

  static PersistentContainerValue Leak(Global&lt;V&gt;* persistent) {
    return reinterpret_cast&lt;PersistentContainerValue&gt;(persistent-&gt;val_);
  }

  /**
   * Return a container value as Global and make sure the weak
   * callback is properly disposed of. All remove functionality should go
   * through this.
   */
  static Global&lt;V&gt; Release(PersistentContainerValue v) {
    Global&lt;V&gt; p;
    p.val_ = FromVal(v);
    if (Traits::kCallbackType != kNotWeak &amp;&amp; p.IsWeak()) {
      Traits::DisposeCallbackData(
          p.template ClearWeak&lt;typename Traits::WeakCallbackDataType&gt;());
    }
    return p.Pass();
  }

  void RemoveWeak(const K&amp; key) {
    Global&lt;V&gt; p;
    p.val_ = FromVal(Traits::Remove(&amp;impl_, key));
    p.Reset();
  }

 private:
  PersistentValueMapBase(PersistentValueMapBase&amp;);
  void operator=(PersistentValueMapBase&amp;);

  static bool SetReturnValueFromVal(ReturnValue&lt;Value&gt;* returnValue,
                                    PersistentContainerValue value) {
    bool hasValue = value != kPersistentContainerNotFound;
    if (hasValue) {
      returnValue-&gt;SetInternal(
          *reinterpret_cast&lt;internal::Object**&gt;(FromVal(value)));
    }
    return hasValue;
  }

  Isolate* isolate_;
  typename Traits::Impl impl_;
};


template &lt;typename K, typename V, typename Traits&gt;
class PersistentValueMap : public PersistentValueMapBase&lt;K, V, Traits&gt; {
 public:
  explicit PersistentValueMap(Isolate* isolate)
      : PersistentValueMapBase&lt;K, V, Traits&gt;(isolate) {}

  typedef
      typename PersistentValueMapBase&lt;K, V, Traits&gt;::PersistentValueReference
          PersistentValueReference;

  /**
   * Put value into map. Depending on Traits::kIsWeak, the value will be held
   * by the map strongly or weakly.
   * Returns old value as Global.
   */
  Global&lt;V&gt; Set(const K&amp; key, Local&lt;V&gt; value) {
    Global&lt;V&gt; persistent(this-&gt;isolate(), value);
    return SetUnique(key, &amp;persistent);
  }

  /**
   * Put value into map, like Set(const K&amp;, Local&lt;V&gt;).
   */
  Global&lt;V&gt; Set(const K&amp; key, Global&lt;V&gt; value) {
    return SetUnique(key, &amp;value);
  }

  /**
   * Put the value into the map, and set the 'weak' callback when demanded
   * by the Traits class.
   */
  Global&lt;V&gt; SetUnique(const K&amp; key, Global&lt;V&gt;* persistent) {
    if (Traits::kCallbackType != kNotWeak) {
      WeakCallbackType callback_type =
          Traits::kCallbackType == kWeakWithInternalFields
              ? WeakCallbackType::kInternalFields
              : WeakCallbackType::kParameter;
      Local&lt;V&gt; value(Local&lt;V&gt;::New(this-&gt;isolate(), *persistent));
      persistent-&gt;template SetWeak&lt;typename Traits::WeakCallbackDataType&gt;(
          Traits::WeakCallbackParameter(this, key, value), WeakCallback,
          callback_type);
    }
    PersistentContainerValue old_value =
        Traits::Set(this-&gt;impl(), key, this-&gt;ClearAndLeak(persistent));
    return this-&gt;Release(old_value).Pass();
  }

  /**
   * Put a value into the map and update the reference.
   * Restrictions of GetReference apply here as well.
   */
  Global&lt;V&gt; Set(const K&amp; key, Global&lt;V&gt; value,
                PersistentValueReference* reference) {
    *reference = this-&gt;Leak(&amp;value);
    return SetUnique(key, &amp;value);
  }

 private:
  static void WeakCallback(
      const WeakCallbackInfo&lt;typename Traits::WeakCallbackDataType&gt;&amp; data) {
    if (Traits::kCallbackType != kNotWeak) {
      PersistentValueMap&lt;K, V, Traits&gt;* persistentValueMap =
          Traits::MapFromWeakCallbackInfo(data);
      K key = Traits::KeyFromWeakCallbackInfo(data);
      Traits::Dispose(data.GetIsolate(),
                      persistentValueMap-&gt;Remove(key).Pass(), key);
      Traits::DisposeCallbackData(data.GetParameter());
    }
  }
};


template &lt;typename K, typename V, typename Traits&gt;
class GlobalValueMap : public PersistentValueMapBase&lt;K, V, Traits&gt; {
 public:
  explicit GlobalValueMap(Isolate* isolate)
      : PersistentValueMapBase&lt;K, V, Traits&gt;(isolate) {}

  typedef
      typename PersistentValueMapBase&lt;K, V, Traits&gt;::PersistentValueReference
          PersistentValueReference;

  /**
   * Put value into map. Depending on Traits::kIsWeak, the value will be held
   * by the map strongly or weakly.
   * Returns old value as Global.
   */
  Global&lt;V&gt; Set(const K&amp; key, Local&lt;V&gt; value) {
    Global&lt;V&gt; persistent(this-&gt;isolate(), value);
    return SetUnique(key, &amp;persistent);
  }

  /**
   * Put value into map, like Set(const K&amp;, Local&lt;V&gt;).
   */
  Global&lt;V&gt; Set(const K&amp; key, Global&lt;V&gt; value) {
    return SetUnique(key, &amp;value);
  }

  /**
   * Put the value into the map, and set the 'weak' callback when demanded
   * by the Traits class.
   */
  Global&lt;V&gt; SetUnique(const K&amp; key, Global&lt;V&gt;* persistent) {
    if (Traits::kCallbackType != kNotWeak) {
      WeakCallbackType callback_type =
          Traits::kCallbackType == kWeakWithInternalFields
              ? WeakCallbackType::kInternalFields
              : WeakCallbackType::kParameter;
      Local&lt;V&gt; value(Local&lt;V&gt;::New(this-&gt;isolate(), *persistent));
      persistent-&gt;template SetWeak&lt;typename Traits::WeakCallbackDataType&gt;(
          Traits::WeakCallbackParameter(this, key, value), OnWeakCallback,
          callback_type);
    }
    PersistentContainerValue old_value =
        Traits::Set(this-&gt;impl(), key, this-&gt;ClearAndLeak(persistent));
    return this-&gt;Release(old_value).Pass();
  }

  /**
   * Put a value into the map and update the reference.
   * Restrictions of GetReference apply here as well.
   */
  Global&lt;V&gt; Set(const K&amp; key, Global&lt;V&gt; value,
                PersistentValueReference* reference) {
    *reference = this-&gt;Leak(&amp;value);
    return SetUnique(key, &amp;value);
  }

 private:
  static void OnWeakCallback(
      const WeakCallbackInfo&lt;typename Traits::WeakCallbackDataType&gt;&amp; data) {
    if (Traits::kCallbackType != kNotWeak) {
      auto map = Traits::MapFromWeakCallbackInfo(data);
      K key = Traits::KeyFromWeakCallbackInfo(data);
      map-&gt;RemoveWeak(key);
      Traits::OnWeakCallback(data);
      data.SetSecondPassCallback(SecondWeakCallback);
    }
  }

  static void SecondWeakCallback(
      const WeakCallbackInfo&lt;typename Traits::WeakCallbackDataType&gt;&amp; data) {
    Traits::DisposeWeak(data);
  }
};


/**
 * A map that uses Global as value and std::map as the backing
 * implementation. Persistents are held non-weak.
 *
 * C++11 embedders don't need this class, as they can use
 * Global directly in std containers.
 */
template&lt;typename K, typename V,
    typename Traits = DefaultPersistentValueMapTraits&lt;K, V&gt; &gt;
class StdPersistentValueMap : public PersistentValueMap&lt;K, V, Traits&gt; {
 public:
  explicit StdPersistentValueMap(Isolate* isolate)
      : PersistentValueMap&lt;K, V, Traits&gt;(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 &lt;typename K, typename V,
          typename Traits = DefaultGlobalMapTraits&lt;K, V&gt; &gt;
class StdGlobalValueMap : public GlobalValueMap&lt;K, V, Traits&gt; {
 public:
  explicit StdGlobalValueMap(Isolate* isolate)
      : GlobalValueMap&lt;K, V, Traits&gt;(isolate) {}
};


class DefaultPersistentValueVectorTraits {
 public:
  typedef std::vector&lt;PersistentContainerValue&gt; Impl;

  static void Append(Impl* impl, PersistentContainerValue value) {
    impl-&gt;push_back(value);
  }
  static bool IsEmpty(const Impl* impl) {
    return impl-&gt;empty();
  }
  static size_t Size(const Impl* impl) {
    return impl-&gt;size();
  }
  static PersistentContainerValue Get(const Impl* impl, size_t i) {
    return (i &lt; impl-&gt;size()) ? impl-&gt;at(i) : kPersistentContainerNotFound;
  }
  static void ReserveCapacity(Impl* impl, size_t capacity) {
    impl-&gt;reserve(capacity);
  }
  static void Clear(Impl* impl) {
    impl-&gt;clear();
  }
};


/**
 * A vector wrapper that safely stores Global values.
 * C++11 embedders don't need this class, as they can use Global
 * directly in std containers.
 *
 * This class relies on a backing vector implementation, whose type and methods
 * are described by the Traits class. The backing map will handle values of type
 * PersistentContainerValue, with all conversion into and out of V8
 * handles being transparently handled by this class.
 */
template&lt;typename V, typename Traits = DefaultPersistentValueVectorTraits&gt;
class PersistentValueVector {
 public:
  explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }

  ~PersistentValueVector() {
    Clear();
  }

  /**
   * Append a value to the vector.
   */
  void Append(Local&lt;V&gt; value) {
    Global&lt;V&gt; persistent(isolate_, value);
    Traits::Append(&amp;impl_, ClearAndLeak(&amp;persistent));
  }

  /**
   * Append a persistent's value to the vector.
   */
  void Append(Global&lt;V&gt; persistent) {
    Traits::Append(&amp;impl_, ClearAndLeak(&amp;persistent));
  }

  /**
   * Are there any values in the vector?
   */
  bool IsEmpty() const {
    return Traits::IsEmpty(&amp;impl_);
  }

  /**
   * How many elements are in the vector?
   */
  size_t Size() const {
    return Traits::Size(&amp;impl_);
  }

  /**
   * Retrieve the i-th value in the vector.
   */
  Local&lt;V&gt; Get(size_t index) const {
    return Local&lt;V&gt;::New(isolate_, FromVal(Traits::Get(&amp;impl_, index)));
  }

  /**
   * Remove all elements from the vector.
   */
  void Clear() {
    size_t length = Traits::Size(&amp;impl_);
    for (size_t i = 0; i &lt; length; i++) {
      Global&lt;V&gt; p;
      p.val_ = FromVal(Traits::Get(&amp;impl_, i));
    }
    Traits::Clear(&amp;impl_);
  }

  /**
   * Reserve capacity in the vector.
   * (Efficiency gains depend on the backing implementation.)
   */
  void ReserveCapacity(size_t capacity) {
    Traits::ReserveCapacity(&amp;impl_, capacity);
  }

 private:
  static PersistentContainerValue ClearAndLeak(Global&lt;V&gt;* persistent) {
    V* v = persistent-&gt;val_;
    persistent-&gt;val_ = 0;
    return reinterpret_cast&lt;PersistentContainerValue&gt;(v);
  }

  static V* FromVal(PersistentContainerValue v) {
    return reinterpret_cast&lt;V*&gt;(v);
  }

  Isolate* isolate_;
  typename Traits::Impl impl_;
};

}  // namespace v8

#endif  // V8_UTIL_H
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-nodejs10%2Finclude%2Fnode'>Back to Directory</a>