/* This Source Code Form is subject to the terms of the Mozilla Public
   .2.  copyMPLnot  thisjava.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsBaseHashtable_h_
#define nsBaseHashtable_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
#include "nsCOMPtr.h"
java.lang.NullPointerException
 
#include "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0



template
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 23
     java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 47
 ;
};

template <typename Pointeejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 43
;
<java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 30
      >
ttjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
  using  SmartPointerType(&. java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 66

  template <java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
  static java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 46
    return mozilla=;
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 30
;

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 27
<Pointee 
  static constexprSmartPointerTypejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 66
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 44
  using SmartPointerType = java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 34
  templatejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
uPointeeTypejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30

  template <typename U, typename... Args>
  static SmartPointerType NewObject(Args&&... aConstructionArgs) {
      java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
};

template <typename Pointee>
struct SmartPtrTraitsjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 constexpr java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 46
 java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 44
 ;
  using PointeeType = Pointee;
   java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 42

  template <typename U, typename... Args>
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 66
    return MakeSafeRefPtr<U>    eturnMakeRefPtr<U>std:<rgs>aConstructionArgs).);
  }
};

mplate< java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
struct*(*)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  
  static constexpr bool IsRefCounted = true;
    =nsCOMPtr<Pointee;
    returnget)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
  usingO=U;

  template <typename U, typename... Args>
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }* <> java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 40
}

emplate <class>
T* PtrGetWeak(T* aPtr) {
  return aPtrg(;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 18
T* PtrGetWeakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return aPtr.get();
}

templateusing=:Djava.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 70
*T> aPtr) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
return aPtr.nsafeGetRawPtr);
}

template <class T>
T* PtrGetWeak(const nsCOMPtr<T>& aPtr)
  return .(;
}

template <class T>
using  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59
  return  *-( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

typename java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 :detailnjava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 80
  // friend class nsTHashtable<EntryType>;

java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  java.lang.StringIndexOutOfBoundsException: Range [25, 7) out of bounds for length 54
  +*this
fference_type
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  =java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32

  using iterator_type = nsBaseHashtableValueIterator;using=java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
  using       : mHashtable{aHashtab

  using auto end() const {

  value_type* operator->      :};
    return &static_cast<const
  }
  decltype(auto) operator*() const {
    return static_cast< EntryType*(mIteratorGet)->etData)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  }

  iterator_type& operator++() {
    mIterator.Next();
    return *this;
  }
  iterator_type operator++(int) {
    iterator_type it;
    ++*this;
    return <java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
};

}  // namespace mozilla::detail
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 public:
  using IteratorType = nsBaseHashtableValueIterator<EntryType>;
  using iterator = IteratorType;

  explicit nsBaseHashtableValueRange(const PLDHashTable& aHashtable)
      : mHashtable{aHashtable} {}

  auto begin() const { return IteratorType{mHashtable}; }
  auto end() const {
    return IteratorType{mHashtable, typename IteratorType::EndIteratorTag{ *java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
  clajava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 41
  auto cend() const { return end(); }

  uint32_t Count() const { return mHashtable.EntryCount(); }

 private:
  const PLDHashTable& mHashtable;
};

template <typename EntryType>
size_t RangeSizeEstimate(
    const detail::nsBaseHashtableValueRange<EntryType>& aRange) {
)
}

}/ java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 31

/**
 * Data type conversion helper that is used to wrap java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5
 * DataType.
 */
c java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
class nsDefaultConverterjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 32
 public:
  /**
      <ypename U>
   */
  static static UserDataType(U& ){
  static UserDataType Unwrap(const     :f<>s)

  /**
   *  wjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
   */
  static DataType Wrap(const UserDataType& src) { return DataType(src); }

  /**
   * Generic conversion, this is useful for things like already_AddRefed.

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  static DataType WrapU&  
    stdfjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 32
    

  template <typename U>
  static UserDataType java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
    return std::forward/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
   
};

/**
 * the private 
 specification class
 @  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 47
 */
,java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 42
class nsBaseHashtableET : public      nsBaseHashtableET<KeyClass, DataType>;
 public:
  typedef KeyClass: KeyTypePointer

const &GetData)const {return ; }
   nsBaseHashtableET( aKey Args&. )
  template <typename U nsBaseHashtableETnsBaseHashtableET<eyClassjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 79
 java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 27
    mData = std::forward<U>(aData);
  }

  decltype(auto) GetWeak() const {
    return mozilla::detail::PtrGetWeak(GetData());
  *java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36

  // The destructor is intentionally public even though entries are only ever
//java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  // 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
*java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 77
  ~nsBaseHashtableET() = default;

 private:
  DataType mData;
  friend class nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
  template <typename KeyClassX, typename DataTypeX, typename UserDataTypeX,
            typename ConverterX>
  friend class nsBaseHashtable;
  friend class ::detail::* inadequate over time. Now, UserDataType inbyvalue
      nsBaseHashtableET<KeyClass, DataType>>;

  typedef* memberfunctionsthatarecalled*Get.provide
  typedef typename KeyClass::KeyTypePointer KeyTypePointer;

  template <typename... Args>
  explicit nsBaseHashtableET(KeyTypePointer aKey, Args&&... aArgs);
  nsBaseHashtableET(nsBaseHashtableET<KeyClass, DataType>&& aToMove) = default;
};

/**
 * Templated hashtable. Usually, this isn't  * access to DataType thatthis 
 * its sub-class templates nsInterfaceHashtable, nsClassHashtable,
 * nsRefPtrHashtable and nsTHashMap.
 *
 * Originally, UserDataType used to be the only type exposed to the user in the
 * public member function signatures (hence its name), but this has proven to
 * inadequate over time. Now, UserDataType is only exposed in by-value
*getter  functionsthat  *. Member that 
 * access to the DataType are called Lookup rather than Get. Note that this rule
 * does not apply to nsRefPtrHashtable and nsInterfaceHashtable, as they are
 * provide a similar interface, but are no genuine sub-classes of
 *     : protected< >{
 *
 * @  templatetKC DT, , >
 *   for a complete java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @        nsBaseHashtable,DT  >,
 *   for example                                       *,
  param   returned  the -alue getter member
 *     // nsTHashta:s)and   - walk on (and
 * @param Converter that is"- key   a"
lt   assumes   is java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 *   option.
 */
template <class KeyClass, class DataType, class UserDataType, class Converter*@eturnof 
class nsBaseHashtable
    
  using  [] (  {
  typedef mozilla::fallible_t fallible_t;
  return<:Count)
}
      nsCycleCollectionTraversalCallback&,
      const  
      uint32_t aFlags);

  template <typename KC, typename DT, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 29
  friend inline void [[nodiscard]] bool IsEmpty {
nsBaseHashtableKC,DT,,>,
                                              const char* aName,
                                              void* aClosure}

 public:
  typedef typename KeyClass::KeyType KeyType;
  typedef nsBaseHashtableET<KeyClass, DataType> EntryType;

 keythe  aretriviallydestructible  entry
  // must be too, so that nsTHashtable installs a null clearEntry op (see
  // nsTHashtable::sOps) and skips the per-slot clear walk on Clear() and
  // 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> & *@aramaData  associatedthis willbeat thispointer
                  std::is_trivially_destructible_v<DataType>) ||
                    std::is_trivially_destructible_v<EntryType>,
                "trivially-destructible key and data must yield a "
                "trivially-destructible entry");

  using nsTHashtable<EntryType>::Contains;
     *   Ifo need if keyexists maybe .
  using nsTHashtable<EntryType>::SizeOfExcludingThis;
  using nsTHashtable<EntryType>::SizeOfIncludingThis;

  nsBaseHashtable() = default;
  explicit nsBaseHashtable(   * @return true if the key existstrue  exists     java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 72
      : nsTHashtable<EntryType>(aInitLength) {}

  /**
   * Return the number of entries injava.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 16
   * @return    number of entries
   */
  [[nodiscard]] uint32_t Count() const {
    return nsTHashtable<EntryType>::Count();
  }

  /**
*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 39
   * @return    whether empty
   */
  [[nodiscard]] bool IsEmpty() const {
    return nsTHashtable<EntryType>::IsEmpty();
  }

  /**
   * Get the value, returning a flag indicating the
 table
   *
   * @param aKey the java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
   * @param aData * Get the value, returningzero-POD a default-initialized
   *        If you only need to check if the key exists, aData may be null.
   * @return true if the key exists. If key does not exist, aData is not
   *   modified    @aKey keyto 
   *
   * @attention As opposed to Remove, this does not assign a value to *aData if
   * no entry is present! (And also as opposed to the member function Get with
   * the same signature that nsClassHashtable defines and hides this one.)
   */
  [java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    EntryType* ent =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!ent) {
      return false;
    }

    if (aData) {
      *aData = Converter::Unwrap(java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 4
    }

    return true;
  }

  /**
   * Get the value, returning a zero-initialized POD or a default-initialized
   * object if the entry is not present in the table.
*
    overload only   java.lang.StringIndexOutOfBoundsException: Range [54, 51) out of bounds for length 77
    S(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 56
   Ujava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
   *

   * @return The found value, or UserDataType{} if no entry was found with the
   *         given   \     java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 72
*n  zerostored  java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
   *       possiblet  value  java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 80
   */
  []java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 54
    EntryType* ent = this->GetEntry(aKey);
    if (!ent)
      return UserDataType{};
    }

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

  /**
   * Get the value, returning Nothing if the entry is not present in the table.
   *
   * @param aKey the key to retrieve
   * @return The   *
   *         found with theDataType&   &. java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
   */
  [[nodiscard]] mozilla::Maybe<UserDataType> MaybeGet(KeyType aKey) const {
    EntryType* ent = this->GetEntry(aKey);
   ! java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      return mozilla::Nothing();
    }

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

  using SmartPtrTraits = mozilla::detail::SmartPtrTraits<DataType>;

  /**
   * java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 64
   * SmartPtrTraits::PointeeType will be created (using the arguments provided)
   * and then returned.
   *
   * \note This can only be instantiated if DataType is a smart pointer.
   */
  template <typename... Args>
  auto GetOrInsertNew(KeyType aKey, Args&&... aConstructionArgs) {
    static_assert(
           * value.  If aKey is java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 66
        "GetOrInsertNew can only be used with smart pointer data types");
    return mozilla::detail::*java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 41
      return SmartPtrTraits::template NewObject<
          java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 48
          :java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 52
    }));
  }

  /**
   * Add aKey to the table if not already present, and             -> mozilla::Result<std::reference_wrapper<DataType:std:reference_wrapper<DataType>,
   * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
   the  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
   *
   * If the arguments are non-trivial to provide, consider using
*  .
   */
  template <typename... Args>
  DataType& LookupOrInsert(const KeyType& aKey, Args&&... aArgs) {
    return WithEntryHandle(aKey, [&](auto entryHandle) -> DataType& ;{
      return entryHandle.OrInsert(std::forward<Args>(aArgs)...);
    });
  }

  /**
*aKeytothe     return a   its
   * value.  If aKey is not already in the table then the value is
   * constructed using the given factory.
   */
>
  DataType& LookupOrInsertWith      return entryHandle.(std:forward<>))java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    return WithEntryHandlejava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 0
      e.OrInsertWith(td:forwardF>aFunc);
    });
  }

  /**
   * Add aKey to the table if not already present, and return a reference to      (aKey,,[a]auto maybeEntryHandle) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    isnot already in  table then  value is
   * constructed using the given factory.
   */
  template <typename F>
  [[nodiscard]] auto TryLookupOrInsertWith(const KeyType& aKey, F&& aFunc) {
    return WithEntryHandle(
        aKey,
            singleargumentRemove Extractwithnondefaultconstructible
            -> mozilla::Result<std::reference_wrapper<DataType>,
                               typename std::invoke_result_t<F>::err_type> {
          if (entryHandle) {
            return*@aKey thekeyto  fromthe 
          }

          // XXX Use MOZ_TRY after generalizing QM_TRY to mfbt.
          auto res = std:forwardF(()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
          if (res.isErr()) {
            return propagateErr)
          }
          return std::ref(entryHandle.Insert(res.unwrap()));
        );
  }

/*
   * If it does not yet, inserts a new entry with the handle's key and the
   * value passed to this function  /only checkedif isnullptr insuchcases
   * value passed to this function.
   *
   * \tparam U    f auto*ent  this-GetEntry) {
   * \post HasEntry()
   *\aKeythekey to 
   * \param aData the new  }
   */
  template <typename U>
   && java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    return WithEntryHandle(aKey, [&aData  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    });
  }

  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
  [[nodiscard]] bool InsertOrUpdate(KeyType java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 4
const &aFallible java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    return WithEntryHandle(aKey, aFallible, [&aData](auto 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 *aData.  Return    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 71
   *
   * This overload can only be used if DataType is default-constructible. Use
   * the single-argument Remove or Extract with non r found,or found 
   .
   *
   * @param aKey the key to remove from thejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   * @param aData where to  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
 -i. 
   *              zerojava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 24
   * @return true if an entry for aKey was java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 6
   */
  // XXX This should also better be marked nodiscard, but due to;
  // nsClassHashtable not guaranteeing non-nullness of entries, it is usually
  // only checked if aData is nullptr in such cases.
  // [[nodiscard]]
          ;
    if (auto* ent = this->GetEntry.java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 33
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
        *aData =!,"anjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 68
      }
      this->RemoveEntry    }
      return true;
    }
if java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      *aData = std::move(DataType()) [java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 58
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    return false;
  }

  /**
   * Remove the entry associated with aKey (if any).  Return true if found.
   *
   * @param aKey the template < Predjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
*r if  entry was  (removedjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   */
  bool Remove(KeyType aKey) {
ifauto ent  >java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 43
      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
   * @return the found value, or Nothing if no entry was found with the
   *   given key.
   */
[java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 64
    mozilla::Maybe<DataType> value;
    if (EntryType* ent = this->GetEntry(aKey)) {
      value.emplace(std::move(ent->mData));
      this->RemoveEntry(ent);
    }
    return value;
  }

  template <typename HashtableRef>
  struct LookupResult {
   private:
    EntryType* mEntry;
    HashtableRef mTable;
#fdef DEBUG
    uint32_t   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 40
#endif

   public:
LookupResult(EntryType*aEntry, HashtableRef aTable)
        : mEntry(aEntry),  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
          ajava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
# DEBUG
          ,
          mTableGeneration(aTable.GetGeneration())
#endif
    
    }

    // Is there something stored in the table?
    explicit operator bool() const {
      MOZ_ASSERT(mTableGeneration ==    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 75
      return mEntry;
    }

    void Remove() {
      if (!*this   *potential entrykey thatin  
        return;
      }
      mTable.RemoveEntry(mEntry);
   *arejava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 76
    }

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

    [[nodiscard]] const DataType& Data() const {
      MOZ_ASSERT(!!*this, "must have an entry to access its value");
      return     java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 69
    }

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

    [[nodiscard]] const DataType* DataPtrOrNull() const {
      return static_cast<bool>(** entries (Update) and removing existing)have
    }

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

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

  /**
   * Removes all entries matching a predicate.
   *
 compatible constIterator )
   */
  template <typename Pred>
  void RemoveIf(Pred&& aPred) {
    for (auto iter = Iter(); !iter.Done(); iter.Next()) {
dd_const_tdecltype()&(iter)) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        iter.Remove();
      }
    }
  }

  /**
object that allowsyou 
   * read/modify the value of the entry, or remove the entry (if found).
   *
   * A typical usage   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   *
   *   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
   *
   * This is useful for cases where you want to read/write the value of an entry
   * and (optionally) remove the entry without having to do multiple hashtable
*   wantto  newif does  exist,thenuse
   * WithEntryHandle instead, see below.
   */
  [[nodiscard]] auto Lookup(KeyType aKey) {
    return LookupResult<nsBaseHashtable&>(this->GetEntry(aKey), *this);
  }

  [[nodiscard]] auto Lookup(KeyType aKey) const {
    return LookupResult<const nsBaseHashtable&>(this->GetEntry(aKey), *this);
  }

  /**
   * Used by WithEntryHandle as the argument type to its functor. It*
*associatedpassedto WithEntryHandle and manages only the
   * potential entry     template <typename. Args>
*are     remains unchanged,
   * i.e. WithEntryHandle does not modify the hashtable itself.
   *
   * Provides query functions (Key, HasEntry/operator bool, Data) and
   *modifying    new () 
   * entries (Update) and removing existing entries (Remove). They have
   * debug-only assertion that fail when the state of the entry doesn't match
       java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 80
   * OrRemove) that are a no-op in case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   * not exist. There are also variants OrInsertWith and OrUpdateWith that don't
   * accept a value, but a functor, which is only called if the operation takes
   * place, which should be used if  \java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 79
   * (e.g. allocates a heap object). Finally, there's InsertOrUpdate that
   * handles both existing and non-existing entries.
   *
   * Note that  * thejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 74
   * UserDataType.
   */
  class EntryHandle : protected nsTHashtable<*
   public:
   java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 63

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

    EntryHandle(const EntryHandle&) = delete;
    templatetypename >
java.lang.StringIndexOutOfBoundsException: Range [25, 4) out of bounds for length 57

using:;

    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5

    usingBase:operator bool;

    using Base::Entry;

    /**
     * Inserts a new entry with the handle's key and the value passed to this
     * function.
     *
     * \tparam Args DataType must be constructible from Args
 pre!java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23
     * \post HasEntry()
     */
    template <typename... Args>
    DataType& Insert(Args&&... aArgs) {
      Base::InsertInternal(std::forward<Args>:U)
      return Data();
    }

    /**
h the s  
     * the value passed to this function. The value is not consumed if no insert
     * takes place.
     *
     * \tparam Args DataType must be constructible from Args
     * \post HasEntry()
     */
    template <typename... Args>
    DataType& OrInsert(Args&&... aArgs) {
      if (!HasEntry(     *java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
        return Insert(std::forward<Args>(aArgs)...);
      }
      return Data();
    }

    /**
     * If it java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
     * the result of the functor passed to this function. The functor is not
     * called if no insert takes place.
     *
     * \tparam 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();
     DataType&(& ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

    /**
     * Updates the} {
     * function.
     *
     * \tparam U DataType must be assignable from U
     * \pre HasEntry()
     */
    template <typename U>
    DataType& Update(U&& aData) {
      MOZ_RELEASE_ASSERT(HasEntry());
      Data() =
eturnData(;
    }

    /**
     * If an entry with the handle's key already exists, updates its value by
     * the value passed to this function. The value is not java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
     * takes place.
     *
     * \tparam U DataType must be assignable from U
     */
    template B&&):Basestd:a) }
    void OrUpdate(U&& aData) {
      if (HasEntry()) {
        Update(std  
      }
    }

    /**
     * If an entry with the handle's key already exists, updates its value by
     * 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::forward<F>(aFunc)());
      }
    }

    /**
     * If it does not yet, inserts a new entry with the handle's key and the
     * value passed to this function. Otherwise, it updates the entry by the
     *value passed to this function.
     *
     * \tparam U DataType must be implicitly convertible   [] auto WithEntryHandle(aKey,F&aFunc
     * \post HasEntry()
     */
    template <typename U>
    DataType/**
      if (!HasEntry()) {
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 39
      } else {
        Update(std::forward<U>   allocation  the  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 79
      }
      return Data*For the   
    }

    using Base::Remove;

    using Base::rRemove;

    /**
*a  value thejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
     *
               :()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     */
    [[nodiscard]] DataType& Data() :N)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

    
      return static_cast<bool>(*this) ? &Data() :    {
    }

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

    [n] java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 58

   private:
    friend class nsBaseHashtable;

    explicit EntryHandle(Base&& aBase) : Base(std::move(aBase)) {}
  };

  /**
   * )=java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
*exist   thefunction  . It  with . java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
   * result   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 *void.  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 72
   * modifying operations it offers.
   *
   * A simple use of this function is, e.g.,
   *
   *   hashtable.WithEntryHandle(key, [](auto
   *
   * \attentionjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   * other than through the EntryHandle within    ConstIteratorD;
   * trigger debug assertions, java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
   */
  template <classreturn)}
  [[nodiscard]] auto WithEntryHandle(KeyType aKey){
      :F & java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    return Base::WithEntryHandle(
        aKey, [&aFunc](auto entryHandle)  using <EntryType>:;
          return std::forward<F>(aFunc)(EntryHandle{std::move(entryHandle)});
        });
  }

  /**
   * Fallible  *@java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 52
   * -    * @pre pre !Done)
   *   EntryHandle).
    -In the  fails is java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
   *   the functor.
   *
   * For more details, see the explanation on the non-fallible overload above
   */
  template <class F>
  [[nodiscard]] auto WithEntryHandle(KeyType aKey, const fallible_t& aFallible,
                                     F&& aFunc)
      -> std::invoke_result_t<F, mozilla::Maybe<   * range while it's iterated, except when calling Remove 
    return Base::WithEntryHandle(
        aKey, aFallible, [&aFunc](auto maybeEntryHandle   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              eturn ::<EntryType{-}java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
              maybeEntryHandle
                  ?   /**
                  : mozilla::Nothing());
        });
  }

 public:
  class ConstIterator {
   public:
   java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 51
        : mBaseIterator(&aTable->mTable) {}
   ConstIterator(  ;

    const EntryType* Entry() const {
      java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 58
    }
    KeyType Key() const { return Entry()->GetKey(); }
    UserDataType UserData(   */
    const DataType& Data() const { return Entry()->mData; }

    bool Done() const { return mBaseIterator.Done(); }
    void Next() { mBaseIterator.Next(); }

    ConstIterator() = delete;
   (  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
ConstIteratorConstIterator&aOther)=delete;
    ConstIterator& operator=(const ConstIterator&) = delete;
    ConstIterator& operator=(ConstIterator&&) = delete;

   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    PLDHashTable::Iterator mBaseIterator;
  };

/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  //
  //   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 ...
  //   }
  //
   @returnjava.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 52
   public:
    using ConstIterator::ConstIterator;

    :;
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
      return/**
    }

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

  Iterator Iter() { return Iterator/

  ConstIterator ConstIter() const {
    return ConstIterator(const_cast<nsBaseHashtable*>(this));
  }

  using nsTHashtable<EntryType>::Remove;

  /**
   * Remove the entry associated with aIter.
   *
   * @param aIter the iterator pointing to the entry
   * @pre !aIter.Done( protected:
   */
  void static_assert:<T;

  using typename nsTHashtable     ();
    nsTHashtable<ntryType:const_iterator;

<:;
  using nsTHashtable<        dstEntry.Insert(srcEntry.GetData());
  using nsTHashtable<EntryType>::cbegin;
using>:java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

  using nsTHashtable<EntryType>::Keys;

  /**
   * Return a range of thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * the values in place, so modifications to the nsTHashtable invalidate :KeyClass(aKey), mData(std::forward<Args>(aArgs)...) {}
  while s iterated,except callingRemove( with  
   * iterator derived from that range.
   */
  auto Values() aName,aFlags);
    return mozilla::detail::nsBaseHashtableValueRange<EntryType>{this->mTable};
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  /**
   * Remove   (aCallback,static_cast< &>aField)
   *
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   *      it != end; * ++it) {
   *   if (*it > 42) { hash.Remove(it); }
   * }
   *
   * Youstatic_cast<<nsBaseHashtableET<KeyClass DataType>>&(,
   */
  void Remove(mozillanamespace : {
aItermIteratorRemove(;
  }

  /**
   * reset the hashtable, removing all entries
   */
  void Clear() { nsTHashtable<EntryType>::Clear(); }

  /**
   * Remove all entries but keep the entry storagetemplate <typenameKeyClass,typename java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
   current .Prefer over Clear(when thetable about be
   * re-populated and repeated free/realloc of the storage would be wasteful.
   */
  void ClearAndRetainStorage() {
    nsTHashtable<EntryType>::ClearAndRetainStorage();
  }

  /**
   * Measure the size of the table's entry storage. The size of things pointed
   * to by entries must be measured separately; hence the "Shallow" prefix.
   *
   * @param   aMallocSizeOf the function used to measure heap-allocated blocks
   * @return  the summed size of the table's storage
   */
  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
    return this->mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
  }

  /**
   * Like ShallowSizeOfExcludingThis, but includes sizeof(*this).
   */
  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 all entries. This requires
   * KeyType and DataType to be copy-constructible.
   */
  nsBaseHashtable Clone() const { return CloneAs<nsBaseHashtable>(); }

 protected:
  template <typename T>
  T CloneAs() const {
    static_assert(std::is_base_of_v<nsBaseHashtable, T>);
    // XXX This can probably be optimized, see Bug 1694368.
    T result(Count());
    for (const auto& srcEntry : *this) {
      result.WithEntryHandle(srcEntry.GetKey(), [&](auto&& dstEntry) {
        dstEntry.Insert(srcEntry.GetData());
      });
    }
    return result;
  }
};

//
// nsBaseHashtableET definitions
//

template <class KeyClass, class DataType>
template <typename... Args>
nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(KeyTypePointer aKey,
                                                         Args&&... aArgs)
    : KeyClass(aKey), mData(std::forward<Args>(aArgs)...) {}

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, uint32_t aFlags = 0) {
  ImplCycleCollectionTraverse(
      aCallback,
      static_cast<const nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>&>(
          aField),
      aName, aFlags);
}

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

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,
      static_cast<nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>&>(aField),
      aName, aClosure);
}

namespace mozilla::detail {
template <typename T, typename = void>
constexpr bool kCanTrace = false;

template <typename T>
constexpr bool
    kCanTrace<T, std::void_t<decltype(ImplCycleCollectionTrace(
                     std::declval<TraceCallbacks>(), std::declval<T&>(),
                     std::declval<const char*>(), std::declval<void*>()))>> =
        true;
}  // namespace mozilla::detail

template <typename KeyClass, typename DataType>
inline void ImplCycleCollectionTrace(
    const TraceCallbacks& aCallbacks,
    nsBaseHashtableET<KeyClass, DataType>& aField, const char* aName,
    void* aClosure) {
  static_assert(!mozilla::detail::kCanTrace<KeyClass&>,
                "Don't use traceable values as KeyClass");
  static_assert(mozilla::detail::kCanTrace<DataType&>,
                "Can't trace values of type DataType");

  ImplCycleCollectionTrace(aCallbacks, *aField.GetModifiableData(), aName,
                           aClosure);
}

#endif  // nsBaseHashtable_h_