uritemplate.h

#ifndef SOURCEMETA_CORE_URITEMPLATE_H_
#define SOURCEMETA_CORE_URITEMPLATE_H_
 
#ifndef SOURCEMETA_CORE_URITEMPLATE_EXPORT
#include <sourcemeta/core/uritemplate_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/uritemplate_error.h>
#include <sourcemeta/core/uritemplate_router.h>
#include <sourcemeta/core/uritemplate_token.h>
// NOLINTEND(misc-include-cleaner)
 
#include <cstddef>     // std::size_t
#include <cstdint>     // std::uint64_t
#include <functional>  // std::function
#include <optional>    // std::optional
#include <string>      // std::string
#include <string_view> // std::string_view
#include <tuple>       // std::tuple
#include <type_traits> // std::void_t
#include <vector>      // std::vector

 
namespace sourcemeta::core {

using URITemplateValue = std::optional<
    std::tuple<std::string_view, std::optional<std::string_view>, bool>>;

enum class URITemplateExpansionMode : std::uint8_t {
  URI,
  IRI
};

using URITemplateParseResult =
    std::optional<std::pair<URITemplateToken, std::size_t>>;

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplate {
public:
  URITemplate(const std::string_view source);

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

  [[nodiscard]] static auto is_literal(char32_t codepoint) noexcept -> bool;

  [[nodiscard]] auto size() const noexcept -> std::uint64_t;

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

  [[nodiscard]] auto at(std::size_t index) const & -> const URITemplateToken &;

  [[nodiscard]] auto at(std::size_t index) && -> URITemplateToken;

  [[nodiscard]] auto begin() const noexcept
      -> std::vector<URITemplateToken>::const_iterator;

  [[nodiscard]] auto end() const noexcept
      -> std::vector<URITemplateToken>::const_iterator;

  [[nodiscard]] auto
  expand(const std::function<URITemplateValue(std::string_view)> &callback,
         URITemplateExpansionMode mode = URITemplateExpansionMode::URI) const
      -> std::string;

  template <typename Container,
            typename = std::void_t<typename Container::key_type>>
  [[nodiscard]] auto expand(
      const Container &variables,
      const URITemplateExpansionMode mode = URITemplateExpansionMode::URI) const
      -> std::string {
    return this->expand(
        [&variables](const std::string_view name) -> URITemplateValue {
          const auto iterator{find_variable(variables, name)};
          if (iterator == variables.end()) {
            return std::nullopt;
          }
          return std::make_tuple(std::string_view{iterator->second},
                                 std::nullopt, false);
        },
        mode);
  }
 
private:
  // Prefer a heterogeneous lookup so the key is not materialized when the
  // container supports it
  template <typename Container>
  static auto find_variable(const Container &variables,
                            const std::string_view name) {
    if constexpr (requires { variables.find(name); }) {
      return variables.find(name);
    } else {
      return variables.find(typename Container::key_type{name});
    }
  }
 
// 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(push)
#pragma warning(disable : 4251)
#endif
  std::vector<URITemplateToken> tokens_;
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
};
 
} // namespace sourcemeta::core
 
#endif