strings.hpp

浏览该文件的文档.

#ifndef __STRINGS_HPP__
#define __STRINGS_HPP__

#include <stdarg.h>

namespace winux
{

WINUX_FUNC_DECL(int) StrSplit( String const & str, String const & delimList, StringArray * arr, bool alwaysRetOneElem = false );

WINUX_FUNC_DECL(int) StrSplit2( String const & str, String const & delim, StringArray * arr, bool alwaysRetOneElem = false );

WINUX_FUNC_DECL(String) StrJoin( String const & delim, StringArray const & arr );
WINUX_FUNC_DECL(String) StrInsert( String const & str, int start, int end, String const & insert );
WINUX_FUNC_DECL(String &) StrMakeReplace( String * str, String const & findText, String const & replaceText, String::size_type offset = 0 );

WINUX_FUNC_DECL(String) StrTrim( String const & str );

WINUX_FUNC_DECL(String &) StrMakeUpper( String * str );
WINUX_FUNC_DECL(String) StrUpper( String const & str );
WINUX_FUNC_DECL(String &) StrMakeLower( String * str );
WINUX_FUNC_DECL(String) StrLower( String const & str );

WINUX_FUNC_DECL(AnsiString) AddSlashesA( AnsiString const & str, AnsiString const & charlist );
inline AnsiString AddCSlashesA( AnsiString const & str ) { return AddSlashesA( str, "\n\r\t\v\a\\\'\"" ); }

WINUX_FUNC_DECL(UnicodeString) AddSlashesW( UnicodeString const & str, UnicodeString const & charlist );
inline UnicodeString AddCSlashesW( UnicodeString const & str ) { return AddSlashesW( str, L"\n\r\t\v\a\\\'\"" ); }

#if defined(_UNICODE) || defined(UNICODE)
    #define AddSlashes AddSlashesW
    #define AddCSlashes AddCSlashesW
#else
    #define AddSlashes AddSlashesA
    #define AddCSlashes AddCSlashesA
#endif

WINUX_FUNC_DECL(AnsiString) StripSlashes( AnsiString const & str, AnsiString const & charlist );
inline AnsiString StripCSlashes( AnsiString const & str ) { return StripSlashes( str, "\n\r\t\v\a\\\'\"" ); }

WINUX_FUNC_DECL(String) AddQuotes( String const & str, tchar quote = '\"' );

WINUX_FUNC_DECL(bool) StrGetLine( String * line, String const & str, int * i, String * nl = NULL );

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

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

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

WINUX_FUNC_DECL(std::vector<int>) KmpCalcNext( char const * substr, int sublen );
WINUX_FUNC_DECL(int) KmpMatchEx( char const * str, int len, char const * substr, int sublen, int pos, std::vector<int> const & next );
WINUX_FUNC_DECL(int) KmpMatch( char const * str, int len, char const * substr, int sublen, int pos );


class WINUX_DLL OutStringStreamWrapper
{
    String * _str;
    std::ostringstream * _sout;
    bool _isAppend;
public:
    OutStringStreamWrapper( String * str, bool isAppend = false );
    OutStringStreamWrapper( OutStringStreamWrapper const & other );
    ~OutStringStreamWrapper();
    OutStringStreamWrapper & operator = ( OutStringStreamWrapper & other );

    template < typename _AnyType >
    std::ostream & operator << ( _AnyType t )
    {
        assert( _sout != NULL );
        return *_sout << t;
    }
};

class WINUX_DLL MultiMatch
{
public:
    typedef std::vector<short> KmpNextValueArray;

    struct MatchState
    {
        int j; 
        int markpos;
    };

    typedef std::vector<MatchState> MatchStates;

    struct MatchResult
    {
        int pos;    
        int item;   
    };
    typedef String (* ReplaceFuncType)( MultiMatch const * matchObj, int item, void * extra );

    MultiMatch( String matches[], uint m, String replaces[], uint n );
    MultiMatch( String matches[], uint count, ReplaceFuncType replaceFunc, void * extra = NULL );
    MultiMatch( StringArray const & matches, StringArray const & replaces );
    MultiMatch( StringArray const & matches, ReplaceFuncType replaceFunc, void * extra = NULL );

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

    int addMatchReplacePair( String const & match, String const & replace );
    int addMatch( String const & match );
    ReplaceFuncType setReplaceFunc( ReplaceFuncType newReplaceFunc, void * extra = NULL );

    MatchResult search( String const & str, int offset = 0 ) const;
    MatchResult commonSearch( String const & str, int offset = 0 ) const;
    /* 贪婪模式 */
    //MatchResult greedSearch( String const & str, int offset = 0 ) const;
    String replace( String const & str, MatchResult ( MultiMatch:: * fnSearch )( String const & str, int offset ) const = &MultiMatch::search ) const;

    String const & getMatchItem( int item ) const;
    String getReplaceItem( int item ) const;
    void setReplaceItem( int item, String const & replace );
    void clear();
private:
    std::vector<KmpNextValueArray> _nextVals;
    StringArray _matchItems;
    StringArray _replaceItems;
    ReplaceFuncType _replaceFunc;
    void * _extra;
};

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

WINUX_FUNC_DECL(uint) LocalCharsCount( LocalString const & local );
WINUX_FUNC_DECL(uint) UnicodeMinLength( UnicodeString const & unicode );
WINUX_FUNC_DECL(LocalString) UnicodeToLocal( UnicodeString const & unicode );
WINUX_FUNC_DECL(UnicodeString) LocalToUnicode( LocalString const & local );

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

WINUX_DLL String FormatExV( uint cch, tchar const * fmt, va_list args );
WINUX_DLL String FormatEx( uint cch, tchar const * fmt, ... );
WINUX_DLL String Format( tchar const * fmt, ... );

class WINUX_DLL SZInput
{
    union
    {
        char * _psz;
        wchar_t * _pwsz;
    };
    enum { szCharInput, szWCharInput } _type;
    size_t _count;
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 );

};

#if defined(__GNUC__) || _MSC_VER >= 1600
/* VC2010以上支持模板取数组大小 */
template < typename _CHAR, uint _N >
SZInput SZ( _CHAR (&sz)[_N] )
{
    return SZInput( sz, _N );
}

#else
/* 否则使用宏定义 */
#define SZ(sz) SZInput( sz, sizeof(sz) / sizeof(sz[0]) )

#endif
/* 如果操作对象是缓冲区指针，则使用SZP宏 */
#define SZP SZInput

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

class WINUX_DLL Conv
{
public:
    Conv( char const * fromCode, char const * toCode );
    ~Conv();

    int 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 outBytes = this->convert( (char *)str.c_str(), (str.length() + 1) * sizeof(typename _String::value_type), (char **)&buf );
        _RetString s = (typename _RetString::pointer)buf;
        free(buf);
        return s;
    }
private:
    MembersWrapper<struct Conv_Data> _self;

    DISABLE_OBJECT_COPY(Conv)
};

template < typename _ToString >
class ConvTo : public Conv
{
public:
    ConvTo( char 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;
        Conv::convert( (char *)str.c_str(), (str.length() + 1) * sizeof(typename AnsiString::value_type), (char **)&buf );
        _ToString s = buf;
        free(buf);
        return s;
    }
};

template < typename _FromString >
class ConvFrom : public Conv
{
public:
    ConvFrom( char 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;
        Conv::convert( (char *)str.c_str(), (str.length() + 1) * sizeof(typename _FromString::value_type), (char **)&buf );
        AnsiString s = buf;
        free(buf);
        return s;
    }

};

// UTF-8编码转换
WINUX_FUNC_DECL(AnsiString) LocalFromUtf8( AnsiString const & str );
WINUX_FUNC_DECL(AnsiString) LocalToUtf8( AnsiString const & str );


} // namespace winux

#endif // __STRINGS_HPP__