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 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()) {}
 
  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