UrlBase.h

Go to the documentation of this file.

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

namespace zypp
{ 

  namespace url
  { 
 
 
    // ---------------------------------------------------------------
    struct ZYPP_API ViewOption
    {
      static const ViewOption WITH_SCHEME ZYPP_API;
      static const ViewOption WITH_USERNAME ZYPP_API;
      static const ViewOption WITH_PASSWORD ZYPP_API;
      static const ViewOption WITH_HOST ZYPP_API;
      static const ViewOption WITH_PORT ZYPP_API;
      static const ViewOption WITH_PATH_NAME ZYPP_API;
      static const ViewOption WITH_PATH_PARAMS ZYPP_API;
      static const ViewOption WITH_QUERY_STR ZYPP_API;
      static const ViewOption WITH_FRAGMENT ZYPP_API;

      static const ViewOption EMPTY_AUTHORITY ZYPP_API;
      static const ViewOption EMPTY_PATH_NAME ZYPP_API;
      static const ViewOption EMPTY_PATH_PARAMS ZYPP_API;
      static const ViewOption EMPTY_QUERY_STR ZYPP_API;
      static const ViewOption EMPTY_FRAGMENT ZYPP_API;

      static const ViewOption DEFAULTS ZYPP_API;
 

      ViewOption();
 

      friend inline ViewOption
      operator + (const ViewOption &l, const ViewOption &r)
      {
        return ViewOption(l.opt |  r.opt);
      }

      friend inline ViewOption
      operator - (const ViewOption &l, const ViewOption &r)
      {
        return ViewOption(l.opt & ~r.opt);
      }

      inline ViewOption &
      operator = (const ViewOption &o)
      {
        opt = o.opt; return *this;
      }

      inline bool
      has(const ViewOption &o) const
      {
        return o.opt & opt;
      }
 
      static const ViewOption hotfix1050625;
    private:
      ViewOption(int option);
      int opt;
    };
 
 
    // ---------------------------------------------------------------
    using ViewOptions = ViewOption;
 
 
    // ---------------------------------------------------------------
    using UrlSchemes = std::vector<std::string>;
 
 
    // ---------------------------------------------------------------
    class UrlBaseData;
 
 
    // ---------------------------------------------------------------
    class UrlBase
    {
    public:
 
      virtual
      ~UrlBase();
 
      UrlBase();

      UrlBase(const UrlBase &url);

      UrlBase(const std::string &scheme,
              const std::string &authority,
              const std::string &pathdata,
              const std::string &querystr,
              const std::string &fragment);
 
 
      // -----------------
      virtual void
      clear();

      virtual UrlBase *
      clone() const;

      virtual void
      init(const std::string &scheme,
           const std::string &authority,
           const std::string &pathdata,
           const std::string &querystr,
           const std::string &fragment);
 
 
      // -----------------
      virtual UrlSchemes
      getKnownSchemes() const;

      virtual bool
      isKnownScheme(const std::string &scheme) const;
 

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

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

      virtual std::string
      asString(const zypp::url::ViewOptions &opts) const;
 
 
      // -----------------
      virtual std::string
      getScheme() const;
 
 
      // -----------------
      virtual std::string
      getAuthority() const;

      virtual std::string
      getUsername(EEncoding eflag) const;

      virtual std::string
      getPassword(EEncoding eflag) const;

      virtual std::string
      getHost(EEncoding eflag) const;

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

      virtual std::string
      getPathName(EEncoding eflag) const;

      virtual std::string
      getPathParams() const;

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

      virtual zypp::url::ParamMap
      getPathParamsMap(EEncoding eflag) const;

      virtual std::string
      getPathParam(const std::string &param, EEncoding eflag) const;
 
 
      // -----------------
      virtual std::string
      getQueryString() const;

      virtual std::string
      getQueryString( const ViewOptions & viewopts_r ) const;

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

      virtual zypp::url::ParamMap
      getQueryStringMap(EEncoding eflag) const;

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

      virtual void
      setUsername(const std::string &user,
                  EEncoding         eflag);

      virtual void
      setPassword(const std::string &pass,
                  EEncoding         eflag);

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

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

      virtual void
      setPathName(const std::string &path,
                  EEncoding         eflag);

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

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

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

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

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

      virtual void
      setQueryStringMap(const zypp::url::ParamMap &qmap, EEncoding eflag);

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

      virtual void
      delQueryParam(const std::string &param);
 
      void
      delQueryParams(const std::set<std::string> &params);
 
      // -----------------
      virtual void
      setFragment(const std::string &fragment,
                  EEncoding         eflag);
 
 
      // -----------------
      virtual void
      configure();
 

      std::string
      config(const std::string &opt) const;

      void
      config(const std::string &opt, const std::string &val);
 

      ViewOptions
      getViewOptions() const;

      void
      setViewOptions(const ViewOptions &vopts);
 
      std::string asString1050625() const;
    protected:
      virtual std::string
      cleanupPathName(const std::string &path, bool authority) const;

      virtual std::string
      cleanupPathName(const std::string &path) const;

      virtual bool
      isValidHost(const std::string &host) const;

      virtual bool
      isValidPort(const std::string &port) const;
 
    private:
      UrlBaseData *m_data;
    };
 
 
    // ---------------------------------------------------------------
    using UrlRef = RWCOW_pointer<UrlBase>;
 

  } // namespace url

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