urlutil.h

Windows CE 6.0 Server 源码

        else
        {
            *unescaped++ = (T)esc;
        }
    }

    ASSERT(*escaped == 0);
    *unescaped = (T)0;     // null terminator

    return S_OK;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: template<class F, class T> HRESULT UnescapeUrl(const F *escaped, T *unescaped, DWORD *size)
//
//  parameters:
//
//  description:
//        Unescapes URL. If unescaped is null, returns only the buffer size (in characters) needed to
//        unescape the url. This size includes the null string terminator.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
template<class F, class T> HRESULT UnescapeUrl(const F *escaped, T *unescaped, DWORD *size)
{
    HRESULT hr     = S_OK;
    DWORD   dwSize = SizeToUnescape<F>(escaped);

    if (escaped && dwSize && unescaped && size && *size > dwSize)
    {
        CHK((DoUnescapeUrl<F, T>(escaped, unescaped)));
    }

    if (size)
    {
        *size = dwSize;
    }

Cleanup:
    return hr;
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline DWORD SizeToEscapeA(const CHAR *unescaped)
//
//  parameters:
//
//  description:
//        Calculates the size (in characters, including string null terminator) to escape given url.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline DWORD SizeToEscapeA(const CHAR *unescaped)
{
    return SizeToEscape<CHAR>(unescaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline DWORD SizeToEscapeW(const WCHAR *unescaped)
//
//  parameters:
//
//  description:
//        Calculates the size (in characters, including string null terminator) to escape given url.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline DWORD SizeToEscapeW(const WCHAR *unescaped)
{
    return SizeToEscape<WCHAR>(unescaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline DWORD SizeToUnescapeA(const CHAR *escaped)
//
//  parameters:
//
//  description:
//        Calculates the size (in characters, including string null terminator) to unescape given url.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline DWORD SizeToUnescapeA(const CHAR *escaped)
{
    return SizeToUnescape<CHAR>(escaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline DWORD SizeToUnescapeW(const WCHAR *escaped)
//
//  parameters:
//
//  description:
//        Calculates the size (in characters, including string null terminator) to unescape given url.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline DWORD SizeToUnescapeW(const WCHAR *escaped)
{
    return SizeToUnescape<WCHAR>(escaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT DoEscapeUrlA(const CHAR *unescaped, CHAR *escaped)
//
//  parameters:
//
//  description:
//        Performs URL escape work (assumes buffers are of correct sizes)
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT DoEscapeUrlA(const CHAR *unescaped, CHAR *escaped)
{
    return DoEscapeUrl<CHAR>(unescaped, escaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT DoEscapeUrlW(const WCHAR *unescaped, WCHAR *escaped)
//
//  parameters:
//
//  description:
//        Performs URL escape work (assumes buffers are of correct sizes)
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT DoEscapeUrlW(const WCHAR *unescaped, WCHAR *escaped)
{
    return DoEscapeUrl<WCHAR>(unescaped, escaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT EscapeUrlA(const CHAR *unescaped, CHAR *escaped, DWORD *size)
//
//  parameters:
//
//  description:
//        Escapes URL. If escaped is null, returns only the buffer size (in characters) needed to
//        escape the url. This size includes the null string terminator.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT EscapeUrlA(const CHAR *unescaped, CHAR *escaped, DWORD *size)
{
    return EscapeUrl<CHAR>(unescaped, escaped, size);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT EscapeUrlW(const WCHAR *unescaped, WCHAR *escaped, DWORD *size)
//
//  parameters:
//
//  description:
//        Escapes URL. If escaped is null, returns only the buffer size (in characters) needed to
//        escape the url. This size includes the null string terminator.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT EscapeUrlW(const WCHAR *unescaped, WCHAR *escaped, DWORD *size)
{
    return EscapeUrl<WCHAR>(unescaped, escaped, size);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT DoUnescapeUrlA(const CHAR *escaped, CHAR *unescaped)
//
//  parameters:
//
//  description:
//        Performs URL unescape work (assumes buffers are of correct sizes)
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT DoUnescapeUrlA(const CHAR *escaped, CHAR *unescaped)
{
    return DoUnescapeUrl<CHAR>(escaped, unescaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT DoUnescapeUrlW(const WCHAR *escaped, WCHAR *unescaped)
//
//  parameters:
//
//  description:
//        Performs URL unescape work (assumes buffers are of correct sizes)
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT DoUnescapeUrlW(const WCHAR *escaped, WCHAR *unescaped)
{
    return DoUnescapeUrl<WCHAR>(escaped, unescaped);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT UnescapeUrlA(const CHAR *escaped, CHAR *unescaped, DWORD *size)
//
//  parameters:
//
//  description:
//        Unescapes URL. If unescaped is null, returns only the buffer size (in characters) needed to
//        unescape the url. This size includes the null string terminator.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT UnescapeUrlA(const CHAR *escaped, CHAR *unescaped, DWORD *size)
{
    return UnescapeUrl<CHAR>(escaped, unescaped, size);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: inline HRESULT UnescapeUrlW(const WCHAR *escaped, WCHAR *unescaped, DWORD *size)
//
//  parameters:
//
//  description:
//        Unescapes URL. If unescaped is null, returns only the buffer size (in characters) needed to
//        unescape the url. This size includes the null string terminator.
//  returns:
//
////////////////////////////////////////////////////////////////////////////////////////////////////
inline HRESULT UnescapeUrlW(const WCHAR *escaped, WCHAR *unescaped, DWORD *size)
{
    return UnescapeUrl<WCHAR>(escaped, unescaped, size);
}


HRESULT EscapeUrl(const BSTR unescaped, BSTR *escaped);
HRESULT UnescapeUrl(const BSTR escaped, BSTR *unescaped);


#endif  // __URLUTIL_H_INCLUDED__