strings.hpp

浏览该文件的文档.

#ifndef __STRINGS_HPP__
#define __STRINGS_HPP__
//
// strings 提供字符串相关的功能
//

#include <stdarg.h>

namespace winux
{
template < typename _ChTy >
inline static XString<_ChTy> CharSeqToString( _ChTy const * str, size_t len = npos )
{
    str = str ? str : winux::Literal<_ChTy>::nulStr;
    return (ssize_t)len < 0 ? XString<_ChTy>(str) : XString<_ChTy>( str, len );
}

template < typename _RetChTy, typename _ChTy = _RetChTy >
inline static XString<_RetChTy> CharToHexStr( _ChTy ch, bool padZero = false )
{
    _RetChTy str[sizeof(ch) * 2 + 1] = { (_RetChTy)0 };
    byte * pbyt = (byte*)&ch;
    ssize_t i = sizeof(ch) - 1;
    ssize_t j = 0;
    bool hadNonZero = padZero;
    for ( ; i >= 0; --i )
    {
        if ( pbyt[i] && !hadNonZero ) hadNonZero = true;
        if ( hadNonZero )
        {
            str[j * 2] = Literal<_RetChTy>::hexadecLowerStr[((pbyt[i] & (byte)0xF0) >> 4)];
            str[j * 2 + 1] = Literal<_RetChTy>::hexadecLowerStr[(pbyt[i] & (byte)0xF)];
            j++;
        }
    }
    if ( j == 0 )
    {
        str[0] = Literal<_RetChTy>::zeroChar;
        str[1] = Literal<_RetChTy>::zeroChar;
    }
    return str;
}


template < typename _ChTy >
size_t StrSplit( XString<_ChTy> const & str, XString<_ChTy> const & delimList, XStringArray<_ChTy> * arr, bool alwaysRetOneElem = false );
template <>
WINUX_FUNC_DECL(size_t) StrSplit( XString<char> const & str, XString<char> const & delimList, XStringArray<char> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit( XString<wchar> const & str, XString<wchar> const & delimList, XStringArray<wchar> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit( XString<char16> const & str, XString<char16> const & delimList, XStringArray<char16> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit( XString<char32> const & str, XString<char32> const & delimList, XStringArray<char32> * arr, bool alwaysRetOneElem );
#if defined(_UNICODE) || defined(UNICODE)
inline size_t StrSplit( UnicodeString const & str, UnicodeString const & delimList, UnicodeStringArray * arr, bool alwaysRetOneElem = false ) { return StrSplit<wchar>( str, delimList, arr, alwaysRetOneElem ); }
#else
inline size_t StrSplit( AnsiString const & str, AnsiString const & delimList, AnsiStringArray * arr, bool alwaysRetOneElem = false ) { return StrSplit<char>( str, delimList, arr, alwaysRetOneElem ); }
#endif


template < typename _ChTy >
XStringArray<_ChTy> StrSplit( XString<_ChTy> const & str, XString<_ChTy> const & delimList, bool alwaysRetOneElem = false );
template <>
WINUX_FUNC_DECL(XStringArray<char>) StrSplit( XString<char> const & str, XString<char> const & delimList, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<wchar>) StrSplit( XString<wchar> const & str, XString<wchar> const & delimList, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<char16>) StrSplit( XString<char16> const & str, XString<char16> const & delimList, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<char32>) StrSplit( XString<char32> const & str, XString<char32> const & delimList, bool alwaysRetOneElem );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeStringArray StrSplit( UnicodeString const & str, UnicodeString const & delimList, bool alwaysRetOneElem = false ) { return StrSplit<wchar>( str, delimList, alwaysRetOneElem ); }
#else
inline AnsiStringArray StrSplit( AnsiString const & str, AnsiString const & delimList, bool alwaysRetOneElem = false ) { return StrSplit<char>( str, delimList, alwaysRetOneElem ); }
#endif


template < typename _ChTy >
size_t StrSplit2( XString<_ChTy> const & str, XString<_ChTy> const & delim, XStringArray<_ChTy> * arr, bool alwaysRetOneElem = false );
template <>
WINUX_FUNC_DECL(size_t) StrSplit2( XString<char> const & str, XString<char> const & delim, XStringArray<char> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit2( XString<wchar> const & str, XString<wchar> const & delim, XStringArray<wchar> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit2( XString<char16> const & str, XString<char16> const & delim, XStringArray<char16> * arr, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(size_t) StrSplit2( XString<char32> const & str, XString<char32> const & delim, XStringArray<char32> * arr, bool alwaysRetOneElem );
#if defined(_UNICODE) || defined(UNICODE)
inline size_t StrSplit2( UnicodeString const & str, UnicodeString const & delim, UnicodeStringArray * arr, bool alwaysRetOneElem = false ) { return StrSplit2<wchar>( str, delim, arr, alwaysRetOneElem ); }
#else
inline size_t StrSplit2( AnsiString const & str, AnsiString const & delim, AnsiStringArray * arr, bool alwaysRetOneElem = false ) { return StrSplit2<char>( str, delim, arr, alwaysRetOneElem ); }
#endif


template < typename _ChTy >
XStringArray<_ChTy> StrSplit2( XString<_ChTy> const & str, XString<_ChTy> const & delim, bool alwaysRetOneElem = false );
template <>
WINUX_FUNC_DECL(XStringArray<char>) StrSplit2( XString<char> const & str, XString<char> const & delim, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<wchar>) StrSplit2( XString<wchar> const & str, XString<wchar> const & delim, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<char16>) StrSplit2( XString<char16> const & str, XString<char16> const & delim, bool alwaysRetOneElem );
template <>
WINUX_FUNC_DECL(XStringArray<char32>) StrSplit2( XString<char32> const & str, XString<char32> const & delim, bool alwaysRetOneElem );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeStringArray StrSplit2( UnicodeString const & str, UnicodeString const & delim, bool alwaysRetOneElem = false ) { return StrSplit2<wchar>( str, delim, alwaysRetOneElem ); }
#else
inline AnsiStringArray StrSplit2( AnsiString const & str, AnsiString const & delim, bool alwaysRetOneElem = false ) { return StrSplit2<char>( str, delim, alwaysRetOneElem ); }
#endif


template < typename _ChTy >
XString<_ChTy> StrJoin( XString<_ChTy> const & delim, XStringArray<_ChTy> const & arr );
template <>
WINUX_FUNC_DECL(XString<char>) StrJoin( XString<char> const & delim, XStringArray<char> const & arr );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrJoin( XString<wchar> const & delim, XStringArray<wchar> const & arr );
template <>
WINUX_FUNC_DECL(XString<char16>) StrJoin( XString<char16> const & delim, XStringArray<char16> const & arr );
template <>
WINUX_FUNC_DECL(XString<char32>) StrJoin( XString<char32> const & delim, XStringArray<char32> const & arr );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrJoin( UnicodeString const & delim, UnicodeStringArray const & arr ) { return StrJoin<wchar>( delim, arr ); }
#else
inline AnsiString StrJoin( AnsiString const & delim, AnsiStringArray const & arr ) { return StrJoin<char>( delim, arr ); }
#endif


template < typename _ChTy >
XString<_ChTy> StrJoinEx( XString<_ChTy> const & delim, XStringArray<_ChTy> const & arr, size_t start = 0, size_t elemCount = -1  );
template <>
WINUX_FUNC_DECL(XString<char>) StrJoinEx( XString<char> const & delim, XStringArray<char> const & arr, size_t start, size_t elemCount );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrJoinEx( XString<wchar> const & delim, XStringArray<wchar> const & arr, size_t start, size_t elemCount );
template <>
WINUX_FUNC_DECL(XString<char16>) StrJoinEx( XString<char16> const & delim, XStringArray<char16> const & arr, size_t start, size_t elemCount );
template <>
WINUX_FUNC_DECL(XString<char32>) StrJoinEx( XString<char32> const & delim, XStringArray<char32> const & arr, size_t start, size_t elemCount );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrJoinEx( UnicodeString const & delim, UnicodeStringArray const & arr, size_t start = 0, size_t elemCount = -1 ) { return StrJoinEx<wchar>( delim, arr, start, elemCount ); }
#else
inline AnsiString StrJoinEx( AnsiString const & delim, AnsiStringArray const & arr, size_t start = 0, size_t elemCount = -1 ) { return StrJoinEx<char>( delim, arr, start, elemCount ); }
#endif


template < typename _ChTy >
XString<_ChTy> StrInsert( XString<_ChTy> const & str, size_t start, size_t end, XString<_ChTy> const & insert );
template <>
WINUX_FUNC_DECL(XString<char>) StrInsert( XString<char> const & str, size_t start, size_t end, XString<char> const & insert );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrInsert( XString<wchar> const & str, size_t start, size_t end, XString<wchar> const & insert );
template <>
WINUX_FUNC_DECL(XString<char16>) StrInsert( XString<char16> const & str, size_t start, size_t end, XString<char16> const & insert );
template <>
WINUX_FUNC_DECL(XString<char32>) StrInsert( XString<char32> const & str, size_t start, size_t end, XString<char32> const & insert );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrInsert( UnicodeString const & str, size_t start, size_t end, UnicodeString const & insert ) { return StrInsert<wchar>( str, start, end, insert ); }
#else
inline AnsiString StrInsert( AnsiString const & str, size_t start, size_t end, AnsiString const & insert ) { return StrInsert<char>( str, start, end, insert ); }
#endif


template < typename _ChTy >
XString<_ChTy> & StrMakeReplace( XString<_ChTy> * str, XString<_ChTy> const & findText, XString<_ChTy> const & replaceText, size_t offset = 0 );
template <>
WINUX_FUNC_DECL(XString<char> &) StrMakeReplace( XString<char> * str, XString<char> const & findText, XString<char> const & replaceText, size_t offset );
template <>
WINUX_FUNC_DECL(XString<wchar> &) StrMakeReplace( XString<wchar> * str, XString<wchar> const & findText, XString<wchar> const & replaceText, size_t offset );
template <>
WINUX_FUNC_DECL(XString<char16> &) StrMakeReplace( XString<char16> * str, XString<char16> const & findText, XString<char16> const & replaceText, size_t offset );
template <>
WINUX_FUNC_DECL(XString<char32> &) StrMakeReplace( XString<char32> * str, XString<char32> const & findText, XString<char32> const & replaceText, size_t offset );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString & StrMakeReplace( UnicodeString * str, UnicodeString const & findText, UnicodeString const & replaceText, size_t offset = 0 ) { return StrMakeReplace<wchar>( str, findText, replaceText, offset ); }
#else
inline AnsiString & StrMakeReplace( AnsiString * str, AnsiString const & findText, AnsiString const & replaceText, size_t offset = 0 ) { return StrMakeReplace<char>( str, findText, replaceText, offset ); }
#endif


template < typename _ChTy >
XString<_ChTy> StrTrim( XString<_ChTy> const & str, size_t * leftSpaceCount = nullptr, size_t * rightSpaceCount = nullptr );
template <>
WINUX_FUNC_DECL(XString<char>) StrTrim( XString<char> const & str, size_t * leftSpaceCount, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrTrim( XString<wchar> const & str, size_t * leftSpaceCount, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char16>) StrTrim( XString<char16> const & str, size_t * leftSpaceCount, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char32>) StrTrim( XString<char32> const & str, size_t * leftSpaceCount, size_t * rightSpaceCount );

template < typename _ChTy >
XString<_ChTy> StrLTrim( XString<_ChTy> const & str, size_t * leftSpaceCount = nullptr );
template <>
WINUX_FUNC_DECL(XString<char>) StrLTrim( XString<char> const & str, size_t * leftSpaceCount );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrLTrim( XString<wchar> const & str, size_t * leftSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char16>) StrLTrim( XString<char16> const & str, size_t * leftSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char32>) StrLTrim( XString<char32> const & str, size_t * leftSpaceCount );

template < typename _ChTy >
XString<_ChTy> StrRTrim( XString<_ChTy> const & str, size_t * rightSpaceCount = nullptr );
template <>
WINUX_FUNC_DECL(XString<char>) StrRTrim( XString<char> const & str, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrRTrim( XString<wchar> const & str, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char16>) StrRTrim( XString<char16> const & str, size_t * rightSpaceCount );
template <>
WINUX_FUNC_DECL(XString<char32>) StrRTrim( XString<char32> const & str, size_t * rightSpaceCount );

#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrTrim( UnicodeString const & str, size_t * leftSpaceCount = nullptr, size_t * rightSpaceCount = nullptr ) { return StrTrim<wchar>( str, leftSpaceCount, rightSpaceCount ); }
inline UnicodeString StrLTrim( UnicodeString const & str, size_t * leftSpaceCount = nullptr ) { return StrLTrim<wchar>( str, leftSpaceCount ); }
inline UnicodeString StrRTrim( UnicodeString const & str, size_t * rightSpaceCount = nullptr ) { return StrRTrim<wchar>( str, rightSpaceCount ); }
#else
inline AnsiString StrTrim( AnsiString const & str, size_t * leftSpaceCount = nullptr, size_t * rightSpaceCount = nullptr ) { return StrTrim<char>( str, leftSpaceCount, rightSpaceCount ); }
inline AnsiString StrLTrim( AnsiString const & str, size_t * leftSpaceCount = nullptr ) { return StrLTrim<char>( str, leftSpaceCount ); }
inline AnsiString StrRTrim( AnsiString const & str, size_t * rightSpaceCount = nullptr ) { return StrRTrim<char>( str, rightSpaceCount ); }
#endif


template < typename _ChTy >
XString<_ChTy> & StrMakeUpper( XString<_ChTy> * str );
template <>
WINUX_FUNC_DECL(XString<char> &) StrMakeUpper( XString<char> * str );
template <>
WINUX_FUNC_DECL(XString<wchar> &) StrMakeUpper( XString<wchar> * str );
template <>
WINUX_FUNC_DECL(XString<char16> &) StrMakeUpper( XString<char16> * str );
template <>
WINUX_FUNC_DECL(XString<char32> &) StrMakeUpper( XString<char32> * str );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString & StrMakeUpper( UnicodeString * str ) { return StrMakeUpper<wchar>(str); }
#else
inline AnsiString & StrMakeUpper( AnsiString * str ) { return StrMakeUpper<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> StrUpper( XString<_ChTy> str );
template <>
WINUX_FUNC_DECL(XString<char>) StrUpper( XString<char> str );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrUpper( XString<wchar> str );
template <>
WINUX_FUNC_DECL(XString<char16>) StrUpper( XString<char16> str );
template <>
WINUX_FUNC_DECL(XString<char32>) StrUpper( XString<char32> str );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrUpper( UnicodeString str ) { return StrUpper<wchar>(str); }
#else
inline AnsiString StrUpper( AnsiString str ) { return StrUpper<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> & StrMakeLower( XString<_ChTy> * str );
template <>
WINUX_FUNC_DECL(XString<char> &) StrMakeLower( XString<char> * str );
template <>
WINUX_FUNC_DECL(XString<wchar> &) StrMakeLower( XString<wchar> * str );
template <>
WINUX_FUNC_DECL(XString<char16> &) StrMakeLower( XString<char16> * str );
template <>
WINUX_FUNC_DECL(XString<char32> &) StrMakeLower( XString<char32> * str );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString & StrMakeLower( UnicodeString * str ) { return StrMakeLower<wchar>(str); }
#else
inline AnsiString & StrMakeLower( AnsiString * str ) { return StrMakeLower<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> StrLower( XString<_ChTy> str );
template <>
WINUX_FUNC_DECL(XString<char>) StrLower( XString<char> str );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrLower( XString<wchar> str );
template <>
WINUX_FUNC_DECL(XString<char16>) StrLower( XString<char16> str );
template <>
WINUX_FUNC_DECL(XString<char32>) StrLower( XString<char32> str );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrLower( UnicodeString str ) { return StrLower<wchar>(str); }
#else
inline AnsiString StrLower( AnsiString str ) { return StrLower<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> StrMultiple( XString<_ChTy> const & str, size_t multiple );
template <>
WINUX_FUNC_DECL(XString<char>) StrMultiple( XString<char> const & str, size_t multiple );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrMultiple( XString<wchar> const & str, size_t multiple );
template <>
WINUX_FUNC_DECL(XString<char16>) StrMultiple( XString<char16> const & str, size_t multiple );
template <>
WINUX_FUNC_DECL(XString<char32>) StrMultiple( XString<char32> const & str, size_t multiple );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrMultiple( UnicodeString const & str, size_t multiple ) { return StrMultiple<wchar>( str, multiple ); }
#else
inline AnsiString StrMultiple( AnsiString const & str, size_t multiple ) { return StrMultiple<char>( str, multiple ); }
#endif


template < typename _ChTy >
XString<_ChTy> StrSubtract( XString<_ChTy> str1, XString<_ChTy> const & str2 );
template <>
WINUX_FUNC_DECL(XString<char>) StrSubtract( XString<char> str1, XString<char> const & str2 );
template <>
WINUX_FUNC_DECL(XString<wchar>) StrSubtract( XString<wchar> str1, XString<wchar> const & str2 );
template <>
WINUX_FUNC_DECL(XString<char16>) StrSubtract( XString<char16> str1, XString<char16> const & str2 );
template <>
WINUX_FUNC_DECL(XString<char32>) StrSubtract( XString<char32> str1, XString<char32> const & str2 );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StrSubtract( UnicodeString str1, UnicodeString const & str2 ) { return StrSubtract<wchar>( str1, str2 ); }
#else
inline AnsiString StrSubtract( AnsiString str1, AnsiString const & str2 ) { return StrSubtract<char>( str1, str2 ); }
#endif


enum StrToXqFlags
{
    stqUnsigned = 1, 
    stqNegative = 2, 
    stqOverflow = 4, 
    stqReadDigit = 8 
};

template < typename _ChTy >
uint64 StrToXq( _ChTy const * nptr, _ChTy const ** endptr, int ibase, int flags );
template <>
WINUX_FUNC_DECL(uint64) StrToXq( char const * nptr, char const ** endptr, int ibase, int flags );
template <>
WINUX_FUNC_DECL(uint64) StrToXq( wchar const * nptr, wchar const ** endptr, int ibase, int flags );
template <>
WINUX_FUNC_DECL(uint64) StrToXq( char16 const * nptr, char16 const ** endptr, int ibase, int flags );
template <>
WINUX_FUNC_DECL(uint64) StrToXq( char32 const * nptr, char32 const ** endptr, int ibase, int flags );
#if defined(_UNICODE) || defined(UNICODE)
inline uint64 StrToXq( wchar const * nptr, wchar const ** endptr, int ibase, int flags ) { return StrToXq<wchar>( nptr, endptr, ibase, flags ); }
#else
inline uint64 StrToXq( char const * nptr, char const ** endptr, int ibase, int flags ) { return StrToXq<char>( nptr, endptr, ibase, flags ); }
#endif


template < typename _ChTy >
int64 StrToInt64( XString<_ChTy> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(int64) StrToInt64( XString<char> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(int64) StrToInt64( XString<wchar> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(int64) StrToInt64( XString<char16> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(int64) StrToInt64( XString<char32> const & numStr, int ibase );
#if defined(_UNICODE) || defined(UNICODE)
inline int64 StrToInt64( UnicodeString const & numStr, int ibase ) { return StrToInt64<wchar>( numStr, ibase ); }
#else
inline int64 StrToInt64( AnsiString const & numStr, int ibase ) { return StrToInt64<char>( numStr, ibase ); }
#endif


template < typename _ChTy >
uint64 StrToUInt64( XString<_ChTy> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(uint64) StrToUInt64( XString<char> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(uint64) StrToUInt64( XString<wchar> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(uint64) StrToUInt64( XString<char16> const & numStr, int ibase );
template <>
WINUX_FUNC_DECL(uint64) StrToUInt64( XString<char32> const & numStr, int ibase );
#if defined(_UNICODE) || defined(UNICODE)
inline uint64 StrToUInt64( UnicodeString const & numStr, int ibase ) { return StrToUInt64<wchar>( numStr, ibase ); }
#else
inline uint64 StrToUInt64( AnsiString const & numStr, int ibase ) { return StrToUInt64<char>( numStr, ibase ); }
#endif


template < typename _ChTy >
inline XString<_ChTy> AddSlashes( XString<_ChTy> const & str, XString<_ChTy> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char>) AddSlashes( XString<char> const & str, XString<char> const & charlist );
template <>
WINUX_FUNC_DECL(XString<wchar>) AddSlashes( XString<wchar> const & str, XString<wchar> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char16>) AddSlashes( XString<char16> const & str, XString<char16> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char32>) AddSlashes( XString<char32> const & str, XString<char32> const & charlist );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString AddSlashes( UnicodeString const & str, UnicodeString const & charlist ) { return AddSlashes<wchar>( str, charlist ); }
#else
inline AnsiString AddSlashes( AnsiString const & str, AnsiString const & charlist ) { return AddSlashes<char>( str, charlist ); }
#endif


template < typename _ChTy >
inline XString<_ChTy> AddCSlashes( XString<_ChTy> const & str ) { return AddSlashes<_ChTy>( str, Literal<_ChTy>::cslashesStr ); }
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString AddCSlashes( UnicodeString const & str ) { return AddCSlashes<wchar>(str); }
#else
inline AnsiString AddCSlashes( AnsiString const & str ) { return AddCSlashes<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> StripSlashes( XString<_ChTy> const & str, XString<_ChTy> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char>) StripSlashes( XString<char> const & str, XString<char> const & charlist );
template <>
WINUX_FUNC_DECL(XString<wchar>) StripSlashes( XString<wchar> const & str, XString<wchar> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char16>) StripSlashes( XString<char16> const & str, XString<char16> const & charlist );
template <>
WINUX_FUNC_DECL(XString<char32>) StripSlashes( XString<char32> const & str, XString<char32> const & charlist );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StripSlashes( UnicodeString const & str, UnicodeString const & charlist ) { return StripSlashes<wchar>( str, charlist ); }
#else
inline AnsiString StripSlashes( AnsiString const & str, AnsiString const & charlist ) { return StripSlashes<char>( str, charlist ); }
#endif


template < typename _ChTy >
inline XString<_ChTy> StripCSlashes( XString<_ChTy> const & str ) { return StripSlashes<_ChTy>( str, Literal<_ChTy>::cslashesStr ); }
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString StripCSlashes( UnicodeString const & str ) { return StripCSlashes<wchar>(str); }
#else
inline AnsiString StripCSlashes( AnsiString const & str ) { return StripCSlashes<char>(str); }
#endif


template < typename _ChTy >
XString<_ChTy> AddQuotes( XString<_ChTy> const & str, _ChTy quote = Literal<_ChTy>::quoteChar );
template <>
WINUX_FUNC_DECL(XString<char>) AddQuotes( XString<char> const & str, char quote );
template <>
WINUX_FUNC_DECL(XString<wchar>) AddQuotes( XString<wchar> const & str, wchar quote );
template <>
WINUX_FUNC_DECL(XString<char16>) AddQuotes( XString<char16> const & str, char16 quote );
template <>
WINUX_FUNC_DECL(XString<char32>) AddQuotes( XString<char32> const & str, char32 quote );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString AddQuotes( UnicodeString const & str, UnicodeString::value_type quote = Literal<UnicodeString::value_type>::quoteChar ) { return AddQuotes<wchar>( str, quote ); }
#else
inline AnsiString AddQuotes( AnsiString const & str, AnsiString::value_type quote = Literal<AnsiString::value_type>::quoteChar ) { return AddQuotes<char>( str, quote ); }
#endif


template < typename _ChTy >
bool StrGetLine( XString<_ChTy> * line, XString<_ChTy> const & str, size_t * i, XString<_ChTy> * nl = nullptr );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char> * line, XString<char> const & str, size_t * i, XString<char> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<wchar> * line, XString<wchar> const & str, size_t * i, XString<wchar> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char16> * line, XString<char16> const & str, size_t * i, XString<char16> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char32> * line, XString<char32> const & str, size_t * i, XString<char32> * nl );
#if defined(_UNICODE) || defined(UNICODE)
inline bool StrGetLine( UnicodeString * line, UnicodeString const & str, size_t * i, UnicodeString * nl = nullptr ) { return StrGetLine<wchar>( line, str, i, nl ); }
#else
inline bool StrGetLine( AnsiString * line, AnsiString const & str, size_t * i, AnsiString * nl = nullptr ) { return StrGetLine<char>( line, str, i, nl ); }
#endif


template < typename _ChTy >
bool StrGetLine( XString<_ChTy> * line, _ChTy const * str, size_t len, size_t * i, XString<_ChTy> * nl = nullptr );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char> * line, char const * str, size_t len, size_t * i, XString<char> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<wchar> * line, wchar const * str, size_t len, size_t * i, XString<wchar> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char16> * line, char16 const * str, size_t len, size_t * i, XString<char16> * nl );
template <>
WINUX_FUNC_DECL(bool) StrGetLine( XString<char32> * line, char32 const * str, size_t len, size_t * i, XString<char32> * nl );
#if defined(_UNICODE) || defined(UNICODE)
inline bool StrGetLine( UnicodeString * line, UnicodeString::value_type const * str, size_t len, size_t * i, UnicodeString * nl = nullptr ) { return StrGetLine<wchar>( line, str, len, i, nl ); }
#else
inline bool StrGetLine( AnsiString * line, AnsiString::value_type const * str, size_t len, size_t * i, AnsiString * nl = nullptr ) { return StrGetLine<char>( line, str, len, i, nl ); }
#endif


template < typename _ChTy >
void GetLineByPos( XString<_ChTy> const & content, ssize_t pos, ssize_t * lineHead, ssize_t * lineTail, XString<_ChTy> * line = nullptr );
template <>
WINUX_FUNC_DECL(void) GetLineByPos( XString<char> const & content, ssize_t pos, ssize_t * lineHead, ssize_t * lineTail, XString<char> * line );
template <>
WINUX_FUNC_DECL(void) GetLineByPos( XString<wchar> const & content, ssize_t pos, ssize_t * lineHead, ssize_t * lineTail, XString<wchar> * line );
template <>
WINUX_FUNC_DECL(void) GetLineByPos( XString<char16> const & content, ssize_t pos, ssize_t * lineHead, ssize_t * lineTail, XString<char16> * line );
template <>
WINUX_FUNC_DECL(void) GetLineByPos( XString<char32> const & content, ssize_t pos, ssize_t * lineHead, ssize_t * lineTail, XString<char32> * line );


enum CollateIdentifierStringFlag : winux::uint
{
    wordRaw = 0x00, 
    wordAllUpper = 0x01, 
    wordAllLower = 0x02, 
    wordFirstCharUpper = 0x03, 

    nameLowerCamelCase = 0x10 | wordFirstCharUpper, 
    nameUpperCamelCase = 0x20 | wordFirstCharUpper, 
    namePascalCase = nameUpperCamelCase, 
    nameSnakeCase = 0x30 | wordAllLower, 
    nameKebabCase = 0x40 | wordAllLower, 
    nameScreamingSnakeCase = 0x50 | wordAllUpper, 
};

template < typename _ChTy >
XString<_ChTy> CollateIdentifierToString( XString<_ChTy> const & identifier, XString<_ChTy> const & sep, winux::uint flags = wordFirstCharUpper );
template <>
WINUX_FUNC_DECL(XString<char>) CollateIdentifierToString( XString<char> const & identifier, XString<char> const & sep, winux::uint flags );
template <>
WINUX_FUNC_DECL(XString<wchar>) CollateIdentifierToString( XString<wchar> const & identifier, XString<wchar> const & sep, winux::uint flags );
template <>
WINUX_FUNC_DECL(XString<char16>) CollateIdentifierToString( XString<char16> const & identifier, XString<char16> const & sep, winux::uint flags );
template <>
WINUX_FUNC_DECL(XString<char32>) CollateIdentifierToString( XString<char32> const & identifier, XString<char32> const & sep, winux::uint flags );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeString CollateIdentifierToString( UnicodeString const & identifier, UnicodeString const & sep, winux::uint flags = wordFirstCharUpper ) { return CollateIdentifierToString<wchar>( identifier, sep, flags ); }
#else
inline AnsiString CollateIdentifierToString( AnsiString const & identifier, AnsiString const & sep, winux::uint flags = wordFirstCharUpper ) { return CollateIdentifierToString<char>( identifier, sep, flags ); }
#endif


template < typename _ChTy >
XStringArray<_ChTy> CollateIdentifierToArray( XString<_ChTy> const & identifier, winux::uint flags = wordFirstCharUpper );
template <>
WINUX_FUNC_DECL(XStringArray<char>) CollateIdentifierToArray( XString<char> const & identifier, winux::uint flags );
template <>
WINUX_FUNC_DECL(XStringArray<wchar>) CollateIdentifierToArray( XString<wchar> const & identifier, winux::uint flags );
template <>
WINUX_FUNC_DECL(XStringArray<char16>) CollateIdentifierToArray( XString<char16> const & identifier, winux::uint flags );
template <>
WINUX_FUNC_DECL(XStringArray<char32>) CollateIdentifierToArray( XString<char32> const & identifier, winux::uint flags );
#if defined(_UNICODE) || defined(UNICODE)
inline UnicodeStringArray CollateIdentifierToArray( UnicodeString const & identifier, winux::uint flags = wordFirstCharUpper ) { return CollateIdentifierToArray<wchar>( identifier, flags ); }
#else
inline AnsiStringArray CollateIdentifierToArray( AnsiString const & identifier, winux::uint flags = wordFirstCharUpper ) { return CollateIdentifierToArray<char>( identifier, flags ); }
#endif


template < typename _IndexType, typename _ChTy >
inline static std::vector<_IndexType> _Templ_KmpCalcNext( _ChTy const * substr, size_t sublen )
{
    std::vector<_IndexType> next( sublen + 1 );
    ssize_t j = 0, k = -1;
    next[0] = -1;
    while ( j < (ssize_t)sublen )
    {
        if ( k == -1 || substr[j] == substr[k] )
        {
            j++;
            k++;
            //if ( substr[j] != substr[k] )
                next[j] = (_IndexType)k;
            //else
            //    next[j] = next[k];
        }
        else
        {
            k = next[k];
        }
    }
    return next;
}

template < typename _IndexType, typename _ChTy >
inline static size_t _Templ_KmpMatchEx( _ChTy const * str, size_t len, _ChTy const * substr, size_t sublen, size_t pos, std::vector<_IndexType> const & next )
{
    ssize_t i, j;
    i = pos;
    j = 0;
    while ( i < (ssize_t)len && j < (ssize_t)sublen )
    {
        if ( str[i] == substr[j] )
        {
            j++;
            i++;
        }
        else
        {
            j = next[j];

            if ( j == -1 )
            {
                j = 0;
                i++;
            }
        }
    }
    return j == (ssize_t)sublen ? i - (ssize_t)sublen : -1;
}

template < typename _IndexType, typename _ChTy >
inline static size_t _Templ_KmpMatch( _ChTy const * str, size_t len, _ChTy const * substr, size_t sublen, size_t pos )
{
    return _Templ_KmpMatchEx<_IndexType, _ChTy>( str, len, substr, sublen, pos, _Templ_KmpCalcNext( substr, sublen ) );
}

template < typename _ChTy >
inline std::vector<int> KmpCalcNext( _ChTy const * substr, size_t sublen )
{
    return _Templ_KmpCalcNext< int, _ChTy >( substr, sublen );
}
template < typename _ChTy >
inline size_t KmpMatchEx( _ChTy const * str, size_t len, _ChTy const * substr, size_t sublen, size_t pos, std::vector<int> const & next )
{
    return _Templ_KmpMatchEx< int, _ChTy >( str, len, substr, sublen, pos, next );
}
template < typename _ChTy >
inline size_t KmpMatch( _ChTy const * str, size_t len, _ChTy const * substr, size_t sublen, size_t pos )
{
    return KmpMatchEx<_ChTy>( str, len, substr, sublen, pos, KmpCalcNext( substr, sublen ) );
}


template < typename _ChTy >
class XStringWriter
{
public:
    XStringWriter( XString<_ChTy> * str, bool isAppend = false ) : _str(str), _sout(NULL), _isAppend(isAppend)
    {
        _sout = new std::basic_ostringstream<_ChTy>();
    }
    XStringWriter( XStringWriter const & other ) : _str(NULL), _sout(NULL)
    {
        this->operator = ( const_cast<XStringWriter &>(other) );
    }
    ~XStringWriter()
    {
        if ( _str )
        {
            if ( _isAppend )
            {
                *_str += _sout->str();
            }
            else
            {
                *_str = _sout->str();
            }
        }
        if ( _sout ) delete _sout;
    }
    XStringWriter & operator = ( XStringWriter & other )
    {
        if ( this != &other )
        {
            _str = other._str;
            _sout = other._sout;
            _isAppend = other._isAppend;

            other._str = NULL;
            other._sout = NULL;
            other._isAppend = false;
        }
        return *this;
    }

    template < typename _AnyType >
    std::basic_ostream<_ChTy> & operator << ( _AnyType && t )
    {
        return *_sout << std::forward<_AnyType>(t);
    }

private:
    XString<_ChTy> * _str;
    std::basic_ostringstream<_ChTy> * _sout;
    bool _isAppend;
};

using StringWriter = XStringWriter<tchar>;
using AnsiStringWriter = XStringWriter<char>;
using UnicodeStringWriter = XStringWriter<wchar>;
using UnicodeString16Writer = XStringWriter<char16>;
using Utf16StringWriter = XStringWriter<char16>;
using UnicodeString32Writer = XStringWriter<char32>;
using Utf32StringWriter = XStringWriter<char32>;

class WINUX_DLL MultiMatch
{
public:
    struct MatchResult
    {
        ssize_t pos; 
        ssize_t item; 
    };

    struct MatchState
    {
        ssize_t j; 
        ssize_t markpos; 
        MatchResult mr; 
        bool prevCharMatch; 
        bool matched; 

        void reset()
        {
            memset( this, 0, sizeof(*this) );
            mr.pos = -1;
            mr.item = -1;
        }
    };

    typedef std::vector<short> KmpNextValueArray;

    typedef std::vector<MatchState> MatchStates;

    typedef String (* ReplaceFuncType)( MultiMatch const * matchObj, ssize_t item, void * extra );

    typedef MatchResult ( MultiMatch:: * SearchFuncType )( String const & str, ssize_t offset ) const;

    MultiMatch();

    MultiMatch( StringArray const & matches, StringArray const & replaces );

    MultiMatch( StringArray const & matches, ReplaceFuncType replaceFunc, void * extra = NULL );

    template < size_t _Count >
    MultiMatch( String (&matches)[_Count], String (&replaces)[_Count] ) : _replaceFunc(NULL), _extra(NULL)
    {
        this->init( StringArray( matches, matches + _Count ), StringArray( replaces, replaces + _Count ) );
    }

    template < size_t _Count >
    MultiMatch( String (&matches)[_Count], ReplaceFuncType replaceFunc, void * extra = NULL ) : _replaceFunc(NULL), _extra(NULL)
    {
        this->init( StringArray( matches, matches + _Count ), replaceFunc, extra );
    }

    void init( StringArray const & matches, StringArray const & replaces );

    void init( StringArray const & matches, ReplaceFuncType replaceFunc, void * extra = NULL );

    ssize_t addMatchReplacePair( String const & match, String const & replace );

    ssize_t addMatch( String const & match );

    String const & getMatchItem( ssize_t item ) const;

    void setMatchItem( ssize_t item, String const & match );

    String getReplaceItem( ssize_t item ) const;

    void setReplaceItem( ssize_t item, String const & replace );

    void setReplaceItems( StringArray const & replaces );

    ReplaceFuncType setReplaceFunc( ReplaceFuncType newReplaceFunc, void * extra = NULL );

    void clear();

    MatchResult search( String const & str, ssize_t offset = 0 ) const;

    MatchResult greedSearch( String const & str, ssize_t offset = 0 ) const;

    MatchResult commonSearch( String const & str, ssize_t offset = 0 ) const;

    String replace( String const & str, ssize_t offset = 0, SearchFuncType fnSearch = &MultiMatch::commonSearch ) const;

private:
    std::vector<KmpNextValueArray> _nextVals;
    mutable MatchStates _states;
    StringArray _matchItems;
    StringArray _replaceItems;
    ReplaceFuncType _replaceFunc;
    void * _extra;
};

class WINUX_DLL Locale
{
public:
    static void Set( char const * lc ) { _clsLc = lc; }
    static char const * Get() { return _clsLc.c_str(); }
    Locale( char const * lc = NULL );
    ~Locale();

private:
    AnsiString _loc;
    AnsiString _prevLoc;
    static AnsiString _clsLc;
    DISABLE_OBJECT_COPY(Locale)
};


WINUX_FUNC_DECL(size_t) LocalCharsCount( AnsiString const & local );
WINUX_FUNC_DECL(size_t) UnicodeMinLength( UnicodeString const & unicode );
WINUX_FUNC_DECL(AnsiString) UnicodeToLocal( UnicodeString const & unicode );
WINUX_FUNC_DECL(UnicodeString) LocalToUnicode( AnsiString const & local );

WINUX_FUNC_DECL(String) LocalToString( AnsiString const & local );
WINUX_FUNC_DECL(String) UnicodeToString( UnicodeString const & unicode );
WINUX_FUNC_DECL(AnsiString) StringToLocal( String const & str );
WINUX_FUNC_DECL(UnicodeString) StringToUnicode( String const & str );


WINUX_DLL AnsiString FormatExVA( size_t cch, char const * fmt, va_list args );
WINUX_DLL UnicodeString FormatExVW( size_t cch, wchar const * fmt, va_list args );

WINUX_DLL AnsiString FormatExA( size_t cch, char const * fmt, ... );
WINUX_DLL UnicodeString FormatExW( size_t cch, wchar const * fmt, ... );

WINUX_DLL AnsiString FormatA( char const * fmt, ... );
WINUX_DLL UnicodeString FormatW( wchar const * fmt, ... );

#if defined(_UNICODE) || defined(UNICODE)

inline UnicodeString FormatExV( size_t cch, wchar const * fmt, va_list args ) { return FormatExVW( cch, fmt, args ); }
WINUX_DLL UnicodeString FormatEx( size_t cch, wchar const * fmt, ... );
WINUX_DLL UnicodeString Format( wchar const * fmt, ... );
#else

inline AnsiString FormatExV( size_t cch, char const * fmt, va_list args ) { return FormatExVA( cch, fmt, args ); }
WINUX_DLL AnsiString FormatEx( size_t cch, char const * fmt, ... );
WINUX_DLL AnsiString Format( char const * fmt, ... );
#endif

class WINUX_DLL SZInput
{
public:
    explicit SZInput( char * psz, size_t count ) : _psz(psz), _type(szCharInput), _count(count) { }
    explicit SZInput( wchar_t * pwsz, size_t count ) : _pwsz(pwsz), _type(szWCharInput), _count(count) { }
    SZInput & operator = ( char const * pstr );
    SZInput & operator = ( wchar_t const * pwstr );

private:
    union
    {
        char * _psz;
        wchar_t * _pwsz;
    };
    enum { szCharInput, szWCharInput } _type;
    size_t _count;
};

#if defined(__GNUC__) || _MSC_VER >= 1600

template < typename _CHAR, uint _Count >
SZInput SZ( _CHAR (&sz)[_Count] )
{
    return SZInput( sz, _Count );
}

#else

#define SZ(sz) SZInput( sz, sizeof(sz) / sizeof(sz[0]) )

#endif

#define SZP SZInput

// ----------------------------------------------------------------------------------

class WINUX_DLL Conv
{
public:
    Conv( AnsiString const & fromCode, AnsiString const & toCode );
    ~Conv();

    size_t convert( char const * srcBuf, size_t srcSize, char * * destBuf );

    template < typename _RetString, typename _String >
    _RetString convert( _String const & str )
    {
        typename _RetString::pointer buf;
        size_t n = this->convert( (char *)str.c_str(), str.length() * sizeof(typename _String::value_type), (char **)&buf );
        _RetString s( (typename _RetString::pointer)buf, n / sizeof(typename _RetString::value_type) );
        Buffer::Free(buf);
        return s;
    }

private:
    PlainMembers<struct Conv_Data, 8> _self;

    DISABLE_OBJECT_COPY(Conv)
};

template < typename _ToString >
class ConvTo : public Conv
{
public:
    ConvTo( AnsiString const & toCode ) : Conv( "", toCode )
    {
    }

    _ToString convert( AnsiString const & str )
    {
        return this->Conv::convert<_ToString, AnsiString>(str);
    }

    _ToString operator () ( AnsiString const & str )
    {
        typename _ToString::value_type * buf;
        size_t n = Conv::convert( (char *)str.c_str(), str.length() * sizeof(typename AnsiString::value_type), (char **)&buf );
        _ToString s( buf, n / sizeof(typename _ToString::value_type) );
        Buffer::Free(buf);
        return s;
    }
};

template < typename _FromString >
class ConvFrom : public Conv
{
public:
    ConvFrom( AnsiString const & fromCode ) : Conv( fromCode, "" )
    {
    }

    AnsiString convert( _FromString const & str )
    {
        return this->Conv::convert<AnsiString, _FromString>(str);
    }

    AnsiString operator () ( _FromString const & str )
    {
        AnsiString::value_type * buf;
        size_t n = Conv::convert( (char *)str.c_str(), str.length() * sizeof(typename _FromString::value_type), (char **)&buf );
        AnsiString s( buf, n / sizeof(AnsiString::value_type) );
        Buffer::Free(buf);
        return s;
    }
};

class WINUX_DLL UnicodeConverter
{
public:
    UnicodeConverter( Utf8String const & utf8str );
    UnicodeConverter( UnicodeString const & wstr );
    UnicodeConverter( Utf16String const & utf16str );
    UnicodeConverter( Utf32String const & utf32str );

    Utf8String toUtf8( size_t newCap = 0 ) const;
    UnicodeString toUnicode( size_t newCap = 0 ) const;
    Utf16String toUtf16( size_t newCap = 0 ) const;
    Utf32String toUtf32( size_t newCap = 0 ) const;

    size_t calcUtf8Length() const;
    size_t calcUnicodeLength() const;
    size_t calcUtf16Length() const;
    size_t calcUtf32Length() const;

private:
    template < typename _Ty >
    _Ty const * _q() const { return reinterpret_cast<_Ty const *>(_p); }

    void const * _p;
    enum {
        ucUtf8,
        ucUnicode,
        ucUtf16,
        ucUtf32
    } _type;
};

using UC = UnicodeConverter;
// 定义一些转换宏
#define $u8(s) winux::UnicodeConverter(s).toUtf8()
#define $L(s) winux::UnicodeConverter(s).toUnicode()
#define $u(s) winux::UnicodeConverter(s).toUtf16()
#define $U(s) winux::UnicodeConverter(s).toUtf32()

// UTF-8编码转换
// Windows平台默认local就不是utf8，因此不用设置LOCAL_ISNT_UTF8。若设置LOCAL_IS_UTF8，则认为local是utf8
// Unix-like平台默认local就是utf8，因此不用设置LOCAL_IS_UTF8。若设置LOCAL_ISNT_UTF8，则认为local不是utf8
#if defined(OS_WIN) && !defined(LOCAL_IS_UTF8) || defined(LOCAL_ISNT_UTF8)

WINUX_FUNC_DECL(AnsiString) LocalFromUtf8( AnsiString const & str );
WINUX_FUNC_DECL(AnsiString) LocalToUtf8( AnsiString const & str );
#define LOCAL_FROM_UTF8(s) winux::LocalFromUtf8(s)
#define LOCAL_TO_UTF8(s) winux::LocalToUtf8(s)
#else

inline static AnsiString LocalFromUtf8( AnsiString const & str ) { return str; }
inline static AnsiString LocalToUtf8( AnsiString const & str ) { return str; }
#define LOCAL_FROM_UTF8(s) s
#define LOCAL_TO_UTF8(s) s
#endif


} // namespace winux

#endif // __STRINGS_HPP__