ResolvedModuleSet.h

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * 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 js_loader_ResolvedModuleSet_h

#define js_loader_ResolvedModuleSet_h

#include "mozilla/AlreadyAddRefed.h"

#include "mozilla/HashTable.h"

#include "nsIURI.h"

#include "nsCOMPtr.h"

namespace JS::loader {

// https://html.spec.whatwg.org/#specifier-resolution-record

struct SpecifierResolutionRecord {

  SpecifierResolutionRecord(const nsACString& aSerializedBaseURL,

                            const nsAString& aNormalizedSpecifier,

                            nsIURI* aResult, bool aIsURLLike,

                            bool aIsSpecialScheme)

      : mSerializedBaseURL(aSerializedBaseURL),

        mNormalizedSpecifier(aNormalizedSpecifier),

        mResult(aResult),

        mIsURLLike(aIsURLLike),

        mIsSpecialScheme(aIsSpecialScheme) {}

  const nsACString& SerializedBaseURL() const { return mSerializedBaseURL; }

  const nsAString& NormalizedSpecifier() const { return mNormalizedSpecifier; }

  nsIURI* Result() const { return mResult; }

  already_AddRefed<nsIURI> TakeResult() { return mResult.forget(); }

  bool IsURLLike() const { return mIsURLLike; }

  bool IsAsURLNull() const { return !mIsURLLike; }

  bool IsSpecialScheme() const { return mIsSpecialScheme; }

  mozilla::HashNumber Hash() const {

    return mozilla::AddToHash(mozilla::HashString(mSerializedBaseURL.get()),

                              mozilla::HashString(mNormalizedSpecifier.get()));

  bool Match(const mozilla::UniquePtr<SpecifierResolutionRecord>& aLookup) {

    bool eq = mSerializedBaseURL.Equals(aLookup->SerializedBaseURL()) &&

              mNormalizedSpecifier.Equals(aLookup->NormalizedSpecifier());

    MOZ_ASSERT_IF(eq, mIsURLLike == aLookup->IsURLLike());

    MOZ_ASSERT_IF(eq, mIsSpecialScheme == aLookup->IsSpecialScheme());

    return eq;

  const nsCString mSerializedBaseURL;

  const nsString mNormalizedSpecifier;

  // Resolved result during preload.

  nsCOMPtr<nsIURI> mResult;

  const bool mIsURLLike;

  const bool mIsSpecialScheme;

};

struct SpecifierResolutionHasher {

  using Key = mozilla::UniquePtr<SpecifierResolutionRecord>;

  using Lookup = const Key&;

  static mozilla::HashNumber hash(Lookup aLookup) { return aLookup->Hash(); }

  static bool match(const Key& aKey, Lookup aLookup) {

    return aKey->Match(aLookup);

};

// https://html.spec.whatwg.org/#resolved-module-set

using ResolvedModuleSet =

    mozilla::HashSet<mozilla::UniquePtr<SpecifierResolutionRecord>,

                     SpecifierResolutionHasher, InfallibleAllocPolicy>;

}  // namespace JS::loader

#endif  // js_loader_ResolvedModuleSet_h