http_url.hpp

浏览该文件的文档.

#ifndef __HTTP_URL_HPP__
#define __HTTP_URL_HPP__

namespace http
{

class HTTPWRAPPER_DLL Url
{
public:
    enum UrlSegmentFlags
    {
        urlSimple = 0, 
        urlQueryVars = 1, 
        urlPathComp = 2,  
        urlPathMatrixParams = 4 | urlPathComp, 
        urlCanRelative = 8, 
        urlDefault = urlQueryVars | urlCanRelative,
        urlAll = urlPathComp | urlPathMatrixParams | urlQueryVars | urlCanRelative,
    };

public:
    explicit Url( int flags = urlDefault ) : _flags(flags), _isRelative(false)
    {
    }

    explicit Url( winux::String const & url, int flags = urlDefault ) : _flags(flags), _isRelative(false)
    {
        this->parse(url);
    }

    virtual ~Url()
    {
    }

    // attributes -------------------------------------------------------------------------

    winux::uint getFlags() const { return _flags; }

    bool isRelative() const { return _isRelative; }

    winux::String const & getScheme() const { return _scheme; }

    winux::String const & getUser() const { return _user; }

    winux::String const & getPwd() const { return _pwd; }

    winux::String const & getHost() const { return _host; }

    winux::String const & getPort() const { return _port; }

    winux::String const & getRawPathStr() const { return _rawPathStr; }

    size_t getPathCompsCount() const { return _pathComps.getCount(); }

    winux::String getPath() const;

    //winux::Mixed const & getPathMatrixParams( winux::String const & pathComp ) const;
    //winux::Mixed const & getPathMatrixParam( winux::String const & pathComp, winux::String const & name ) const;

    winux::Mixed const & getPathMatrixParams( int iPathComp ) const;

    winux::Mixed const & getPathMatrixParam( int iPathComp, winux::String const & name ) const;

    winux::String const & getRawQueryStr() const { return _rawQueryStr; }

    winux::Mixed const & getQueryParams() const { return _query; }

    winux::Mixed const & getQueryParam( winux::String const & name ) const { return _query[name]; }

    winux::String const & getFragment() const { return _fragment; }

    // methods ----------------------------------------------------------------------------

    Url & clear()
    {
        // scheme segment
        _scheme.clear();
        // host segment
        _user.clear();
        _pwd.clear();
        _host.clear();
        _port.clear();
        // path segment
        _rawPathStr.clear(); // 首不含'/'
        //[ { pathname:{ a:1, b:2 } }, { pathname1:{ a:1, b:2 } }, ... ]
        _pathComps.free();
        // query segment
        _rawQueryStr.clear(); // 首不含'?'
        _query.free();
        // fragment segment
        _fragment.clear(); // 首不含'#'
        return *this;
    }

    winux::String toString() const;

    bool assembleSchemeSegment( winux::String * urlSegment ) const;

    bool assembleHostSegment( winux::String * urlSegment, bool hasSchemeSegment ) const;

    bool assemblePathSegment( winux::String * urlSegment, bool hasHostSegment, bool hasQuerySegment, bool hasFragmentSegment ) const;

    bool assembleQuerySegment( winux::String * urlSegment, bool incStartChar ) const;

    bool assembleFragmentSegment( winux::String * urlSegment, bool incStartChar ) const;

    winux::Mixed dump() const;

    Url & parse( winux::String const & url, bool hasSchemeSegment = true, bool hasHostSegment = true, bool hasPathSegment = true, bool hasQuerySegment = true, bool hasFragmentSegment = true );

    Url & setFlags( winux::uint flags ) { _flags = flags; return *this; }

    Url & setRelative( bool relative ) { _isRelative = relative; return *this; }

    Url & setScheme( winux::String const & scheme ) { _scheme = scheme; return *this; }

    Url & setUser( winux::String const & user ) { _user = user; return *this; }

    Url & setPwd( winux::String const & pwd ) { _pwd = pwd; return *this; }

    Url & setHost( winux::String const & host ) { _host = host; return *this; }

    Url & setPort( winux::String const & port ) { _port = port; return *this; }

    Url & setRawPathStr( winux::String const & rawPathStr );

    Url & setPathComps( winux::Mixed const & pathComps );

    Url & setRawQueryStr( winux::String const & rawQueryStr );

    Url & setQuery( winux::Mixed const & query );

    Url & setFragment( winux::String const & fragment ) { _fragment = fragment; return *this; }


private:
    winux::uint _flags;
    bool _isRelative;
    // scheme segment
    winux::String _scheme;
    // host segment
    winux::String _user;
    winux::String _pwd;
    winux::String _host;
    winux::String _port;
    // path segment
    winux::String _rawPathStr; // 首不含'/'
    //[ { pathname:{ a:1, b:2 } }, { pathname1:{ a:1, b:2 } }, ... ]
    winux::Mixed _pathComps;
    // query segment
    winux::String _rawQueryStr; // 首不含'?'
    winux::Mixed _query;
    // fragment segment
    winux::String _fragment; // 首不含'#'

    friend class UrlParser;
};

class HTTPWRAPPER_DLL UrlParser
{
public:
    UrlParser( Url * pUrl ) : _pUrl(pUrl) { }

    void parse( winux::String const & url, bool hasSchemeSegment = true, bool hasHostSegment = true, bool hasPathSegment = true, bool hasQuerySegment = true, bool hasFragmentSegment = true );
    void parseHostSegment( winux::String const & hostSegment );
    void parsePathSegment( winux::String const & pathSegment );
    void parseQuerySegment( winux::String const & querySegment );

private:
    void _parseMatrixUriParams( winux::String const & matrixSegment, winux::Mixed * pMatrixParams );

    Url * _pUrl;
};

} // namespace http


#endif // __HTTP_URL_HPP__