http_misc.hpp

浏览该文件的文档.

#ifndef __HTTP_MISC_HPP__
#define __HTTP_MISC_HPP__

namespace http
{

class HTTPWRAPPER_DLL Header
{
public:
    class HTTPWRAPPER_DLL HeaderField
    {
    public:
        HeaderField() { }
        HeaderField( winux::String const & fieldVal ) { parse(fieldVal); }
        HeaderField( winux::String const & firstVal, winux::Mixed const & options );

        virtual winux::String toString() const;
        HeaderField & parse( winux::String const & fieldVal );
        void clear() { _firstVal.clear(); _options.clear(); }

        winux::String getOption( winux::String const & name ) const { return winux::isset( _options, name ) ? _options.at(name) : ""; }
        void setOption( winux::String const & name, winux::String const & value ) { _options[name] = value; }
        bool hasOption( winux::String const & name ) const { return winux::isset( _options, name ); }

        winux::StringStringMap & getOptions() { return _options; }
        winux::StringStringMap const & getOptions() const { return _options; }
        winux::String getFirstVal() const { return _firstVal; }
        void setFirstVal( winux::String const & firstVal ) { _firstVal = winux::StrLower(firstVal); }
    protected:
        static void _ParseOptions( winux::String const & strOptions, winux::StringStringMap * options );

        winux::String _firstVal;
        winux::StringStringMap _options;
    };
    class HTTPWRAPPER_DLL ContentType : public HeaderField
    {
    public:
        ContentType() { }
        ContentType( winux::String const & fieldVal ) : HeaderField(fieldVal) { }
        ContentType( winux::String const & mimeType, winux::Mixed const & options ) : HeaderField( mimeType, options ) { }

        virtual winux::String toString() const;
        winux::String getMimeType() const { return _firstVal; }
        void setMimeType( winux::String const & mimeType ) { _firstVal = winux::StrLower(mimeType); }
        winux::String getCharset() const { return getOption("charset"); }
        void setCharset( winux::String const & charset ) { setOption( "charset", winux::StrLower(charset) ); }
        winux::String getBoundary() const { return getOption("boundary"); }
        void setBoundary( winux::String const & boundary ) { setOption( "boundary", boundary ); }
    };
    class HTTPWRAPPER_DLL ContentDisposition : public HeaderField
    {
    public:
        ContentDisposition() { }
        ContentDisposition( winux::String const & fieldVal ) : HeaderField(fieldVal) { }
        ContentDisposition( winux::String const & firstVal, winux::Mixed const & options ) : HeaderField( firstVal, options ) { }
    };

public:
    Header();
    Header( std::initializer_list< std::pair< winux::String, winux::Mixed > > list );
    void clear();
    winux::String toString( bool isAddCrlfAtEnd = true ) const;

    Header & parse( winux::String const & headerStr );

    winux::String const & operator [] ( winux::String const & name ) const;
    winux::String & operator [] ( winux::String const & name );

    winux::StringArray getHeaders( winux::String const & name ) const;
    winux::String getHeader( winux::String const & name, winux::String const & defval = winux::String() ) const { return _headers.has(name) ? _headers[name].refAnsi() : defval; }
    template < typename _Ty > _Ty getHeader( winux::String const & name, _Ty const & defval = _Ty() ) const { return _headers.has(name) ? (_Ty)_headers[name] : defval; }
    void addHeader( winux::String const & name, winux::String const & value );
    void setHeader( winux::String const & name, winux::String const & value ) { _headers[name] = value; }
    bool hasHeader( winux::String const & name ) const { return _headers.has(name); }
    void delHeader( winux::String const & name ) { _headers.del(name); }

    template < typename _HeaderField >
    bool get( winux::String const & name, _HeaderField * field ) const
    {
        if ( _headers.has(name) )
        {
            field->parse( *_headers[name]._pStr );
            return true;
        }
        return false;
    }
    template < typename _HeaderField >
    _HeaderField get( winux::String const & name ) const
    {
        _HeaderField f;
        f.parse( (*this)[name] );
        return f;
    }

    winux::StringWriter operator () ( winux::String const & name );

    winux::StringWriter operator () ( winux::String const & name, int i );

    winux::String getMultiHeader( winux::String const & name, int i, winux::String const & defval = winux::String() ) const;
    void addMultiHeader( winux::String const & name, winux::String const & value );
    bool hasMultiHeader( winux::String const & name ) const;
    void delMultiHeader( int index );

    void setResponseLine( winux::String const & responseLine, bool setStatus = true );

    void setRequestLine( winux::String const & requestLine );

    winux::String getStatusLine( bool isAddCrlf = false ) const;

    winux::String const & getMethod() const { return _method; }
    winux::String const & getUrl() const { return _url; }
    winux::String const & getStatusCode() const { return _statusCode; }
    winux::String const & getStatusStr() const { return _statusStr; }
    winux::String const & getVersion() const { return _version; }

    Header & setMethod( winux::String const & method ) { _method = method; return *this; }
    Header & setUrl( winux::String const & url ) { _url = url; return *this; }
    Header & setStatusCode( winux::String const & statusCode ) { _statusCode = statusCode; return *this; }
    Header & setStatusStr( winux::String const & statusStr ) { _statusStr = statusStr; return *this; }
    Header & setVersion( winux::String const & version ) { _version = version; return *this; }

    bool enumHeader( winux::String * name, winux::String * value ) const;

private:
    winux::String _method, _url; // for a request
    winux::String _statusCode, _statusStr; // for a response
    winux::String _version; // for a request/response

    winux::Mixed _headers; // 存放只能一次的头
    std::vector< std::pair< winux::String, winux::String > > _multiHeaders; // 存放可多次的头

    // 枚举相关
    mutable int _curHeaderIndex; // 当前枚举到的头部索引
    mutable int _curMultiHeaderIndex; // 当前枚举到的多头部索引
    mutable bool _isCompleteEnum; // 是否完成枚举，从而进行下一次枚举，默认是true
};

class HTTPWRAPPER_DLL Cookie
{
    class HTTPWRAPPER_DLL ExpiresVal
    {
        winux::String _vStr;
    public:
        bool empty() const { return _vStr.empty(); }
        operator winux::String & () { return _vStr; }
        operator winux::String const & () const { return _vStr; }

        void operator = ( winux::int64 v );
        winux::String & operator = ( winux::String const & v ) { return _vStr = v; }
    };
public:
    winux::String name;
    winux::String value;
    ExpiresVal expires;
    winux::String domain;
    winux::String path;
    bool secure;
    bool httpOnly;

    bool wantSet; // 该Cookie是否要设置

    Cookie() : secure(false), httpOnly(false), wantSet(false) { }
    Cookie(
        winux::String name,
        winux::String value = "",
        winux::int64 expires = -1,
        winux::String domain = "",
        winux::String path = "",
        bool secure = false,
        bool httpOnly = false
    );

    operator winux::String const & () const { return this->value; }

    // 设置值时将wantSet标志设真
    winux::String & operator = ( winux::String const & v );
    // 获得一个用于Set-Cookie的字符串,不包含"Set-Cookie:"串
    winux::String toSetString() const;

};

inline std::ostream & operator << ( std::ostream & o, Cookie const & cookie )
{
    o << (winux::String)cookie;
    return o;
}

class HTTPWRAPPER_DLL Cookies
{
    std::map< winux::String, http::Cookie > _cookies;
public:
    Cookies() { }

    void set(
        winux::String name,
        winux::String value = "",
        winux::int64 expires = -1,
        winux::String domain = "",
        winux::String path = "",
        bool secure = false,
        bool httpOnly = false
    );

    http::Cookie const & get( winux::String const & name ) const { return _cookies.at(name); }

    void clear() { _cookies.clear(); }

    void loadCookies( winux::AnsiString const & cookiesStr );

    void commitTo( http::Header * header );

    winux::Mixed dump() const;

    bool has( winux::String const & name ) const { return _cookies.find(name) != _cookies.end(); }

    http::Cookie & operator [] ( winux::String const & name );

    http::Cookie const & operator [] ( winux::String const & name ) const { return _cookies.at(name); }

};

class HTTPWRAPPER_DLL Vars
{
    winux::Mixed _vars;
public:
    Vars( winux::AnsiString const & varsData = "" );
    Vars( winux::Mixed const & vars );
    void clear();
    winux::String toString() const;
    winux::Mixed const & operator [] ( winux::String const & name ) const;
    winux::Mixed & operator [] ( winux::String const & name );
    bool has( winux::String const & name ) const;
    Vars & parse( winux::AnsiString const & varsData );

    template < typename _Ty >
    _Ty get( winux::String const & name, _Ty defval = _Ty() ) const
    {
        return this->has(name) ? (_Ty)_vars[name] : defval;
    }

    winux::Mixed & getVars() { return _vars; }
};

} // namespace http


#endif // __HTTP_MISC_HPP__