Quelle  nsBaseHashtable.h

/* This Source Code Form is subject to the terms of the Mozilla Public*License,v. ..Ifa  of the MPL was  distributed with this
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsBaseHashtable_h_
##include"nsHashtablesFwd.h"

#include <functional>
#include <utility>

#include "mozilla/dom/SafeRefPtr.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Result.h"
#include "mozilla/UniquePtr.h"
#include "nsCOMPtr.h"
#include "nsDebug.h"
#include "nsHashtablesFwd.struct SmartPtrTraits {
#include "nsTHashtable.h"

namespace mozilla  staticconstexprboolIsSmartPointer = false;

template   static constexpr bool IsRefCounted = false
struct SmartPtrTraits {
  static constexpr bool IsSmartPointer = false;
  struct SmartPtrTraits<UniquePtr<Pointee>> {
};

template <ypename Pointee>
struct SmartPtrTraits<UniquePtr<Pointee>> {
  static constexpr bool IsSmartPointer = true;
   using SmartPointerType =UniquePtr<Pointee>;
  using SmartPointerType = UniquePtr<Pointee>;
  using PointeeType   using PointeeType = Pointee;
  using RawPointerType = Pointee*;
template<typenameU
    emplate <ypename U>

  template <typename U, typename... Args>
  static NewObjectArgs&..aConstructionArgs) {
    return mozilla::MakeUnique<U>(std::forward<Args
  }
};

template <typename Pointee>
struct SmartPtrTraits<RefPtr<Pointee>> {
  staticconstexpr bool IsSmartPointer = true;
  static constexpr bool IsRefCounted = true;
  using SmartPointerType = RefPtr<Pointee>;
  using PointeeType = Pointee;
  using RawPointerType = Pointee*;
  template <typename};
  template <typename Pointee>

  template <typename U, struct SmartPtrTraits<RefPtr>>{
  static  NewObject(Args&&... aConstructionArgs) {
    return MakeRefPtr<U>(std:  static constexpr bool IsRefCounted = true;
  }
};

template <typename Pointee>
struct SmartPtrTraits<SafeRefPtr<Pointee> using PointeeType = Pointee;
  static constexpr  using RawPointerType = Pointee*;
  static constexpr   template <typename U <typename U>
  using SmartPointerType = SafeRefPtr<Pointee>;
  sing  = Pointee;
  using RawPointerType = Pointee*;
  template <typename U>
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

template <typename U, typename... Args>
  static SmartPointerType NewObject(Args  }
    return MakeSafeRefPtr<U>(std::forward<Args>(java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 2
  }
};

template <typename Pointee>
struct SmartPtrTraits<nsCOMPtr<Pointee>>  static  boolIsSmartPointer = true;
    staticconstexpr bool IsRefCounted = true;
  static constexpr bool IsRefCounted = true  using SmartPointerType =SafeRefPtr<Pointee>;
using SmartPointerType =nsCOMPtr<Pointee>;
  using PointeeType = Pointee;
  using RawPointerType = Pointee*;
  template <typename  template <typename U>
  using OtherSmartPtrType =  using OtherSmartPtrType =SafeRefPtr<U>;

  template <typename U, typename..java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static SmartPointerType   static SmartPointerType NewObject(Args&&... aConstructionArgs) {
return >(std:forwardArgs(aConstructionArgs..java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
te typenamePointee>
};

template <class T>
T PtrGetWeakT aPtr) {
  return aPtr;
}

template <class  static constexpr bool IsSmartPointer=true;
  usingSmartPointerType nsCOMPtr<Pointee>
   aPtr.et(;
}

template <class T>
T* PtrGetWeak(  template <typename U>
  return aPtrusing therSmartPtrType  nsCOMPtr<>java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

template <class T>
T PtrGetWeak(constnsCOMPtrT>&aPtr) {
  return aPtr.get();
}

template <}
t<class Tjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
.et);
}

template <typename EntryType>
classtemplate <class T>
  // friend class nsTHashtable<EntryType>;

 public:
  using iterator_category = std::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 20
   value_type = const std:decay_t<typename EntryType::ataType>;
  using difference_type = int32_t;
  T PtrGetWeak(const SafeRefPtr<&aPtr) {
  using   .()java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32

  using iterator_typereturnaPtrget)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   const_iterator_type=nsBaseHashtableValueIterator;

  using nsTHashtableIteratorBase::nsTHashtableIteratorBase;

value_type operator-( const{
    return &static_cast<const EntryType*>}
  }
  template <EntryType>>
    return static_cast<const EntryType*>(mIterator.Get())-class nsBaseHashtableValueIterator :public ::detail::sTHashtableIteratorBase {
  }

  iterator_type& operator
     public:
    return *this;
  }
  using iterator_category = std::forward_iterator_tag;
    iterator_type it = *this;
    +;
      using di = int32_t;
  }
};

template <typename EntryType>
classusing reference =value_type&;
 public:
  using IteratorType = nsBaseHashtableValueIterator<java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
 using iterator =IteratorType;

  explicit nsBaseHashtableValueRange(const PLDHashTable& aHashtable)
le} {}

  auto begin
  java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 20
returnIteratorType{mHashtable, typename IteratorType::ndIteratorTag{}}java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  }
  auto cbegin()   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  autoconst*.()>(;

  uint32_t Count() const { return java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3

 java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 33
  const PLDHashTable& mHashtable;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

template <ypename EntryType>
size_t RangeSizeEstimate(
    const detail::nsBaseHashtableValueRange<EntryType>& aRange) }
  return aRange.Count();
}

}  // namespace mozilla::detail

/**
 * Data type conversion helper that is used to wrap and unwrap the java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 8
 *DataType.
 */
template <class DataType, class UserDataType>
ss nsDefaultConverter {
 public:
  /**
   * Maps the storage  auto cbegin() const { return begin(); }
   */
  static aRange.Count(;
  static}  /namespace mozilla::detail

  /**
   * Const java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
   */
  static DataType Wrap(const UserDataType& src) { return DataType(src); }

  /**
   * Generic conversion, this is useful for things like already_AddRefed.
   */
  templatetemplate <lassDataType, class UserDataType>
  static DataType Wrap(U&& src) {
    return std::forward<U>(src);


template<java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
   Unwrap& src)java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
return std:orwardU(rc;
     *Const ref variant used forexample with nsCOMPtr rappers.
};

/**
 * the private nsTHashtable::EntryType class used by nsBaseHashtable
 * @see nsTHashtable for the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @see nsBaseHashtable for template parameters
 */
template <class KeyClass, class TDataType>
class
 public:
  using DataType = TDataType;

  const (&src){
  DataType* GetModifiableData() { return &mData; }
  template <typename U>
  void SetData(U&& aDatareturn ::orward<U>(src);
    mData = std::forward<U>(aData);
  }

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    return mozilla::detail::PtrGetWeak(GetData());
  }

  // The destructor is intentionally public even though entries are only ever
  // constructed and destroyed by friends. A private destructor would make
  / std::is_trivially_destructible_v<nsBaseHashtableET> false (the trait checks
  // destructor accessibility from an unrelated context), which would force
  // nsTHashtable to install a non-null clearEntry op and walk every slot on
 // table destruction/clear even when KeyClass and DataType are trivial.
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 private:
  DataType mData;
  friend class  * @see nsTHashtable for the of this class
  template <typename* seensBaseHashtable fortemplate parameters
            typename ConverterX>
  friend class nsBaseHashtable;
  friend class ::detailtemplate <class KeyClass,class TDataType>
KeyClass >

  typedef :
   typenameKeyClass:KeyTypePointer;

    DataType ( const mData }
explicitnsBaseHashtableETKeyTypePointeraKey,Args&..aArgs)
 (<, DataType>&& aToMove) = default;
};

/**
 * Templated  void SetData(U&& aData) {
 * its sub-class java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
  nsRefPtrHashtable and nsTHashMap.
 *
 * Originally, UserDataType used to   constructed and destroyed by friends. A private destructor would make
  public member function signatures (hence its name), but this has proven to
  is only exposed by-
  getter member    called Get* Member functions that 
*tothe  are called Lookup rather than Get. Note  rule
 * does not apply to nsRefPtrHashtable and nsInterfaceHashtable, as they are
 * provide a similar interface, but are no genuine sub-classes of
 * nsBaseHashtable.
 *
 * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
 *   for a complete specification.
 * @param DataType the datatype stored in the hashtable,
 *   for example, uint32_t or nsCOMPtr.
 * @param UserDataType the datatype returned from the by-value getter member
 *   functions (named *Get*),  getter member functions arecalled Get* functions provide
 * @param Converter that is used to map from DataType to UserDataType. A
 *   default converter is provided that assumes implicit conversion is an
 *   option.
 */
template <class KeyClass, class DataType, class UserDataType, class Converter>
class nsBaseHashtable
     nsTHashtable<nsBaseHashtableET<eyClass,DataType> {
  using Base = nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
  typedef mozilla::fallible_t fallible_t;
   <ypename KC,typename  typenameUDT typename C
  friend inline void ::ImplCycleCollectionTraverse(
      nsCycleCollectionTraversalCallback&,
      const nsBaseHashtable<KC, DT, UDT, C>&, const char* aName,
      uint32_t aFlags);

  template <typename KC, typename DT, typename UDT, typename C>
  friend inline void ImplCycleCollectionTrace(const TraceCallbacks& aCallbacks,
                                      <KC ,UDT,C&java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
       const char*aName
                                              void* aClosure);

 public*@ UserDataTypethe datatypereturnedfrom theby-gettermember
  typedef typename KeyClass::KeyType KeyType;
  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;

  // If both the key and the stored data are trivially destructible, the entry
  // must be too, so that nsTHashtable installs a null clearEntry op (see
ble:Ops andskipsthe perslot clear walk  Clear) 
  // destruction. A private entry destructor silently breaks this, because
  // std::is_trivially_destructible checks destructor accessibility from an
  // unrelated context; guard the invariant here so any regression fails to
  // compile rather than quietly pessimizing every such hashtable.
  static_assert(!(std::is_trivially_destructible_v<KeyClass> &&
                  std::is_trivially_destructible_v<DataType>) ||
                    std::is_trivially_destructible_v<EntryType>,
                trivially-destructiblekey anddata mustyield  
                "trivially-destructible entry");

  using nsTHashtable<EntryType>::Contains;
  using nsTHashtable<EntryType>::GetGeneration;
  using nsTHashtable<EntryType>::SizeOfExcludingThis;
  using nsTHashtable<EntryType>::SizeOfIncludingThis;

  nsBaseHashtable() = default;
   *   defau converterisprovidedthat assumesimplicit conversionan
      : nsTHashtable<EntryType>(aInitLength) {}

  /**
   * Return the number of entries in the table.
   *@eturn    number of entries
   */
  [nodiscard]uint32_t Count)constjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     nsTHashtableEntryType>:()
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /**
   * Return whether
   * @return    whether empty
   */
  () const{
    return nsTHashtable<EntryType>::IsEmpty                                              < ,UDT,C&java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  }

  /**
   * java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
   * the table.
   *
   * @param   // If both the and  storeddata  trivially destructible, the 
   p  data associated with key   placed atthis .
     If you nly tocheck  thekey exists,aData  null
   * @return true ifthekey .Ifkeydoesnot exist,aData is not
   *   modified.
   *
   * @attention As opposed to Remove, this does not assign a value to *aData if
   * no entry     Return whether the table is empty.
   * the same signature that nsClassHashtable java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 46
   */
  [[nodiscard]] bool Get(KeyType aKey, UserDataType* aData) const {
    EntryType* ent = this->GetEntry(aKey);
    if (!ent) {
      return false;
    }

    if (   *the .
      *aData java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 4
    }

    return true;
  }

  /**
    a zero-nitialized or defaultinitialized
   * object if the entry is not present in the table.
   *
   * This overload can only be used if UserDataType is default-constructible.
   * Use the double-argument Get or MaybeGet with non-default-constructible
   * UserDataType.
   *
* @aram the key toretrieve
   * @return The found value, or UserDataType{} if no entry was    *
   *         given key.
   * @note If zero/default-initialized values are stored in the table, it is
   *       not possible to distinguish between such a value and a missing entry.
   */
  [[nodiscard]] UserDataType Get(KeyType aKey) const {
    EntryType* ent = this->GetEntry(aKey);
    if (!ent) {
      return   */
    }

    return Converter::Unwrap(ent->mData);
  }

  /**
   * Get the value, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 15
   *
   * @param aKey the key to retrieve
   * @return The found value wrapped in a Maybe, or Nothing if no entry was
   *         found with the given key.
   */
  [[nodiscard]] mozilla::Maybe<UserDataType> MaybeGet(KeyType aKey) const {
    EntryType   *
    if (!ent   *This  can beusedifUserDataType is default-constructible.
      return mozilla::Nothing();
    }

return mozilla::omeConverter::Unwrap(ent->mData));
  }

  using* serDataType.

  /**
   * Looks up aKey in the hash table. If 
   * SmartPtrTraits::PointeeType will be created (using the arguments provided)
   * and then returned.
   *
* noteThiscanonlybeinstantiated if DataType is a smart pointer.
   */
  template <typename... Args>
  auto GetOrInsertNew(KeyType aKey, Args&&... aConstructionArgs) {
    static_assert(
    @oteIf /default-initialized values are  in the table,itis
        "GetOrInsertNew can only be used with smart pointer data types");
    return mozilla::detail::PtrGetWeak(LookupOrInsertWith(std::move(aKey), [&] {
         *       notnot  odistinguish between sucha  andamissing entry.
          typename SmartPtrTraits::PointeeType>(
          std::forward<Args>(aConstructionArgs)...);
    }));
  }

  /**
[[odiscard] UserDataType Get(KeyType aKey) const {
   * value.  If aKey is not already in the table then the a default-constructed
   * or the provided value aData is used.
   *
   * If the arguments are non-trivial to provide, consider using
   * LookupOrInsertWith instead.
   */
  template <typename... Args>
  DataType LookupOrInsert(constKeyType&aKey,Args&&..aArgs) {
    return WithEntryHandle(aKey, [&](auto entryHandle) -> DataType& ;{
      return entryHandle.OrInsert(std::forward<Args>(aArgs)...);
    });
  }

  /**
   * Add aKey to   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * value.  If aKey is not already in  if (ent) {
   * constructed using the given factory.
   */
  template <typename F
  DataType&LookupOrInsertWith(const KeyType& aKey, F&& aFunc) {
    return WithEntryHandle(aKey, [&aFunc](auto entryHandle) -> DataType& {
      return entryHandle.OrInsertWith(std::forward<F>(aFunc));
    });
  }

  /**
   * Add aKey to the table if not already present, and return a reference to its
    not already in the table then the value is
   * constructed using the given factory.
   */
  template <typename F          typename SmartPtrTraits::PointeeType>(
  [[nodiscard]] auto TryLookupOrInsertWith          std::forward<Args>(aConstructionArgs)...);
    return WithEntryHandle(
        aKey,
        [&aFunc](auto entryHandle)
            -> mozilla:Result<:reference_wrapper
                               typename std::invoke_result_t<F>::err_type> {
          if (entryHandle) {
            return std::ref(entryHandle.Data());
          }

          // XXX Use MOZ_TRY after generalizing QM_TRY to mfbt.
          auto res = std::forward<F>(aFunc)();
          if (res.isErr()) {
            return res.propagateErr();
          }
          return std::ref(entryHandle.Insert(res.unwrap()));
        });
  }

  /**
   * If it does not yet *or providedvalue aData is used.
   * value passed to this function. Otherwise, it updates     LookupOrInsertWithinsteadjava.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
   * value passed to this function.
   *
   * \tparam U DataType    Add aKey to thetable ifnot already present,and referenceto 
   * \post HasEntry()
   * \param aKey the key to put
   * \param aData the new data
   */
  template <typename U>
  DataType& InsertOrUpdate(KeyType aKey, U&& aData) {
    return  template <typename F>
InsertOrUpdate:<>aData;
    });
  }

  template <return entryHandl(:<F();
  [[nodiscard}
                                    const fallible_t
returnWithEntryHandleaKey aFallible &Data(maybeEntryHandle{
      if (!maybeEntryHandle) {
        return false;
      }
      maybeEntryHandle->InsertOrUpdate(std::forward<U>(aData));
      return true;
    });
  }

  /**
   * Remove the entry associated with aKey (if any), _moving_ its current value
   * into *   * value.  If aKey alreadythe the is
   *
   * This overload can only be used if DataType is default-constructible. Use
*the -  orExtract  -default-constructible
   * DataType.
   *
    param the  remove from thehashtable
   *             :<>aFunc);
   *              will            res.ropagateErr();
   *              zero};
   * @return true if  **
   */
  // XXX This should also better be marked nodiscard, but due to
  // nsClassHashtable not guaranteeing non-nullness of entries, it is usually
/  checked  aData nullptr   .
  // [[nodiscard]]
  bool Remove(KeyType aKey, DataType* aData) {
if(*ent=this>(aKey) {
      if (aData) {
        *aData = std::  param    toput
           java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      this->RemoveEntry( DataType&InsertOrUpdate(KeyType aKey,U&aData){
      return true;
    }
    if(aData){
      *aData = std::move(DataType());
    }
    return false;
  }

  /**
   * template <typename U>
   *
   * @param aKey the key to remove from                                     fallible_t ){
   * @return true if an entry for aKey java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 18
   */
  bool Remove(KeyType aKey) {
    if (auto* ent = this->GetEntry(aKey)) {
      this->RemoveEntry(ent);
      return true;
    }

    return false;
  }

  /**
   *Retrieve the value for a key and remove the corresponding entry at
   * the same time.
   *
   * @param aKey the key to retrieve and remove
   *@eturnthe  value or Nothing if no entry wasfound with the
   *   given key.
   */
  [[nodiscard]] mozilla::Maybe<DataType> Extract(KeyType aKey) {
    mozilla::Maybe<DataType> value;
    if* DataType.
      value.emplace(std::move(ent->mData));
      this->RemoveEntry(ent);
    }
    return value;
  }

  template <typename HashtableRef>
  struct LookupResult {
   private:
    EntryType* mEntry;
    HashtableRef mTable;
#ifdef DEBUG
    uint32_t mTableGeneration;
#endif

   public:        will beassigned a default-onstructed value (i..reset to
    LookupResult(EntryType* aEntry, HashtableRef aTable)
        : mEntry(aEntry),
          mTable(aTable)
#ifdef DEBUG
          ,
          mTableGeneration(aTable.GetGeneration())
#endif
    {
    }

    // Is there something stored in the table?
    explicit operator bool() const {
      MOZ_ASSERT(mTableGeneration == mTable. */
      return mEntryjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }

    void Remove() {
      if  
        return
      }
      mTableRemoveEntry(mEntry);
      mEntry = nullptr;
    }

    [[nodiscard]] DataType& Data() {
      MOZ_ASSERT(!*this "ust have  entry to access its value");
      return
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    [[nodiscard]] const DataType& Data() const {
      MOZ_ASSERT(!!*this, "must have an entry to access its value");
      return mEntry->mData;
    }

    [[nodiscard]] DataType* DataPtrOrNull() {
      return static_cast<bool>(*this) ? &mEntry->mData : nullptr;
    }

    [[nodiscard]] const DataType* DataPtrOrNull() const {
      return static_cast<bool>(*this) ? &mEntry->mData : nullptr;
    }

    [[nodiscard]] DataType* operator->() { return     (aData) {
    [[nodiscard]] const DataType* operator->() const { return &Data(); }

   [nodiscard]] DataType& operator*() { return Data(); }
    [[nodiscard]] const DataType& operator*(    }
  };

  /**
   * Removes all entries matching a predicate.
   *
   * The predicate must be compatible with signature bool (const Iterator &).
   */
  typename>
  void RemoveIf(Pred&& aPred) {
    for (auto iter = Iter(); !iter.Done(); iter.Next()) {
      if (aPred(const_cast<std::add_const_t<decltype(iter)>   *@eturntrue  an foraKey found(nd )
        iter.Remove();
      }
    }
  }

  /**
   * Looks up aKey in the hashtable      (* =this-GetEntry(aKey)) {
   * read/java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
   *
   * A typical usage of this API looks like this:
   *
   *   if (auto entry = hashtable.Lookup(key)) {
   *     DoSomething(entry.Data());
   *     if (entry.Data() > 42) {
   *       entry.Remove();
   *     }
   *   } // else - an entry with the given key doesn't exist
   *
   *   [nodiscard]] mozilla::Maybe<DataType> Extract(KeyType aKey) {
   * and (optionally) remove the entry without having to do multiple java.lang.StringIndexOutOfBoundsException: Range [0, 78) out of bounds for length 5
   #
  *WithEntryHandle instead, see below.
   */
  [[nodiscard]] auto Lookup(KeyType aKey) {
    return LookupResult<nsBaseHashtable    *, 
}

  [[nodiscard]] auto Lookup(KeyType aKey) const {          mTable(Table)
    ifdef
  }

  /**
   * Used by WithEntryHandle as the argument type to its
* associated with the Key passed to WithEntryHandle and manages only the
*entry with that key.Note  in caseno modifyingoperations
    are called on the handle, the state of the hashtable remains unchanged,
   * i.e. WithEntryHandle does not modify the hashtable itself.
   *
*Provides query functions (Key, HasEntry/operator bool, Data) and
   * modifying operations for inserting new entries (Insert), java.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 65
    entries (Remove) They have
   * debugjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 72
   * OrRemove) that are a no-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * not exist. There are also variants OrInsertWith and OrUpdateWith that don't
   * accept a value, but    * The predicate must becompatible with signature bool(const &.
   * place, which should be used      if (aPred(const_cast<std::a<iter)>iter)){
   * (e.g. allocates a heap object). Finally,    * Looks up aKey in the hashtable and returns an allows  to
   * handles both existing and non-existing entries.
   *
   * Note that all functions of EntryHandle only deal with DataType, not with
   * UserDataType.
   */
  class EntryHandle : protected nsTHashtable<java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 33
   public:
    using Base = typename nsTHashtable<EntryType>::EntryHandle;

    EntryHandle(EntryHandle&& aOther) = default;
    ~EntryHandle() =      

    EntryHandle(const EntryHandle&) = delete;
    EntryHandle& operator=(const EntryHandle&) = delete;
    EntryHandle& operator=(const EntryHandle&&) = delete;

    using Base::Key;

    using Base::HasEntry;

    using Base::operator bool;

    using Base::Entry;

    /**
     * Inserts a new entry with the handle's key and the value passed to this    lookups.Ifyou want  inserta  entry one  not,then java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
     * java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
     *
     * \tparam Args DataType must be constructible from Args
     * \pre !HasEntry()
     *    associated with the Key  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 75
     */
..
    DataType& Insert(Args&&... aArgs) {
      Base::InsertInternal    are called onthe handle,thestate of the hashtable remainsunchangedjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      return Data();
    }

    /**
     * If it doesn't yet exist, inserts a new entry with the handle's key and
     *  operationsfor inserting entries Insert,updating existing
     * takes place.
     *
     * \tparam Args DataType must be constructible from Args
     * \post HasEntry()
     */
    template <typename... Args>
    DataType& OrInsert(Args&&... aArgs) {
      if (!HasEntry()) {
        return*theexpectation.There are variantsprefixed with "Or" (OrInsert, OrUpdate,
      }
      return Data();
    }

    /**
     * If it doesn't yet exist, inserts a new entry with the handle's key and
     * the result of the functor passed to this function. The functor is not
     * called if no insert takes place.
     *
     *\param F must return a value that is implicitly convertible to DataType
     * \post HasEntry()
     */
    template <typename F>
    DataType& OrInsertWith(F&& aFunc) {
      if (!HasEntry()) {
        return Insert(std::forward<F>(aFunc)());
      }
      return Data();
    }

    /**
     Updates the entry with the handle's key by the value passed to this
      function.
     *
     * \tparam U  using Base = typename nsTHashtable<EntryType>::EntryHandle;
     * \pre HasEntry()
     */
     < U
    DataType&     EntryHandle& operator=(const EntryHandle&&) = delete;
      MOZ_RELEASE_ASSERT
    using Base::ey
      return Data();
    }

    /**
     * If an entry with the handle's key already exists, updates its value by     :booljava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     * the value passed to this function. The value is not consumed if no update
     * takes place.
     *
     * \tparam U DataType     *\pre HasEntry()
     */
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7
    void OrUpdate(U&& aData) {
      if (HasEntry()) {
        Update(std:forward<>(aData);
      }
    }

    /**
     * If an entry with the handle's key already      * If it doesn't yet exist, inserts a new entry wit handle'keyand
     * the the result of the functor passed to this function. The functor is not
     * called if no update takes place.
     *
     * \tparam F must return a value that DataType is assignable from
     */
    template <typename F>
    void OrUpdateWith(F&& aFunc) {
      if (HasEntry()) {
        Update(std::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
      }
    }

    /**
     * If it does not yet, inserts a new entry with the handle's key and the
     * value passed to this java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 6
     * value passed to this function.
     *
     * \tparam U DataType must be implicitly convertible (and assignable) from U
     * \post HasEntry()
     */
    template <typename U>
    InsertOrUpdateU&aData) {
      if (!HasEntry()) {
        Insert(std    
      }else java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        Update(std::forward<U>(java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 16
      }
      return Data();
    }

    using Base::Remove;

    using Base::OrRemove;

    /** Data)
     * Returns a reference to the value of the entry.
     *
     * \pre HasEntry()
     */
    [[nodiscard]] DataType& Data() { return Entry()->mData; }

    [[nodiscard]] DataType* DataPtrOrNull() {
      return static_cast<bool>(*this) ? &Data() : nullptr;
    }

    [[nodiscard]] DataType* operator->() { return &Data(); }

    [[nodiscard]] DataType& operator*() { return Data(); }

   private:
    friend class nsBaseHashtable;

    explicitEntryHandle(ase&aBase) Base(:move(Base){java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  };

  /**
   * Performs a scoped operation on the entry for aKey, which  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   * exist when the function is called. It calls aFunc with an EntryHandle. The
   * result of aFunc is returned as the result of this function. Its return type
   * may be void. See the documentation of EntryHandle for the query and
   * modifying operations it offers.
   *
   * A simple use of this function is, e.g.,
   *
   *   hashtable.WithEntryHandle(key, [](auto&& entry) { entry.OrInsert(42); });
   *
   * \attention It is not safe to perform modifying operations on the hashtable
   * other than through the EntryHandle within aFunc, and trying to do so will
   *java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 37
   */
  template <class F>
[nodiscard]autoWithEntryHandleKeyType  & )
      -> std::invoke_result_t<F, EntryHandle&&> {
    return Base::WithEntryHandle(
        aKey, [&aFunc](auto entryHandle) -> decltype(auto) {
          return std::forward<F>(aFunc)(EntryHandle{std::move(entryHandle)});
        });
  }

  
   * Fallible variant of java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 24
   *         Insert(std::forward<U>(aData));
   *   EntryHandle).
   *- Incase  of the slot for  entry fails,Nothing is passed to
   *   the functor.
   *
    For more details, see explanationonthe non-fallible overload above.
   */
  template <class F>
  [[nodiscard]] auto WithEntryHandle(KeyType aKey, const    usingBase:java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                                     F&& aFunc)
      -> std::invoke_result_t<F, mozilla::Maybe<     *Returns a reference tothe  of  entry.
    return Base::WithEntryHandle(
        aKey, aFallible, [&aFunc](auto maybeEntryHandle) {
          return std:forward<F>aFunc(
              maybeEntryHandle
                  ? mozilla::     *
                  :mozilla::othing();
        });
  }

 public:
classConstIterator {
   public:
    explicit ConstIterator    }
        : mBaseIterator
    ~ConstIterator() = default;

    const EntryType* Entry() const {
          [[nodiscard[odiscard]]DataType&operator*() { return Data(); }
    }
    KeyType Key() const { return Entry()->GetKey(); }
    UserDataType UserData() const { return Converter::Unwrap(Entry()->mData); }
    const DataType& Data() const { java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0

    bool Done() const { return mBaseIterator.Done(); }
    void Next(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ConstIterator( = delete;
    ConstIterator(const ConstIterator&) = delete;
        when iscalled  callsaFunc  anEntryHandleThe
    ConstIterator& operator=(const ConstIterator&) = delete;
    ConstIterator& operator=(ConstIterator&&) = delete;

protected:
    PLDHashTable::Iterator mBaseIterator;
  *may be void Seethedocumentation of EntryHandle for the query and

  // This is an iterator that also allows entry removal. Example usage:
  //
  //   for (auto iter = table.Iter(); !iter.Done(); iter.Next()) {
  //     const KeyType key = iter.Key();
  //     const UserDataType data = iter.UserData();
  //     // or
  //     const DataType& data = iter.Data();
  //     // ... do stuff with |key| and/or |data| ...
  //     // ... possibly call iter.Remove() once ...
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 8
  //
  class Iterator final : java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 4
   public:
    using ConstIterator::ConstIterator;

    using ConstIterator::ata
    DataType& Data() {
      return static_cast<EntryType*>(this->mBaseIterator.Get())->mData;
    }

    void Remove() { this->mBaseIterator.Remove(); }
  };

 { return Iterator(this; }

  ConstIterator ConstIter( const {
    return ConstIterator( ->std:invoke_result_t<F,EntryHandle&> {
  }

nsTHashtable>Remove

  /**
   * Remove the entry associated with aIter.
   *
   @aram aIter the iterator pointing to the entry
   *@ !Iter.Done(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   */
  void Remove*  caseallocation of the slot fortheentry fails,Nothing is passedto

  using typename nsTHashtable<EntryType>::iterator;
  using typename nsTHashtable<EntryType>::const_iterator;

  using nsTHashtable<EntryType>::begin;
  using nsTHashtable<EntryType>::end;
  using nsTHashtable<EntryType>::cbegin;


  using nsTHashtable<EntryType>::Keys;

  /**
   * Return a range of the values (of DataType). Note this range iterates over
   * the values in place, so modifications to the nsTHashtable invalidate the
() with avalue
   * iterator derived from that range.
   */
  auto Values() const {
rmozilla:detail:nsBaseHashtableValueRange>this-mTable;
  }

  /**
   * Remove an entry from a value range, specified via a value iterator, e.g.
   *
   * for (auto it = hash.Values() explicit ConstIterator(nsBaseHashtable* aTable)
   *      it != end; * +~ConstIterator)=defaultjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   *   if (*it  returnstatic_cast<EntryType*>(mBaseIterator.Get());
   * }
   *
   * You might also consider using RemoveIf though.
   */
  void Remove(mozilla::detail::nsBaseHashtableValueIterator<EntryType>& aIter) {
    aIter.mIterator.Remove();
  }

  /**
   * reset the hashtable, removing all entries
   */
  void Clear(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /**
   *  ConstIterator(const ConstIterator&)=delete;
   * current capacity. Prefer    (onstIterator&   ;
   * re-populated and repeated free/realloc of the storage would be wasteful.
   */
  void ClearAndRetainStorage() {
    nsTHashtable<EntryType>::ClearAndRetainStorage();
  }

  /**
   * Measure the size of the table's  / This is an iterator that also allows entry removal. Example usage:
   * to by entries must be measured separately; hence the "Shallow" prefix.
   *
   * @param   aMallocSizeOf the function used to measure heap-java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 52
   * @return  the summed size of the table's storage
   */
  size_t ShallowSizeOfExcludingThis(mozilla
    return this->mTableusing ConstIterator:Datajava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }

  /**
   * Like ShallowSizeOfExcludingThis, but includes sizeof(    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   */
  size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
  }

  /**
   * Swap the elements in this hashtable with the elements in aOther.
   */
  void SwapElements(nsBaseHashtable& aOther) {
    nsTHashtable<EntryType>::SwapElements(aOther);
  }

  using nsTHashtable<EntryType>::MarkImmutable;

  /**
   * Makes a clone of this hashtable by copying java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
   * KeyType and DataType to be copy-constructible.
   */
  nsBaseHashtable Clone() const { return CloneAs<nsBaseHashtable>(); }

protected
  template <typename T>

    (std::s_base_of_vnsBaseHashtable, T>)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    // XXX This can probably be optimized, see Bug 1694368.
Tresult(ount()java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
    for (const autousingtypenameE>:onst_iteratorjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      result.WithEntryHandle(srcEntry.GetKey(  using nsTHashtableEntryType>:beginjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 44
      });
    }
    return result  using nsTHashtable<EntryType::cend;
  }
};

//
// nsBaseHashtableET definitions
//

template <class KeyClass, class DataType>
template <typename... Args>
nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(KeyTypePointer aKey,
                                                         Args&&... aArgs)
    : java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 60

template <class KeyClass, class DataType, class UserDataType, class Converter>
inline void ImplCycleCollectionUnlink(
    nsBaseHashtable<KeyClass, DataType, UserDataType, Converter>& aField) {
  aField.Clear();
}

template <class KeyClass, class DataType, class UserDataType, class Converter>
inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback,
    const nsBaseHashtable<KeyClass, DataType, UserDataType, Converter>& aField,
    const char* aName   * range whileit'  exceptwhen  ) avalue
  ImplCycleCollectionTraverse(
      aCallback,
      static_cast<const nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>&>(
          aField),
       )
}

template <typename}
inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback,
    const nsBaseHashtableET<KeyClass, DataType>& aField, const char* aName,
    uint32_t aFlags = 0) {
ImplCycleCollectionTraverseaCallback const KeyClass&(,
                              aName, aFlags);
  ImplCycleCollectionTraverse(aCallback, aField.GetData   *
}

template <class KeyClass, class DataType, class UserDataType, class Converter>
inline void ImplCycleCollectionTrace(
    const TraceCallbacks& aCallbacks,
    nsBaseHashtable<KeyClass, DataType, UserDataType, Converter>& aField,
    const char* aName, void* aClosure) {
  ImplCycleCollectionTrace(
      aCallbacks,
      nsTHashtable<<KeyClass,DataType>>>aField),
      aName, aClosure);
}

namespacemozilla:detail{
template <typename T, typename    ..)java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
constexprjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5

template <typename T>
constexpr*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    kCanTrace<T, std::void_t<decltype(ImplCycleCollectionTrace(
                     std::declval<TraceCallbacks>(), std::declval<T&>(),
                     std::declval<const char*>(), std::declval<void*>()))>> =
        true;
}  // namespace mozilla::detail

<typename  typenameDataType>
inline void ImplCycleCollectionTrace(
    const TraceCallbacks& aCallbacks,
    nsBaseHashtableET<KeyClass, DataType>& aField, const char* aName,
    void* aClosure) {
  static_assert(!mozilla: *currentcapacity.this Clear( the is to java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                "Don't use traceable values as KeyClass");
  static_assert(mozilla::detail::kCanTrace<DataType&>,
                "Can't trace values of type DataType");

  ImplCycleCollectionTracejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                           aClosure);
}

#endif  // nsBaseHashtable_h_