Url.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef   ZYPP_URL_H
#define   ZYPP_URL_H

#include <zypp/url/UrlBase.h>
#include <zypp/url/UrlUtils.h>


namespace zypp
{ 


  class Url
  {
  public:
    typedef zypp::url::EEncoding    EEncoding;

    typedef zypp::url::ViewOptions  ViewOptions;


    ~Url();
    Url();

    Url(const Url &url);


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


    Url(const std::string &encodedUrl);


    // -----------------
    static url::UrlRef
    parseUrl(const std::string &encodedUrl);


    // -----------------
    Url&
    operator = (const std::string &encodedUrl);


    Url&
    operator = (const Url &url);


    // -----------------
    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 );
    bool schemeIsDownloading() const { return schemeIsDownloading( 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
    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
    setFragment(const std::string &fragment,
                EEncoding         eflag = zypp::url::E_DECODED);


    // -----------------
    ViewOptions
    getViewOptions() const;

    void
    setViewOptions(const ViewOptions &vopts);

  private:
    url::UrlRef m_impl;
  };

  std::ostream & operator<<( std::ostream & str, const Url & url );

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

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


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

} // namespace zypp

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