Uri.h

#pragma once
 
#include <ada.h>
#include <ada/url_search_params.h>
 
#include <functional>
#include <optional>
#include <string>
#include <string_view>
 
namespace CesiumUtility {

class Uri final {
public:
  Uri(const std::string& uri);
  Uri(const Uri& base, const std::string& relative, bool useBaseQuery = false);

  std::string_view toString() const;

  bool isValid() const;

  operator bool() const { return this->isValid(); }

  std::string_view getScheme() const;

  std::string_view getHost() const;

  std::string_view getPath() const;

  std::string_view getFileName() const;

  std::string_view getStem() const;

  std::string_view getExtension() const;

  std::string_view getQuery() const;

  void setPath(const std::string_view& path);

  void setQuery(const std::string_view& queryString);

  static std::string resolve(
      const std::string& base,
      const std::string& relative,
      bool useBaseQuery = false,
      bool assumeHttpsDefault = true);
  static std::string addQuery(
      const std::string& uri,
      const std::string& key,
      const std::string& value);
  static std::string
  getQueryValue(const std::string& uri, const std::string& key);

  typedef std::string
  SubstitutionCallbackSignature(const std::string& placeholder);

  static std::string substituteTemplateParameters(
      const std::string& templateUri,
      const std::function<SubstitutionCallbackSignature>& substitutionCallback);

  static std::string escape(const std::string& s);

  static std::string unescape(const std::string& s);

  static std::string unixPathToUriPath(const std::string& unixPath);

  static std::string windowsPathToUriPath(const std::string& windowsPath);

  static std::string nativePathToUriPath(const std::string& nativePath);

  static std::string uriPathToUnixPath(const std::string& uriPath);

  static std::string uriPathToWindowsPath(const std::string& uriPath);

  static std::string uriPathToNativePath(const std::string& uriPath);

  static std::string getPath(const std::string& uri);

  static std::string
  setPath(const std::string& uri, const std::string& newPath);
 
private:
  std::optional<ada::url_aggregator> _url = std::nullopt;
  bool _hasScheme = false;
};

class UriQuery final {
public:
  UriQuery(const std::string_view& queryString) : _params(queryString) {}
  UriQuery(const Uri& uri) : _params(uri.getQuery()) {}
  UriQuery() = default;

  std::optional<std::string_view> getValue(const std::string& key) {
    return this->_params.get(key);
  }

  void setValue(const std::string& key, const std::string& value) {
    this->_params.set(key, value);
  }

  bool hasValue(const std::string& key) { return this->_params.has(key); }

  std::string toQueryString() const { return this->_params.to_string(); }

  inline auto begin() const { return this->_params.begin(); }
  inline auto end() const { return this->_params.end(); }
  inline auto front() const { return this->_params.front(); }
  inline auto back() const { return this->_params.back(); }
 
private:
  ada::url_search_params _params;
};
 
} // namespace CesiumUtility