uritemplate_router.h

#ifndef SOURCEMETA_CORE_URITEMPLATE_ROUTER_H_
#define SOURCEMETA_CORE_URITEMPLATE_ROUTER_H_
 
#ifndef SOURCEMETA_CORE_URITEMPLATE_EXPORT
#include <sourcemeta/core/uritemplate_export.h>
#endif
 
#include <sourcemeta/core/io.h>
 
#include <cstddef> // std::size_t
#include <cstdint> // std::uint16_t, std::uint32_t, std::uint8_t, std::int64_t
#include <filesystem>    // std::filesystem::path
#include <functional>    // std::function
#include <memory>        // std::unique_ptr
#include <span>          // std::span
#include <string>        // std::string
#include <string_view>   // std::string_view
#include <tuple>         // std::tuple
#include <unordered_map> // std::unordered_map
#include <utility>       // std::pair
#include <variant>       // std::variant
#include <vector>        // std::vector
 
namespace sourcemeta::core {
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouter {
  friend class URITemplateRouterView;
 
public:
  using Identifier = std::uint16_t;

  using Index = std::uint8_t;

  using Callback =
      std::function<void(Index, std::string_view, std::string_view)>;

  using ArgumentValue = std::variant<std::string_view, std::int64_t, bool>;

  using Argument = std::pair<std::string_view, ArgumentValue>;

  using ArgumentCallback =
      std::function<void(std::string_view, const ArgumentValue &)>;

  enum class NodeType : std::uint8_t {
    Root = 0,
    Literal = 1,
    Variable = 2,
    Expansion = 3,
    OptionalExpansion = 4
  };

  struct Node {
    Identifier identifier{0};
    Identifier context{0};
    NodeType type{NodeType::Root};
    std::string_view value;
 
    // This children distinction enforces that there can only be one non-literal
    // child at the type level. Also allows us to more efficiently search on
    // literals
    std::vector<std::unique_ptr<Node>> literals;
    std::unique_ptr<Node> variable;
  };

  URITemplateRouter() = default;

  explicit URITemplateRouter(std::string_view base_path,
                             std::string_view base_url = {});
 
  // To avoid mistakes
  URITemplateRouter(const URITemplateRouter &) = delete;
  URITemplateRouter(URITemplateRouter &&) = delete;
  auto operator=(const URITemplateRouter &) -> URITemplateRouter & = delete;
  auto operator=(URITemplateRouter &&) -> URITemplateRouter & = delete;

  auto add(const std::string_view uri_template,
           const std::string_view operation_id, const Identifier identifier,
           const Identifier context = 0,
           const std::span<const Argument> arguments = {}) -> void;

  auto otherwise(const Identifier context,
                 const std::span<const Argument> arguments = {}) -> void;

  [[nodiscard]] auto match(const std::string_view path,
                           const Callback &callback) const
      -> std::pair<Identifier, Identifier>;

  [[nodiscard]] auto
  describes(const std::string_view path,
            const std::string_view base_path = {}) const noexcept -> bool;

  [[nodiscard]] auto root() const noexcept -> const Node &;

  auto arguments(const Identifier identifier,
                 const ArgumentCallback &callback) const -> void;

  [[nodiscard]] auto arguments() const noexcept
      -> const std::vector<std::pair<Identifier, std::vector<Argument>>> &;

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

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

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

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

  [[nodiscard]] auto context(const Identifier identifier) const -> Identifier;

  [[nodiscard]] auto path(const Identifier identifier) const -> std::string;

  [[nodiscard]] auto operation(const std::string_view operation_id) const
      -> std::pair<Identifier, Identifier>;

  [[nodiscard]] auto operation_id(const Identifier identifier) const
      -> std::string_view;
 
private:
  Node root_;
  Node otherwise_;
  std::string base_path_;
  std::string base_url_;
  std::vector<std::pair<Identifier, std::vector<Argument>>> arguments_;
  std::vector<std::tuple<Identifier, Identifier, std::string_view>> entries_;
  std::unordered_map<std::string_view, std::pair<Identifier, Identifier>>
      operations_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterView {
public:
  static auto save(const URITemplateRouter &router,
                   const std::filesystem::path &path) -> void;

  URITemplateRouterView(const std::filesystem::path &path);

  URITemplateRouterView(const std::uint8_t *data, std::size_t size);
 
  ~URITemplateRouterView();
 
  // To avoid mistakes
  URITemplateRouterView(const URITemplateRouterView &) = delete;
  URITemplateRouterView(URITemplateRouterView &&) = delete;
  auto operator=(const URITemplateRouterView &)
      -> URITemplateRouterView & = delete;
  auto operator=(URITemplateRouterView &&) -> URITemplateRouterView & = delete;

  [[nodiscard]] auto match(const std::string_view path,
                           const URITemplateRouter::Callback &callback) const
      -> std::pair<URITemplateRouter::Identifier,
                   URITemplateRouter::Identifier>;

  [[nodiscard]] auto
  describes(const std::string_view path,
            const std::string_view base_path = {}) const noexcept -> bool;

  auto arguments(const URITemplateRouter::Identifier identifier,
                 const URITemplateRouter::ArgumentCallback &callback) const
      -> void;

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

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

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

  [[nodiscard]] auto operation(const std::string_view operation_id) const
      -> std::pair<URITemplateRouter::Identifier,
                   URITemplateRouter::Identifier>;

  [[nodiscard]] auto at(const std::size_t index) const
      -> URITemplateRouter::Identifier;

  [[nodiscard]] auto
  context(const URITemplateRouter::Identifier identifier) const
      -> URITemplateRouter::Identifier;

  [[nodiscard]] auto path(const URITemplateRouter::Identifier identifier) const
      -> std::string;

  [[nodiscard]] auto
  operation_id(const URITemplateRouter::Identifier identifier) const
      -> std::string_view;
 
private:
  const std::uint8_t *data_{nullptr};
  std::size_t size_{0};
  std::unique_ptr<FileView> owner_;
  // Holds an eight-byte-aligned copy of an unaligned external buffer, so the
  // over-aligned serialized nodes are always read from aligned storage
  std::vector<std::uint64_t> owned_;
};
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
} // namespace sourcemeta::core
 
#endif