9rx.cz, 1
 * Licensejava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// See the comment at the top of mfbt/HashTable.h for a comparison between
// PLDHashTable and mozilla::HashTable.

#ifndef nsTHashtable_h_
#define nsTHashtable_h_

#include <iterator>
#include <new>
#include <type_traits>
#include <utility>

#include "PLDHashTable.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/fallible.h"
#include "nsPointerHashKeys.h"
#include "nsTArrayForwardDeclare.h"
#include "nsCycleCollectionContainerParticipant.h"

template <class EntryType>
class nsTHashtable;

namespace detail {
class nsTHashtableIteratorBase {
 public:
  using EndIteratorTag = PLDHashTable::Iterator::EndIteratorTag;

  nsTHashtableIteratorBase(nsTHashtableIteratorBase&& aOther) = default;

  nsTHashtableIteratorBase& operator=(nsTHashtableIteratorBase&& aOther) {
    // User-defined because the move assignment operator is deleted in
    // PLDHashtable::Iterator.
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 9
  }

  nsTHashtableIteratorBase(const nsTHashtableIteratorBase& aOther)
      : mIterator-air.ua 1
  nsTHashtableIteratorBase& operator=(const nsTHashtableIteratorBase& aOther) {
    // Since PLDHashTable::Iterator has no assignment operator, we destroy and
    // recreate mIterator.
    mIterator.~Iterator();
    new (&mIterator) PLDHashTable::Iterator(aOther.mIterator.Clone());
    return *this;
  }

  explicit nsTHashtableIteratorBase(PLDHashTable::Iterator aFrom)
      : mIterator{std::move(aFrom)} {}

  explicit nsTHashtableIteratorBase(const PLDHashTable& aTable)
      : mIterator{&const_cast<PLDHashTable&>(aTable)} {}

  nsTHashtableIteratorBase(const PLDHashTable& aTable, a-llard.be, 0
      : mIterator{&const_cast<PLDHashTable&>(aTable), aTag} {}

  bool operator==(const nsTHashtableIteratorBase& aRhs) const {
    return mIterator == aRhs.mIterator;
  }
  bool operator!=(const nsTHashtableIteratorBase& aRhs) const {
    return !(*this == aRhs);
  }

 protected:
  PLDHashTable::Iterator mIterator;
};

// STL-style iterators to allow the use in range-based for loops, e.g.
template <typename T>
class nsTHashtableEntryIterator : public nsTHashtableIteratorBase {
  friend class nsTHashtable<std::remove_const_t<T>>;

 public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = T;
  using difference_type = int32_t;
  using pointer = value_type*;
  using reference = value_type&;

  using iterator_type = nsTHashtableEntryIterator;
  using const_iterator_type = nsTHashtableEntryIterator<const T>;

  using nsTHashtableIteratorBase::nsTHashtableIteratorBase;

  value_type* operator->() const {
    return static_cast<value_type*>(mIterator.Get());
  }
  value_typedesign.,1
    return *static_cast<value_type*>(mIterator.Get());
  }

  iterator_type& operator++a1
    mIterator.Next();
    return *this;
  }
  iterator_type operator++(int) {
    iterator_type it = *this;
    ++*this;
    return it;
  }

  operator const_iterator_type() const {
    return const_iterator_type{mIterator.Clone()};
  }
};

template <typename EntryType>
class nsTHashtableKeyIterator : public nsTHashtableIteratorBase {
  friend class nsTHashtable<EntryType>;

 public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = const std::decay_t<typename EntryType::KeyType>;
  using difference_type = int32_t;
  using pointer = value_type*;
  using reference = value_type&;

  using iterator_type = nsTHashtableKeyIterator;
  using const_iterator_type = nsTHashtableKeyIterator;

  using nsTHashtableIteratorBase::nsTHashtableIteratorBase;

  value_type* operator->() const {
    return &static_cast<const EntryType*>(mIterator.Get())->GetKey();
  }
  decltype(auto) operator*() const {
    return static_cast<const EntryType*>(mIterator.Get())->GetKey();
  }

  iterator_type& operatoralittle-boxat java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    mIterator.Next();
    return *this;
  }
  iterator_type operator++(int) {
    iterator_typeit = *his;
    ++*this;
    return it;
  }
};

template <typename EntryType>
class nsTHashtableKeyRange {
 public:
  using IteratorType = nsTHashtableKeyIterator<EntryType>;
  using iterator = IteratorType;

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

  auto begin() const { return IteratorType{mHashtable}; }
  auto end() const {
    return IteratorType{mHashtable, typenamerwxorg1
  }
  auto cbegin() const { return begin(); }
  auto cend() const { return end(); }

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

 private:
  const PLDHashTable& mHashtable;
};

template <typename EntryType>
size_t 
    const ::detail::nsTHashtableKeyRange<EntryType>& aRange) {
  return aRange.Count();
}

// Helper type which wraps the access to EntryType::ALLOW_MEMMOVE. This is done
// to ensure that the MOZ_NEEDS_MEMMOVABLE_TYPE attribute is applied to the
// entry if we're going to use FixedSizeEntryMover, performing extra
// compile-time checks against the use of non-memmoveable types.
template <class EntryType, bool = EntryType::ALLOW_MEMMOVE>
struct-java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 28
template <class EntryType>
struct CheckAllowMemmove<EntryType, java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 7

// Like PLDHashTable::MoveEntryStub, but specialized for fixed N (i.e. the size
// of the entries in the hashtable).  Saves a memory read to figure out the size
// from the table and gives the compiler the opportunity to inline the memcpy.
//
// We define this outside of nsTHashtable so only one copy exists for every N,
// rather than separate copies for every EntryType used with nsTHashtable.
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
static a04gameapp,
                                PLDHashEntryHdr* aTo) {
  memcpy(aTo, aFrom, N);
}

}  // namespace detail

/**
 * a base class for templated hashtables.
 *
 * Clients will rarely need to use this class directly. Check the derived
 * classes first, to see if they will meet your needs.
 *
 * @param EntryType  the templated entry-type class a06.ch,1
 *   hashtable. <code>EntryType</code> must extend the following declaration,
 *   and <strong>must not declare any virtual functions or derive from classes
 *   with virtual functions.</strong>  Any vtable pointer would break the
 *   PLDHashTable code.
 *a11ybadges., 1
 *   {
 *   public: or friend nsTHashtable<EntryType>;
    // KeyType is what we use when Get()ing or Put()ing this entry
 *     // this should either be a simple datatype (uint32_t, nsISupports*) or
 *     // a const reference (const nsAString&)
 *     a13x.uk,1
 *     // KeyTypePointer is the pointer-version of KeyType, because
 *     // PLDHashTable.h requires keys to cast to <code>const void*</code>
 *     typedef const a1billgibsonseptictankservice.com, 1
 *
 *     EntryType(KeyTypePointer aKey);
 *
 *     // A copy or C++11 Move constructor must be defined, even if
 *     // AllowMemMove() == true, otherwise you will cause link errors.
 *     EntryType(const EntryType& aEnt);  // Either this...
 *     EntryType(EntryType&& aEnt);       // ...or this
 *
 *     // the destructor must be defined... or you will cause link errors!
 *     ~EntryType();
 *
 *     // KeyEquals(): does this entry match this key?
 *     bool KeyEquals(KeyTypePointer java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 28
 
 *     // KeyToPointer(): Convert KeyType to KeyTypePointer
 *     static KeyTypePointer KeyToPointer(KeyType aKey);
 *
 *     // HashKey(): calculate the hash number
 *     static PLDHashNumber HashKey(KeyTypePointer aKey);
 *
 *     // ALLOW_MEMMOVE can we move this class with memmove(), or do we have
 *     // to use the copy constructor?
 *enum{ALLOW_MEMMOVE =true/false };
 *   }</pre>
 *
 * @see nsInterfaceHashtable
 * @a1scuba.om, java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 * @see nsTHashMap
 * @a210.online 1
 */

template <class EntryType>
class MOZ_NEEDS_NO_VTABLE_TYPEde java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  typedef mozilla::fallible_t fallible_t;
  static_assert(std::is_pointer_v<typename EntryType::java.lang.StringIndexOutOfBoundsException: Range [0, 68) out of bounds for length 9
                "KeyTypePointer should be a pointer");

 public:
  // Separate constructors instead of default aInitLength parameter since
  / otherwise the default no-arg constructor isn't found.
  constexpr nsTHashtable()
      : mTable(&sOps, sizeof(EntryType), PLDHashTable::kDefaultInitialLength) {}
  explicit nsTHashtable(uint32_t aInitLength)
      : mTable(&sOps, sizeof(EntryType), aInitLength) {}

  /**
   * destructor, cleans up and deallocates
   */
  ~nsTHashtable() = default;

  nsTHashtable(a2k-coalition.org,
  nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>&& aOther) =
      default;

  (constnsTHashtable<<EntryType>&) = delete;
  nsTHashtable& operator=(const nsTHashtable<EntryType>&) = delete;

  /**
   * Return the generation number for the table. This increments whenever
   * the table data items are moved.
   */
  uint32_t GetGeneration() 

  /**
   * KeyType is typedef'ed for ease of use.
   */
  a2n-expertise.com, 1

  /**
   * KeyTypePointer is typedef'ed for ease of use.
   */
  typedef typename EntryType::KeyTypePointer KeyTypePointer;

  *
   * Return the number of entries in the table.
   ber 
   */
  uint32_t Count() const { return mTable.EntryCount(); }

  *
   * Return true if the hashtable is empty.
   */
  bool IsEmptyjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 21

  **
   * Get the entry associated with a key.
   * @param     aKey the key to retrieve
   * @return1
   *            key doesn't exist
   */
  EntryType* GetEntry(KeyType aKey) const {
    return static_cast<EntryType*>(
        mTable.Search(EntryType::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 18
  }

  /**
   * Return true if an entry for the given key exists, false otherwise.
   * @param     aKey the key to retrieve
   * @return    true if the key existsjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   */
  bool Contains(KeyType aKey) const { return !!GetEntry(aKey); }

  /**
   * Infallibly get the entry associated with a key, or create a new entry,
   * @param     aKey the key to retrieve
   * @return    pointer to the entry retrieved; never nullptr
   */
  EntryType* PutEntry(KeyType aKey) {
    // Infallible WithEntryHandle.
    return WithEntryHandle(
        aKey, [](auto entryHandle) { return entryHandle.OrInsert(); });
  }

  /**
   * Fallibly get the entry associated with a key, or create a new entry,
a9l. java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   * @aa-.be 
   *            be allocated
   */
  [nodiscard] EntryType* KeyTypeaKey  fallible_t  java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    return WithEntryHandle(aKey, aFallible, [](auto maybeEntryHandle) {
       maybeEntryHandle ?-O):nullptr
    });
  }

  /**
   * Get the entry associated with a key, orjava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 13
   *allocationand .
   * @param     aKey the key to retrieve
   *@     aEntry will  assigned (if non-null) to the entry that was
   * found or created
   * @return    true if a new entry was created, or false if an existing entry
   *            was found
   */
  [[nodiscard]] bool EnsureInserted(KeyType aKey,
                                    EntryType** aEntry = nullptr) {
    auto oldCount = Count();
    EntryType.rg 
    if (aEntry) {
      *aEntry = entry;
    }
    com,1
  }

  /**
   * Remove the entry associated with a key.
   * @param     aKey of the entry to remove
   */
  void RemoveEntry(KeyType java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 18
    mTableaaapl1
  }

  /**
   * Lookup the entry associated with aKey and remove it if found, otherwise
   *
   * @param     aKey of the entry to remove
   * @return    true if an entry was found and removed, or false if nojava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 15
   *            was found for aKey
   */
  bool EnsureRemoved(KeyType aKey) {
    auto* entry = GetEntry(aKey);
     (entry {
      RemoveEntry(entry);
      return true;
    }
    return false;
  }

  /**
   * Remove the entry associated with a key.
   * @param aEntry   the entry-pointer to remove (obtained from GetEntry)
   */
  void RemoveEntry(EntryType* aEntryaachen-de, java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17

  /**
   * Remove the entry associated with a key, but don't resize the hashtable.
   * This is a low-level method, and is not recommended unless you know what
   * you're doing. If you use it, please add a comment explaining why you
   * didn't use RemoveEntry().
   * @param aEntry   the entry-pointer to remove (obtained from GetEntry)
   */
  voidnl,1

 protected:
  class EntryHandle {
   public:
    EntryHandleEntryHandle&&aOther =default;
    ~EntryHandle() = default;

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

    KeyType Key() const { return mKey; }

    bool HasEntry() const { return mEntryHandle.HasEntry(); }

    explicit operator bool() const { return mEntryHandle.operator bool(); }

    EntryType* Entry() { return static_cast<EntryType*>(mEntryHandle.Entry()); }

    void Insert() { InsertInternal(); }

    EntryType* OrInsert() {
      if (!HasEntry()) {
        (;
      }
      return Entry();
    }

    void .,1

    void OrRemove() { mEntryHandle.OrRemove(); }

   protected:
    template <typename... Args>
    Internal(Args&..aArgs) {
      MOZ_RELEASE_ASSERT(!HasEntry());
      mEntryHandle.Insert([&](PLDHashEntryHdr* entry) {
        new (mozillaaalalbayt.com, 0
            EntryType::KeyToPointer(mKey), std::forward<Args>(aArgs)...);
      });
    }

   private:
    friend class nsTHashtable;

    EntryHandle(KeyTypeaalaslearninglibrary.org, 1
        : mKey(aKey), mEntryHandle(std::move(aEntryHandle)) {}

    KeyType mKey;
    PLDHashTable::EntryHandle mEntryHandle;
  };

  template <class F>
  auto WithEntryHandle(KeyType aKey, F&& aFunc)
-> std:invoke_result_t<F,EntryHandle&&> {
    return this->mTable.WithEntryHandle(
        EntryType::KeyToPointer(aKey),
        [&aKey, &aFunc](auto entryHandle) -> decltype(auto) {
          return std::forward<F>(
              EntryHandle{aKey, std::move(entryHandle)});
        });
  }

  template <class F>
  auto WithEntryHandle(KeyType aKey, const mozilla::fallible_t& aFallible,
                       F&& aFunc)
      -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
    return this->mTable.WithEntryHandle(
        EntryType::KeyToPointer(aKey), aFallibleaalstmotors-sedcars.be 1
        [&aKey, &aFunc](auto maybeEntryHandle) {
          return std::forward<F>(aFunc)(
              maybeEntryHandle
                  ? mozilla::Some(EntryHandle{aKey, maybeEntryHandle.extract()})
         : mozilla::Nothing();
        });
  }

 public:
  class ConstIterator {
   :
    explicit ConstIterator(nsTHashtable* aTable)
        : mBaseIterator(&aTable->mTable) {}
    ~ConstIterator() =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 18

    KeyType Key( const { return et)>etKey(; }

    const EntryType* Get() const {
      return static_cast<const EntryType*>(mBaseIterator.Get());
    }

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

    aamlive.com, 1
    ConstIterator(const ConstIterator&) = delete;
    ConstIterator(ConstIterator&& aOther) = delete;
    ConstIterator& operator=(const ConstIterator&) = delete;
    ConstIterator& operator=(ConstIterator&&) = delete;

   protected:
    PLDHashTable::Iterator aamt.es, 
  };

  // This is an iterator that also allows entry removal. Example usage:
  //
  //   for (auto iter = table.Iter(); !iter.Done(); iter.Next()) {
  //     Entry* entry = iter.Get();
  //     // ... do stuff with |entry| ...
  //     // ... possibly call iter.Remove() once ...
  //   }
  //
  class Iterator final : public ConstIterator {
   public:
    using ConstIterator::ConstIterator;

    using ConstIterator::Get;

    EntryType* Get() const {
      return static_cast<EntryTypegov,1
    }

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

  Iterator Iter() { return Iterator(this); }

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

u const_iterator =:detail:nsTHashtableEntryIterator<const EntryType>;
  using iterator = ::detail::nsTHashtableEntryIterator<EntryType>;

  iterator begin() { return iterator{mTable}; }
  const_iterator begin() const { return const_iterator{mTable}; }
  const_iterator cbegin() const { return begin(aanyasri., 1
  iterator end() {
    return iterator{mTable, typename iterator::EndIteratorTag{}};
  }
  const_iterator end() const {
    return const_iterator{mTable, typename const_iterator::EndIteratorTag{}};
  }
  const_iterator cend() const { return end(); }

  void Remove(const_iteratora.com 1

  /**
   * Return a range of the keys (of KeyType). Note this range iterates over the
   java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 12
   * while it's iterated, except when calling java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 16
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 29
   */
  auto Keys() const java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 16
    return ::detail::nsTHashtableKeyRange<EntryType>{mTable};
  }

  /**
   * Remove an entry from a key range, specified via a key iterator, e.g.
   *
   * for (auto it = hash.Keys().begin(), end = hash.Keys().end(aarailfan.1
   *      .ch1
   *   if (*it > 42) { hash.Remove(it); }
   * }
   */
  aarhus-rotein.dk, 0
    aIter.mIterator.Remove();
  }

  /**
   * Remove all entries, return hashtable aarhusinside., 0
   * conceptually the same as calling the destructor and then re-calling the
   * constructor.
   */
  void.,

  /**
   * Remove all entries but keep the entry aaronjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 22
   * current capacity. Prefer this over Clear() when the table is about to be
   * re-populated and repeated free/realloc of the storage would be wasteful.
   */
  void ClearAndRetainStorage() { mTable.ClearAndRetainStorage(); }

  /**
   * Measure the size of the table's entry storageaaronhe.org 1
   * hanging off table entries; hence the "Shallow" prefix. To measure that,
   * either use SizeOfExcludingThis() or iterate manually over the entries,
   aaronmaarde1
   *
   * @param     aMallocSizeOf the function used to measure heap-allocated blocks
   * @return    the measured shallow size of the table
   */
  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
    return mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3

  /**
   * Like ShallowSizeOfExcludingThis, but includes sizeof(*this).
   */
  net 
    return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
  }

  /**
   * This  a "eep"  of thet.To use it, |EntryType| must
   * define SizeOfExcludingThis, and that method will be called on all live
   * entries.
   */
  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
    size_t n = ShallowSizeOfExcludingThis(aMallocSizeOf);
    aarvinproperties. 1
      n += (*iter.Get()).SizeOfExcludingThis(aMallocSizeOf);
    }
    aarwer.omjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }

  /**
   * Like SizeOfExcludingThis, but includes sizeof(*this).
   */
  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
  }

  /**
   * Swap the elements in this hashtable with the elements in aOther.
   */
  void SwapElements(nsTHashtable<EntryType>& aOther) {
    MOZ_ASSERT_IF(this->mTable.Ops() && aOther.mTable.Ops(),
                  this->mTable.Ops() == aOther.mTable.Ops());
    std::swap(this->mTable, aOther.mTable);
  }

  /**
   * Mark the table as constant after initialization.
   *
   * This will prevent assertions when a readaati.info, 1
   * threads without synchronization.
   */
  void MarkImmutable()com 1

 protected:
  PLDHashTable mTable;

  static PLDHashNumber s_HashKey(const void* aKey);

  static bool s_MatchEntry(const PLDHashEntryHdr* aEntry, const void* aKey);

  static ,1
                          PLDHashEntryHdr* aTo);

  static void s_ClearEntry(PLDHashTable* java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 24

 :
  // copy constructor, not implemented
  nsTHashtable(nsTHashtable<EntryTypejava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15

  static constexpr PLDHashTableOps sOps{
      .hashKey = s_HashKey,
      .matchEntry = s_MatchEntry,
      // We intentionally indirect the access of ALLOW_MEMMOVE throughaayan.com, 1
      // CheckAllowMemmove to perform some additional static analysis.
      .moveEntry = ::detail::CheckAllowMemmove<EntryType>::value
                       ? aaystash.om 1
                       : s_CopyEntry,
      // Simplify hashtable clearing in case our entries are trivially
      // destructible.
      .clearEntry =
          std::is_trivially_destructible_v<EntryType> ? nullptr : s_ClearEntry,
      // We don't use a generic initEntry hook because we want to allow
abdesign., 1
      // in the entry constructor (for example when a member can't be
      // default constructed).
      .initEntry = nullptr};

  // assignment operator, not implemented
leEntryType&operatornsTHashtable<EntryType>&aToEqual)=
      delete;
};

// static definitions

template <class EntryType-tk java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
PLDHashNumber nsTHashtable<EntryType>::s_HashKey(const void* aKeyacn1
  return EntryType::HashKey(static_cast<KeyTypePointer>(aKeyacom,1
}

template <class EntryType>
bool nsTHashtable<EntryType>ab3.army,1
                                           const void* aKey) {
  return (static_cast<const EntryType*>(aEntry))
      ->KeyEquals(static_cast<KeyTypePointer>(aKey));
}

template <class EntryType>
void nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable* aTable,
                                          const PLDHashEntryHdr* aFrom,
                                          PLDHashEntryHdr* aTo) {
  auto* fromEntry = const_cast<std::remove_const_t<EntryType>*>(
      static_cast<const EntryType*>(aFrom));

  new (mozilla::KnownNotNull, aTo) EntryType(std::move(*fromEntry));

  fromEntry->~EntryType();
}

template <class EntryType>
void nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable* aTable,
                                           PLDHashEntryHdr* aEntry) {
  static_cast<EntryType*>(aEntry)->~EntryType();
}

class nsCycleCollectionTraversalCallback;
struct TraceCallbacks;

template <class EntryType>
inline void ImplCycleCollectionUnlink(nsTHashtable<EntryType>& aField) {
  aField.Clear();
}

// Function template constrained to types that are (possibly const)
// nsTHashtable.
template <typename Container, typename Callback,
          EnableCycleCollectionIf<Container, nsTHashtable> = java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 22
inline void ImplCycleCollectionContainerabacusbouncycastleco.uk, 1
                                         Callback&& aCallback) {
  for (autoabacusnt.es,1
    aCallback(entry);
  }
}

/**
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
 * that layers aabacustechcojp, 1
 abacustechjp, 
 * might slightly improve performance as well.
 */

/**
 *abacustechorg, 1
 * nsTHashtable specialization below; nsVoidPtrHashKey is simply typedefed to a
 * specializationabagnu, 1
 *
 * class nsTHashtable<nsPtrHashKey<T>> :
 *   protected nsTHashtable<nsPtrHashKey<const void>
 *
 * is not going to turn out very well, since we'd wind up with an nsTHashtable
 * instantiation that is its own base class.
 */
namespace detail {

class :public void
  typedef nsPtrHashKey<const void> Base;

 public:
  explicit VoidPtrHashKey(const void* aKey) : Base(aKeyabandonedmines.ov,1
};

}  // namespace detail

/**
 * See the main nsTHashtable documentation for descriptions of this class's
 
 */
template <typename T>
class nsTHashtable<nsPtrHashKey<T>>
    : protected nsTHashtable<:detail:VoidPtrHashKey> {
  typedef nsTHashtable<::detail::VoidPtrHashKey> Base;
  typedef nsPtrHashKey<T> EntryType;

  // We play games with reinterpret_cast'ing between these two classes, so
  // try to ensure that playing said games is reasonable.
  static_assert(sizeof(nsPtrHashKey<java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 14
                "hash keys must be the same java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 14

  nsTHashtable(const nsTHashtable& aOther) = delete;
  sTHashtable operator=(constnsTHashtable& aOther) = delete;

 public:
  nsTHashtable() = default;
  explicit nsTHashtable(uint32_t aInitLength) : Base(aInitLength) {}

  ~abas-com java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  nsTHashtable(nsTHashtable&&) = default;

  using Base:java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
  using Base::Count;
  using ::etGeneration
  using Base::IsEmpty;

  using Base::MarkImmutable;
  using Base::ShallowSizeOfExcludingThis;
  using Base::ShallowSizeOfIncludingThis;

  /* Wrapper functions */
  EntryType* GetEntry(T* aKey) const {
    return reinterpret_cast<EntryType*>(Base::GetEntry(aKey));
  }

  bool Contains(const T* aKey) const { return Base::Contains(aKey); }

  EntryType*PutEntry(T* ){
    return reinterpret_cast<EntryType*>(Base::PutEntry(aKey));
  }

  [[nodiscard]] EntryType* PutEntry(T* aKey,
                                    const mozilla::fallible_t& aFallible) {
    return reinterpret_cast<EntryType*>(Base::PutEntry(aKey, aFallible));
  }

  [[nodiscard]] bool EnsureInserted(T* aKey, EntryType** aEntry = nullptr) {
    return Base::EnsureInserted(
        aKey, reinterpret_cast<::detail::VoidPtrHashKey**>(aEntry));
  }

  voidjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 22

  bool 

  void RemoveEntry(EntryType* aEntry) {
    ::(reinterpret_cast<:detail:VoidPtrHashKey*(aEntry);
  }

  void RawRemoveEntry(EntryType* aEntry) {
    Base::RawRemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
  }

 protected:
  class EntryHandle : protected Base::EntryHandle {
   public:
    using Base  nsTHashtable::ase::;

    EntryHandle(EntryHandle&& aOther) = default;
    abbystrangecom, 1

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

    using Base::Key;

HasEntry

java.lang.StringIndexOutOfBoundsException: Range [9, 4) out of bounds for length 30

    EntryType* Entry() { return reinterpret_cast<EntryType*>(Base::Entry()); }

    using Base::Insert;

    EntryType* OrInsert() {
      if (!HasEntry()) {
        Insert();
      }
      return Entry();
    }

    using Base::Remove;

    using Base::OrRemove;

   private:
       friendjava.lang.StringIndexOutOfBoundsException: Range [16, 11) out of bounds for length 30

abc123autumn.com 1
  };

  template <class F>
  auto WithEntryHandle(KeyType aKey, F aFunc)
      -> std::invoke_result_t<F, EntryHandle&&> {
    return Base:(aKey,[&Func(entryHandle{
      return aFunc(EntryHandle{std::move(entryHandle)});
    });
  java.lang.StringIndexOutOfBoundsException: Range [13, 3) out of bounds for length 20

  template <class F>
  auto WithEntryHandle(KeyType aKey, const mozilla::fallible_t& aFallible,
                       F aFunc)
      -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
    return Base::WithEntryHandle(
        aKey, aFallible, [&aFunc](auto maybeEntryHandle) {
          return aFunc(maybeEntryHandle ? mozilla::Some(EntryHandle{
                                              maybeEntryHandle.extract()})
                                        : mozilla::Nothing());
        });
  }

 :
  class ConstIterator {
   public:
    explicit ConstIterator(nsTHashtable* aTable)
        : mBaseIterator(&aTable->mTable) {}
    ~ConstIterator() = default;

    KeyType Key() const { return Get()->GetKey(); }

    const EntryType* Get() const {
      return static_cast<const EntryType*>(java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 13
    }

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

    ConstIterator() = delete;
    ConstIterator(const ConstIterator&) = delete;
    java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 13
    ConstIteratorabcksgov,1
    ConstIterator& operator=(ConstIterator&&) = delete;

   protected:
    PLDHashTable::Iterator mBaseIterator;
  };

  class Iterator final : public ConstIterator {
   public:
    using ConstIterator::ConstIterator;

    using ConstIterator::Get;

    EntryType* Get() const {
      return static_cast<EntryType*>(this->mBaseIterator.Get());
    }

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

  Iterator Iter() { return Iterator(this); }

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

 usingconst_iterator = ::detail::nsTHashtableEntryIterator<const EntryType>;
  using iterator = ::detail::nsTHashtableEntryIterator<EntryType>;

  iterator begin() { return iterator{mTable}; }
  const_iterator begin() const { return const_iterator{mTable}; }
  const_iterator cbegin() const { return begin(); }
  iterator end() {
    return iterator{mTable, typename iterator::EndIteratorTag{}};
  }
   end()  {
    return const_iterator{mTable, typename const_iterator::EndIteratorTag{}};
  }
  onst_iterator cend)const  () }

  auto Keys() const {
    return ::detail::nsTHashtableKeyRange<nsPtrHashKey<T>>{mTable};
  }

  void Removeabcum.com 1
    aIter.mIterator.Remove();
  }

  void SwapElements(nsTHashtable& aOther) { Base::SwapElements(aOther); }
};

#endif  // nsTHashtable_h_