url.h

Go to the documentation of this file.

/*
 * url.h
 *
 * Universal Resource Locator (for HTTP/HTML) class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 24412 $
 * $Author: rjongbloed $
 * $Date: 2010-05-27 18:53:50 -0500 (Thu, 27 May 2010) $
 */

#ifndef PTLIB_PURL_H
#define PTLIB_PURL_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#if P_URL


// PURL

class PURLLegacyScheme;

class PURL : public PObject
{
  PCLASSINFO(PURL, PObject)
  public:
    PURL();
    PURL(
      const char * cstr,    
      const char * defaultScheme = "http" 
    );
    PURL(
      const PString & str,  
      const char * defaultScheme = "http" 
    );
    PURL(
      const PFilePath & path   
    );

    PURL(const PURL & other);
    PURL & operator=(const PURL & other);

    virtual Comparison Compare(
      const PObject & obj   
    ) const;

    virtual PINDEX HashFunction() const;

    virtual void PrintOn(
      ostream &strm   
    ) const;

    virtual void ReadFrom(
      istream &strm   
    );
 
    inline PBoolean Parse(
      const char * cstr,   
      const char * defaultScheme = NULL 
    ) { return InternalParse(cstr, defaultScheme); }
    inline PBoolean Parse(
      const PString & str, 
      const char * defaultScheme = NULL 
    ) { return InternalParse((const char *)str, defaultScheme); }

    enum UrlFormat {
      FullURL,      
      PathOnly,     
      URIOnly,      
      HostPortOnly  
    };

    PString AsString(
      UrlFormat fmt = FullURL   
    ) const;
    operator PString() const { return AsString(); }

    PFilePath AsFilePath() const;

    enum TranslationType {
      LoginTranslation,
      PathTranslation,
      QueryTranslation
    };

    static PString TranslateString(
      const PString & str,    
      TranslationType type    
    );

    static PString UntranslateString(
      const PString & str,    
      TranslationType type    
    );

    static void SplitVars(
      const PString & str,    
      PStringToString & vars, 
      char sep1,              
      char sep2               
    );

    static void SplitQueryVars(
      const PString & queryStr,   
      PStringToString & queryVars 
    ) { SplitVars(queryStr, queryVars, '&', '='); }



    const PCaselessString & GetScheme() const { return scheme; }

    void SetScheme(const PString & scheme);

    const PString & GetUserName() const { return username; }

    void SetUserName(const PString & username);

    const PString & GetPassword() const { return password; }

    void SetPassword(const PString & password);

    const PCaselessString & GetHostName() const { return hostname; }

    void SetHostName(const PString & hostname);

    WORD GetPort() const { return port; }

    void SetPort(WORD newPort);
    
    PBoolean GetPortSupplied() const { return portSupplied; }

    PBoolean GetRelativePath() const { return relativePath; }

    PString GetPathStr() const;

    void SetPathStr(const PString & pathStr);

    const PStringArray & GetPath() const { return path; }

    void SetPath(const PStringArray & path);

    void AppendPath(const PString & segment);

    PString GetParameters() const;

    void SetParameters(const PString & parameters);

    const PStringToString & GetParamVars() const { return paramVars; }

    void SetParamVars(const PStringToString & paramVars);

    void SetParamVar(
      const PString & key,          
      const PString & data,         
      bool emptyDataDeletes = true  
    );

    const PString & GetFragment() const { return fragment; }

    PString GetQuery() const;

    void SetQuery(const PString & query);

    const PStringToString & GetQueryVars() const { return queryVars; }

    void SetQueryVars(const PStringToString & queryVars);

    void SetQueryVar(const PString & key, const PString & data);

    const PString & GetContents() const { return m_contents; }

    void SetContents(const PString & str);

    PBoolean IsEmpty() const { return urlString.IsEmpty(); }


    static PBoolean OpenBrowser(
      const PString & url   
    );

    PBoolean LegacyParse(const PString & url, const PURLLegacyScheme * schemeInfo);
    PString LegacyAsString(PURL::UrlFormat fmt, const PURLLegacyScheme * schemeInfo) const;

  protected:
    void CopyContents(const PURL & other);
    virtual PBoolean InternalParse(
      const char * cstr,         
      const char * defaultScheme 
    );
    void Recalculate();
    PString urlString;

    PCaselessString scheme;
    PString username;
    PString password;
    PCaselessString hostname;
    WORD port;
    PBoolean portSupplied;          
    PBoolean relativePath;
    PStringArray path;
    PStringToString paramVars;
    PString fragment;
    PStringToString queryVars;
    PString m_contents;  // Anything left after parsing other elements
};


// PURLScheme

class PURLScheme : public PObject
{
  PCLASSINFO(PURLScheme, PObject);
  public:
    virtual PString GetName() const = 0;
    virtual PBoolean Parse(const PString & url, PURL & purl) const = 0;
    virtual PString AsString(PURL::UrlFormat fmt, const PURL & purl) const = 0;
};

// PURLLegacyScheme

class PURLLegacyScheme : public PURLScheme
{
  public:
    PURLLegacyScheme(
      const char * s,
      bool user    = false,
      bool pass    = false,
      bool host    = false,
      bool def     = false,
      bool defhost = false,
      bool query   = false,
      bool params  = false,
      bool frags   = false,
      bool path    = false,
      bool rel     = false,
      WORD port    = 0
    )
      : scheme(s)
      , hasUsername           (user)
      , hasPassword           (pass)
      , hasHostPort           (host)
      , defaultToUserIfNoAt   (def)
      , defaultHostToLocal    (defhost)
      , hasQuery              (query)
      , hasParameters         (params)
      , hasFragments          (frags)
      , hasPath               (path)
      , relativeImpliesScheme (rel)
      , defaultPort           (port)
    { }

    PBoolean Parse(const PString & url, PURL & purl) const
    { return purl.LegacyParse(url, this); }

    PString AsString(PURL::UrlFormat fmt, const PURL & purl) const
    { return purl.LegacyAsString(fmt, this); }

    PString GetName() const     
    { return scheme; }

    PString scheme;
    bool hasUsername;
    bool hasPassword;
    bool hasHostPort;
    bool defaultToUserIfNoAt;
    bool defaultHostToLocal;
    bool hasQuery;
    bool hasParameters;
    bool hasFragments;
    bool hasPath;
    bool relativeImpliesScheme;
    WORD defaultPort;
};

#endif // P_URL

#endif // PTLIB_PURL_H


// End Of File ///////////////////////////////////////////////////////////////

---