Url.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef   ZYPP_URL_H
#define   ZYPP_URL_H
 
#include <set>
#include <zypp-core/url/UrlBase.h>
#include <zypp-core/url/UrlUtils.h>
 

namespace zypp
{ 
 
  class Url;
  namespace hotfix1050625 {
    std::string asString( const Url & url_r );
  }
  namespace filesystem {
    class Pathname;
  }
  using filesystem::Pathname;

  class ZYPP_API Url
  {
  public:
    using EEncoding = zypp::url::EEncoding;

    using ViewOptions = zypp::url::ViewOptions;
 
 
    ~Url();
    Url();

    Url(const Url &url);
 

    Url(zypp::url::UrlRef url);
 

    Url(const std::string &encodedUrl);
 

    Url(Url &&other) = default;
 
 
    // -----------------
    static url::UrlRef
    parseUrl(const std::string &encodedUrl);
 
 
    // -----------------
    Url&
    operator = (const std::string &encodedUrl);
 

    Url&
    operator = (const Url &url);
 

    Url &operator=(Url &&other) = default;
 
 
    // -----------------
    static bool
    registerScheme(const std::string &scheme,
                   url::UrlRef       urlImpl);

    static zypp::url::UrlSchemes
    getRegisteredSchemes();

    static bool
    isRegisteredScheme(const std::string &scheme);
 
 
    // -----------------
    zypp::url::UrlSchemes
    getKnownSchemes() const;
 

    bool
    isValidScheme(const std::string &scheme) const;
 

    static bool schemeIsLocal( const std::string & scheme_r );
    bool schemeIsLocal() const { return schemeIsLocal( getScheme() ); }

    static bool schemeIsRemote( const std::string & scheme_r );
    bool schemeIsRemote() const { return schemeIsRemote( getScheme() ); }

    static bool schemeIsVolatile( const std::string & scheme_r );
    bool schemeIsVolatile() const { return schemeIsVolatile( getScheme() ); }

    static bool schemeIsDownloading( const std::string & scheme_r );
    static bool schemeIsHttpLike( const std::string & scheme_r );
    static bool schemeIsFtpLike( const std::string & scheme_r );
    bool schemeIsDownloading() const { return schemeIsDownloading( getScheme() ); }
    bool schemeIsHttpLike() const { return schemeIsHttpLike( getScheme() ); }
    bool schemeIsFtpLike() const { return schemeIsFtpLike( getScheme() ); }

    static bool schemeIsPlugin( const std::string & scheme_r );
    bool schemeIsPlugin() const { return schemeIsPlugin( getScheme() ); }

    bool
    isValid() const;
 
 
    // -----------------
    std::string
    asString() const;

    std::string
    asString(const ViewOptions &opts) const;

    std::string
    asCompleteString() const;
 
 
    // -----------------
    std::string
    getScheme() const;
 
 
    // -----------------
    std::string
    getAuthority() const;

    std::string
    getUsername(EEncoding eflag = zypp::url::E_DECODED) const;

    std::string
    getPassword(EEncoding eflag = zypp::url::E_DECODED) const;

    bool hasCredentialsInAuthority() const
    { return ! ( getUsername().empty() || getPassword().empty() ); }

    std::string
    getHost(EEncoding eflag = zypp::url::E_DECODED) const;

    std::string
    getPort() const;
 
 
    // -----------------
    std::string
    getPathData() const;

    std::string
    getPathName(EEncoding eflag = zypp::url::E_DECODED) const;

    std::string
    getPathParams() const;

    zypp::url::ParamVec
    getPathParamsVec() const;

    zypp::url::ParamMap
    getPathParamsMap(EEncoding eflag = zypp::url::E_DECODED) const;

    std::string
    getPathParam(const std::string &param,
                 EEncoding eflag = zypp::url::E_DECODED) const;
 
 
    // -----------------
    std::string
    getQueryString() const;

    zypp::url::ParamVec
    getQueryStringVec() const;

    zypp::url::ParamMap
    getQueryStringMap(EEncoding eflag = zypp::url::E_DECODED) const;

    std::string
    getQueryParam(const std::string &param,
                  EEncoding eflag = zypp::url::E_DECODED) const;
 
 
    // -----------------
    std::string
    getFragment(EEncoding eflag = zypp::url::E_DECODED) const;
 
 
    // -----------------
    void
    setScheme(const std::string &scheme);
 
 
    // -----------------
    void
    setAuthority(const std::string &authority);

    void
    setUsername(const std::string &user,
                EEncoding         eflag = zypp::url::E_DECODED);

    void
    setPassword(const std::string &pass,
                EEncoding         eflag = zypp::url::E_DECODED);

    void
    setHost(const std::string &host);

    void
    setPort(const std::string &port);
 
 
    // -----------------
    void
    setPathData(const std::string &pathdata);

    void
    setPathName(const std::string &path,
                EEncoding         eflag = zypp::url::E_DECODED);
    void
    setPathName(const Pathname &path,
                EEncoding         eflag = zypp::url::E_DECODED);
    void
    setPathName(const char *path,
                EEncoding         eflag = zypp::url::E_DECODED);

    void appendPathName( const Pathname & path_r, EEncoding eflag_r = zypp::url::E_DECODED );

    void pathNameSetTrailingSlash( bool apply_r = true );

    void
    setPathParams(const std::string &params);

    void
    setPathParamsVec(const zypp::url::ParamVec &pvec);

    void
    setPathParamsMap(const zypp::url::ParamMap &pmap);

    void
    setPathParam(const std::string &param, const std::string &value);
 
 
    // -----------------
    void
    setQueryString(const std::string &querystr);

    void
    setQueryStringVec(const zypp::url::ParamVec &qvec);

    void
    setQueryStringMap(const zypp::url::ParamMap &qmap);

    void
    setQueryParam(const std::string &param, const std::string &value);

    void
    delQueryParam(const std::string &param);

    void
    delQueryParams(const std::set<std::string> &params);
 
 
    // -----------------
    void
    setFragment(const std::string &fragment,
                EEncoding         eflag = zypp::url::E_DECODED);
 
 
    // -----------------
    ViewOptions
    getViewOptions() const;

    void
    setViewOptions(const ViewOptions &vopts);
 
  private:
    friend std::string hotfix1050625::asString( const Url & url_r );
    url::UrlRef m_impl;
  };
 
  std::ostream & operator<<( std::ostream & str, const Url & url ) ZYPP_API;

  bool operator<( const Url &lhs, const Url &rhs ) ZYPP_API;

  bool operator==( const Url &lhs, const Url &rhs ) ZYPP_API;
 
 
  bool operator!=( const Url &lhs, const Url &rhs ) ZYPP_API;

} // namespace zypp
 
#endif /* ZYPP_URL_H */
/*
** vim: set ts=2 sts=2 sw=2 ai et:
*/