uri.h

#ifndef SOURCEMETA_CORE_URI_H_
#define SOURCEMETA_CORE_URI_H_
 
#ifndef SOURCEMETA_CORE_URI_EXPORT
#include <sourcemeta/core/uri_export.h>
#endif
 
#include <sourcemeta/core/text.h>
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/uri_error.h>
// NOLINTEND(misc-include-cleaner)
 
#include <concepts>    // std::convertible_to, std::same_as
#include <cstddef>     // std::size_t, std::ptrdiff_t
#include <cstdint>     // std::uint32_t
#include <filesystem>  // std::filesystem
#include <istream>     // std::istream
#include <iterator>    // std::forward_iterator_tag
#include <memory>      // std::unique_ptr
#include <optional>    // std::optional
#include <span>        // std::span
#include <string>      // std::string
#include <string_view> // std::string_view
#include <type_traits> // std::is_same_v, std::remove_cvref_t
#include <utility>     // std::pair, std::forward
#include <vector>      // std::vector

 
namespace sourcemeta::core {

class SOURCEMETA_CORE_URI_EXPORT URI {
public:
  URI() = default;

  URI(const URI &) = default;

  URI(URI &&) noexcept = default;

  auto operator=(const URI &) -> URI & = default;

  auto operator=(URI &&) noexcept -> URI & = default;

  template <typename T>
    requires std::convertible_to<T, std::string_view> &&
             (!std::is_same_v<std::decay_t<T>, URI>)
  explicit URI(T &&input) {
    this->parse(std::string_view{std::forward<T>(input)});
  }

  URI(std::istream &input);

  [[nodiscard]] auto is_absolute() const noexcept -> bool;

  [[nodiscard]] auto is_urn() const -> bool;

  [[nodiscard]] auto is_tag() const -> bool;

  [[nodiscard]] auto is_mailto() const -> bool;

  [[nodiscard]] auto is_file() const -> bool;

  [[nodiscard]] auto is_http() const -> bool;

  [[nodiscard]] auto is_https() const -> bool;

  [[nodiscard]] auto is_fragment_only() const -> bool;

  [[nodiscard]] auto is_relative() const -> bool;

  [[nodiscard]] auto is_ipv4() const -> bool;

  [[nodiscard]] auto is_ipv6() const -> bool;

  [[nodiscard]] auto is_loopback() const -> bool;

  [[nodiscard]] auto is_localhost() const -> bool;

  [[nodiscard]] auto empty() const -> bool;

  [[nodiscard]] auto scheme() const -> std::optional<std::string_view>;

  [[nodiscard]] auto host() const -> std::optional<std::string_view>;

  [[nodiscard]] auto port() const -> std::optional<std::uint32_t>;

  [[nodiscard]] auto authority() const -> std::optional<std::string>;

  [[nodiscard]] auto path() const -> std::optional<std::string_view>;

  auto path(const std::string &path) -> URI &;

  auto path(std::string &&path) -> URI &;

  auto append_path(std::string_view path) -> URI &;

  auto append_path(const URI &reference) -> URI &;

  auto append_path(URI &&reference) -> URI &;

  auto extension(std::string &&extension) -> URI &;

  [[nodiscard]] auto fragment() const -> std::optional<std::string_view>;

  auto fragment(const std::string_view fragment) -> URI &;

  class SOURCEMETA_CORE_URI_EXPORT Query {
  public:
    explicit Query(const std::string_view raw);

    [[nodiscard]] auto raw() const -> std::string_view;

    [[nodiscard]] auto at(const std::string_view name) const
        -> std::optional<std::string_view>;

    class SOURCEMETA_CORE_URI_EXPORT const_iterator {
    public:
      using iterator_category = std::forward_iterator_tag;
      using value_type = std::pair<std::string_view, std::string_view>;
      using difference_type = std::ptrdiff_t;
      using reference = const value_type &;
      using pointer = const value_type *;
 
      const_iterator() = default;
      const_iterator(const std::string_view raw, const std::size_t pair_start);
 
      [[nodiscard]] auto operator*() const -> reference;
      [[nodiscard]] auto operator->() const -> pointer;
      auto operator++() -> const_iterator &;
      auto operator++(int) -> const_iterator;
      [[nodiscard]] auto operator==(const const_iterator &other) const -> bool;
      [[nodiscard]] auto operator!=(const const_iterator &other) const -> bool;
 
    private:
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
      std::string_view raw_{};
      std::size_t pair_start_{std::string_view::npos};
      value_type current_{};
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
    };

    [[nodiscard]] auto begin() const -> const_iterator;

    [[nodiscard]] auto end() const -> const_iterator;
 
  private:
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
    std::string_view raw_;
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
  };

  [[nodiscard]] auto query() const -> std::optional<Query>;

  auto query(const std::string_view query) -> URI &;

  [[nodiscard]] auto recompose() const -> std::string;

  [[nodiscard]] auto recompose_relative() const -> std::string;

  [[nodiscard]] auto recompose_without_fragment() const
      -> std::optional<std::string>;

  auto canonicalize() -> URI &;

  [[nodiscard]] auto to_path() const -> std::filesystem::path;

  auto resolve_from(const URI &base) -> URI &;

  auto relative_to(const URI &base) -> URI &;

  auto rebase(const URI &base, const URI &new_base) -> URI &;

  auto rebase(const URI &base, URI &&new_base) -> URI &;

  [[nodiscard]] auto has_same_authority(const URI &other) const noexcept
      -> bool;

  [[nodiscard]] auto userinfo() const -> std::optional<std::string_view>;

  auto userinfo(const std::string_view userinfo) -> URI &;

  auto operator==(const URI &other) const noexcept -> bool;

  auto operator<(const URI &other) const noexcept -> bool;

  static auto from_fragment(const std::string_view fragment) -> URI;

  static auto from_path(const std::filesystem::path &path) -> URI;

  static auto from_iri(std::string_view input) -> URI;

  [[nodiscard]] auto is_internationalized() const noexcept -> bool;

  static auto canonicalize(std::string_view input) -> std::string;

  [[nodiscard]] static auto escape(std::string_view input,
                                   bool maybe_encoded = false) -> std::string;

  template <typename Output>
  static auto escape(const std::string_view input, Output &output,
                     const bool maybe_encoded = false) -> void {
    output.reserve(output.size() + input.size() * 3);
    for (std::size_t position = 0; position < input.size();) {
      auto byte{static_cast<unsigned char>(input[position])};
      std::size_t advance{1};
      // Treat the input as possibly already encoded by decoding each valid
      // escape before re-encoding, so a valid escape survives and a needlessly
      // encoded unreserved octet is decoded
      if (maybe_encoded && input[position] == '%' &&
          position + 2 < input.size()) {
        const auto high{hex_digit_value(input[position + 1])};
        const auto low{high < 0 ? static_cast<std::int8_t>(-1)
                                : hex_digit_value(input[position + 2])};
        if (low >= 0) {
          byte = static_cast<unsigned char>((high << 4) | low);
          advance = 3;
        }
      }
 
      position += advance;
      // RFC 3986 Section 2.3: the unreserved set passes through unescaped
      if (is_alphanum(static_cast<char>(byte)) || byte == '-' || byte == '.' ||
          byte == '_' || byte == '~') {
        output.push_back(static_cast<char>(byte));
      } else {
        // RFC 3986 Section 2.1: percent-encode with uppercase hexadecimal
        const auto high{static_cast<unsigned char>((byte >> 4U) & 0x0FU)};
        const auto low{static_cast<unsigned char>(byte & 0x0FU)};
        output.push_back('%');
        output.push_back(
            static_cast<char>(high < 10 ? '0' + high : 'A' + high - 10));
        output.push_back(
            static_cast<char>(low < 10 ? '0' + low : 'A' + low - 10));
      }
    }
  }

  template <typename Output>
  static auto append_query_parameter(Output &sink, const std::string_view name,
                                     const std::string_view value,
                                     const char opener = '?') -> void {
    if (!sink.empty() && sink.back() != opener && sink.back() != '&') {
      sink.push_back('&');
    }
 
    URI::escape(name, sink);
    sink.push_back('=');
    URI::escape(value, sink);
  }

  [[nodiscard]] static auto unescape(std::string_view input) -> std::string;

  template <typename Output>
  [[nodiscard]] static auto unescape_form(const std::string_view input,
                                          Output &output) -> bool {
    const auto base{output.size()};
    output.reserve(base + input.size());
    for (std::size_t position = 0; position < input.size();) {
      const auto character{input[position]};
      if (character == '+') {
        output.push_back(' ');
        position += 1;
      } else if (character == '%') {
        const auto high{position + 2 < input.size()
                            ? hex_digit_value(input[position + 1])
                            : static_cast<std::int8_t>(-1)};
        const auto low{high < 0 ? static_cast<std::int8_t>(-1)
                                : hex_digit_value(input[position + 2])};
        if (low < 0) {
          output.resize(base, '\0');
          return false;
        }
 
        output.push_back(static_cast<char>((high << 4) | low));
        position += 3;
      } else {
        output.push_back(character);
        position += 1;
      }
    }
 
    return true;
  }

  [[nodiscard]] static auto normalize_path(std::string_view path)
      -> std::string;

  [[nodiscard]] static auto is_scheme(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_gen_delim(char character) noexcept -> bool;

  [[nodiscard]] static auto is_uri(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_uri_reference(std::string_view input) noexcept
      -> bool;

  [[nodiscard]] static auto is_iri(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_iri_reference(std::string_view input) noexcept
      -> bool;

  [[nodiscard]] static auto strip_path_prefix(std::string_view path,
                                              std::string_view prefix)
      -> std::optional<std::string>;

  [[nodiscard]] static auto rebase_path(std::string_view path,
                                        std::string_view old_prefix,
                                        std::string_view new_prefix)
      -> std::optional<std::string>;
 
private:
  auto parse(std::string_view input) -> void;
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
  std::optional<std::string> path_{};
  std::optional<std::string> userinfo_{};
  std::optional<std::string> host_{};
  std::optional<std::uint32_t> port_{};
  std::optional<std::string> scheme_{};
  std::optional<std::string> fragment_{};
  std::optional<std::string> query_{};
  bool ip_literal_{false};
  // Whether this object was parsed as an IRI (RFC 3987) rather than a URI
  // (RFC 3986)
  bool iri_{false};
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
};
 
} // namespace sourcemeta::core
 
#endif