URL.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_URL_H__
#define __ARC_URL_H__

#include <iostream>
#include <list>
#include <map>
#include <string>


// Default ports for different protocols
#define RC_DEFAULT_PORT 389
#define HTTP_DEFAULT_PORT 80
#define HTTPS_DEFAULT_PORT 443
#define HTTPG_DEFAULT_PORT 8443
#define LDAP_DEFAULT_PORT 389
#define FTP_DEFAULT_PORT 21
#define GSIFTP_DEFAULT_PORT 2811
#define LFC_DEFAULT_PORT 5010
#define XROOTD_DEFAULT_PORT 1094


namespace Arc {

  class URLLocation;


  class URL {

  public:
    URL();

    /* \param url      The string representation of URL
       \param encoded  Set to true if URL is encoded according to RFC 3986 */
    URL(const std::string& url, bool encoded = false);

    virtual ~URL();

    enum Scope {
      base, onelevel, subtree
    };


    void URIDecode(void);

    const std::string& Protocol() const;

    void ChangeProtocol(const std::string& newprot);

    const std::string& Username() const;

    const std::string& Passwd() const;

    const std::string& Host() const;

    void ChangeHost(const std::string& newhost);

    int Port() const;

    void ChangePort(int newport);

    const std::string& Path() const;

    std::string FullPath() const;


    std::string FullPathURIEncoded() const;

    void ChangePath(const std::string& newpath);

    void ChangeFullPath(const std::string& newpath, bool encoded = false);

    const std::map<std::string, std::string>& HTTPOptions() const;


    const std::string& HTTPOption(const std::string& option,
                                  const std::string& undefined = "") const;


    bool AddHTTPOption(const std::string& option, const std::string& value,
                   bool overwrite = true);


    void RemoveHTTPOption(const std::string& option);

    const std::list<std::string>& LDAPAttributes() const;

    void AddLDAPAttribute(const std::string& attribute);

    Scope LDAPScope() const;

    void ChangeLDAPScope(const Scope newscope);

    const std::string& LDAPFilter() const;

    void ChangeLDAPFilter(const std::string& newfilter);

    const std::map<std::string, std::string>& Options() const;


    const std::string& Option(const std::string& option,
                              const std::string& undefined = "") const;

    const std::map<std::string, std::string>& MetaDataOptions() const;


    const std::string& MetaDataOption(const std::string& option,
                                      const std::string& undefined = "") const;


    bool AddOption(const std::string& option, const std::string& value,
                   bool overwrite = true);


    bool AddOption(const std::string& option, bool overwrite = true);

    void AddMetaDataOption(const std::string& option, const std::string& value,
                           bool overwrite = true);

    void AddLocation(const URLLocation& location);

    const std::list<URLLocation>& Locations() const;

    const std::map<std::string, std::string>& CommonLocOptions() const;


    const std::string& CommonLocOption(const std::string& option,
                                       const std::string&
                                       undefined = "") const;


    void RemoveOption(const std::string& option);


    void RemoveMetaDataOption(const std::string& option);

    virtual std::string str(bool encode = false) const;

    virtual std::string plainstr(bool encode = false) const;

    virtual std::string fullstr(bool encode = false) const;

    virtual std::string ConnectionURL() const;

    bool operator<(const URL& url) const;

    bool operator==(const URL& url) const;

    operator bool() const;
    bool operator!() const;

    bool StringMatches(const std::string& str) const;


    std::map<std::string, std::string> ParseOptions(const std::string& optstring,
                                                    char separator, bool encoded = false);


    static std::string OptionString(const std::map<std::string,
                                    std::string>& options, char separator, bool encode = false);


    static std::string URIEncode(const std::string& str);


    static std::string URIDecode(const std::string& str);

  protected:
    std::string protocol;

    std::string username;

    std::string passwd;

    std::string host;

    bool ip6addr;

    int port;

    std::string path;

    std::map<std::string, std::string> httpoptions;

    std::map<std::string, std::string> metadataoptions;

    std::list<std::string> ldapattributes;

    Scope ldapscope;

    std::string ldapfilter;

    std::map<std::string, std::string> urloptions;

    std::list<URLLocation> locations;

    std::map<std::string, std::string> commonlocoptions;

    bool valid;

    static std::string BaseDN2Path(const std::string&);

    static std::string Path2BaseDN(const std::string&);

    friend std::ostream& operator<<(std::ostream& out, const URL& u);

    void ParsePath(bool encoded = false);
  };



  class URLLocation
    : public URL {

  public:
    URLLocation(const std::string& url = "");

    URLLocation(const std::string& url, const std::string& name);

    URLLocation(const URL& url);

    URLLocation(const URL& url, const std::string& name);

    URLLocation(const std::map<std::string, std::string>& options,
                const std::string& name);

    virtual ~URLLocation();

    const std::string& Name() const;

    virtual std::string str() const;

    virtual std::string fullstr() const;

  protected:
    std::string name;
  };



  class PathIterator {
  public:

    PathIterator(const std::string& path, bool end = false);
    ~PathIterator();

    PathIterator& operator++();

    PathIterator& operator--();

    operator bool() const;

    std::string operator*() const;

    std::string Rest() const;

  private:
    const std::string& path;
    std::string::size_type pos;
    bool end;
    bool done;
  };


  std::list<URL> ReadURLList(const URL& urllist);

} // namespace Arc

#endif //  __ARC_URL_H__