utilities.hpp

浏览该文件的文档.

#ifndef __UTILITIES_HPP__
#define __UTILITIES_HPP__
//
// utilities 提供基础的宏，模板，类，函数
//

// 各平台条件编译宏检测
#include "system_detection.inl"

#if _MSC_VER > 0 && _MSC_VER < 1201
#pragma warning( disable: 4786 )
#endif
#if _MSC_VER > 0
#pragma warning( disable : 4996 )
#endif

#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <tuple>
#include <queue>
#include <functional>
#include <algorithm>
#include <assert.h>
#include <stdlib.h>
#include <string.h>

#if defined(OS_WIN)
#include <windows.h>
#endif

namespace winux
{
// 一些宏定义 ----------------------------------------------------------------------------------
/*  Dll相关宏定义:
    WINUX_DLL_USE     - 此宏开关表示有DLL参与,包括生成DLL或者导入DLL,不定义此宏和一般的使用源码没区别
    WINUX_DLL_EXPORTS - 此宏开关表示是生成DLL(dllexport)还是导入DLL(dllimport),linux平台下忽略
    WINUX_DLL         - 标记函数、类、变量,用于标明其要从DLL导出还是导入,linux平台下忽略
    WINUX_API         - 标记函数调用约定,Win下Dll参与时为stdcall,否则为空白默认,linux平台下忽略
    WINUX_FUNC_DECL   - 标记函数声明
    WINUX_FUNC_IMPL   - 标记函数实现 */
#ifdef WINUX_DLL_USE
    #if defined(_MSC_VER) || defined(WIN32)
        #pragma warning( disable: 4251 )
        #pragma warning( disable: 4275 )
        #ifdef  WINUX_DLL_EXPORTS
            #define WINUX_DLL  __declspec(dllexport)
        #else
            #define WINUX_DLL  __declspec(dllimport)
        #endif

        #define WINUX_API __stdcall
    #else
        #define WINUX_DLL
        #define WINUX_API
    #endif
#else
    #define WINUX_DLL
    #define WINUX_API
#endif

#define WINUX_FUNC_DECL(ret) WINUX_DLL ret WINUX_API
#define WINUX_FUNC_IMPL(ret) ret WINUX_API

#ifndef countof
    #define countof(arr) ( sizeof(arr) / sizeof(arr[0]) )
#endif

#ifndef TEXT
    #ifdef UNICODE
        #define TEXT(__x) L##__x
    #else
        #define TEXT(__x) __x
    #endif
#endif

// 禁止类的对象赋值/拷贝构造
// DISABLE_OBJECT_COPY
#define DISABLE_OBJECT_COPY( clsname ) private:\
clsname( clsname const & ) = delete;\
clsname & operator = ( clsname const & ) = delete;

// C语言缓冲区转换为AnsiString二进制串
#define CBufferToAnsiString( buf, size ) winux::AnsiString( (char const *)(buf), (size_t)(size) )
// C语言缓冲区转换为Buffer对象
#define CBufferToBuffer( buf, size ) winux::Buffer( (void *)(buf), (size_t)(size), false )
// C语言缓冲区转换为Buffer对象（PEEK模式）
#define CBufferToBufferPeek( buf, size ) winux::Buffer( (void *)(buf), (size_t)(size), true )

// 如果指针非NULL
// IF_PTR
#define IF_PTR(ptr) if ( (ptr) != NULL ) (ptr)
// ASSIGN_PTR
#define ASSIGN_PTR(ptr) if ( (ptr) != NULL ) (*(ptr))

// 不使用一个变量
#ifndef UNUSED
#define UNUSED(s)
#endif

// 给类添加一个属性，和相关的数据成员，自动添加get/set方法
#define DEFINE_ATTR_MEMBER( ty, name, memname ) \
public:\
    ty const & get##name() const { return this->##memname; }\
    void set##name( ty const & v ) { this->##memname = v; }\
private:\
    ty memname;

// 给类添加一个只读属性，和相关的数据成员，自动添加get方法
#define DEFINE_ATTR_MEMBER_READONLY( ty, name, memname ) \
public:\
    ty const & get##name() const { return this->##memname; }\
private:\
    ty memname;

// 给类添加一个属性，自动添加get/set方法
#define DEFINE_ATTR( ty, name, getcode, setcode ) \
public:\
    ty get##name() const { getcode; }\
    void set##name( ty const & _VAL_ ) { setcode; }

// 给类添加一个只读属性，自动添加get方法
#define DEFINE_ATTR_READONLY( ty, name, getcode ) \
public:\
    ty get##name() const { getcode; }

// 给类定义一个NewInstance静态方法
#define DEFINE_FUNC_NEWINSTANCE( cls, ret, paramtypes, params ) \
inline static ret * NewInstance##paramtypes \
{ \
    return new cls##params;\
}

// 给类定义一个自定义事件相关的成员和函数，默认实现
#define DEFINE_CUSTOM_EVENT(evtname, paramtypes, calledparams) \
public: \
    using evtname##HandlerFunction = std::function< void paramtypes >; \
    void on##evtname##Handler( evtname##HandlerFunction handler ) \
    { \
        this->_##evtname##Handler = handler; \
    } \
protected: \
    evtname##HandlerFunction _##evtname##Handler; \
    virtual void on##evtname paramtypes \
    { \
        if ( this->_##evtname##Handler ) this->_##evtname##Handler calledparams; \
    }

// 给类定义一个自定义事件相关的成员和函数，带返回值并自己实现
#define DEFINE_CUSTOM_EVENT_RETURN_EX(ret, evtname, paramtypes) \
public: \
    using evtname##HandlerFunction = std::function< ret paramtypes >; \
    void on##evtname##Handler( evtname##HandlerFunction handler ) \
    { \
        this->_##evtname##Handler = handler; \
    } \
protected: \
    evtname##HandlerFunction _##evtname##Handler; \
    virtual ret on##evtname paramtypes


// 判断GCC版本大于给定版本
#define GCC_VERSION_GREAT_THAN(Major,Minor,Patchlevel) \
( __GNUC__ > Major || ( __GNUC__ == Major && ( __GNUC_MINOR__ > Minor || ( __GNUC_MINOR__ == Minor && __GNUC_PATCHLEVEL__ > Patchlevel ) ) ) )

// WINUX基本类型 -----------------------------------------------------------------------------------
typedef int int32;
typedef unsigned int uint, uint32;
typedef unsigned long ulong;
typedef short int16;
typedef unsigned short ushort, uint16;
typedef char int8;
typedef unsigned char uint8;

typedef char16_t char16;
typedef char32_t char32;

typedef intptr_t offset_t, ssize_t;
typedef size_t usize_t;

#if defined(CL_VC)
typedef wchar_t wchar;
typedef unsigned __int64 uint64;
typedef unsigned __int64 ulonglong;
typedef __int64 int64;
typedef __int64 longlong;
#else
typedef wchar_t wchar;
typedef unsigned long long uint64;
typedef unsigned long long ulonglong;
typedef long long int64;
typedef long long longlong;
#endif

//#ifdef UNICODE
//typedef wchar tchar;
//#else
typedef char tchar;
//#endif

#ifndef byte
typedef unsigned char byte;
#endif

class Mixed;
// STL wrappers
template < typename _ChTy >
using XString = std::basic_string<_ChTy>;

typedef XString<char> AnsiString, Utf8String;
typedef XString<wchar> UnicodeString;
typedef XString<char16> UnicodeString16, Utf16String;
typedef XString<char32> UnicodeString32, Utf32String;
typedef XString<tchar> String;

template < typename _ChTy >
using XStringArray = std::vector< XString<_ChTy> >;

typedef XStringArray<char> AnsiStringArray, Utf8StringArray;
typedef XStringArray<wchar> UnicodeStringArray;
typedef XStringArray<char16> UnicodeString16Array;
typedef XStringArray<char32> UnicodeString32Array;
typedef XStringArray<char16> Utf16StringArray;
typedef XStringArray<char32> Utf32StringArray;
typedef XStringArray<tchar> StringArray;

typedef std::map<String, String> StringStringMap;
typedef std::pair<String, String> StringStringPair;

typedef std::vector<Mixed> MixedArray;
typedef std::map<String, Mixed> StringMixedMap;
typedef std::pair<String, Mixed> StringMixedPair;
//typedef std::map<Mixed, Mixed> MixedMixedMap;
//typedef std::pair<Mixed, Mixed> MixedMixedPair;

// WINUX常用常量 ---------------------------------------------------------------------------
static constexpr size_t const npos = static_cast<size_t>(-1);

// 模板元编程支持 ---------------------------------------------------------------------------
template < typename _Ty >
inline static constexpr _Ty InvertByteOrder( _Ty v )
{
    _Ty v2 = 0;
    for ( int i = 0; i < sizeof(_Ty); ++i ) v2 |= ( ( v >> i * 8 ) & 0xFFU ) << ( sizeof(_Ty) - 1 - i ) * 8;
    return v2;
}

inline static bool IsLittleEndian()
{
    constexpr winux::uint16 judgeHostOrder = 0x0102;
    return *(winux::byte*)&judgeHostOrder == 0x02;
}

inline static bool IsBigEndian()
{
    constexpr winux::uint16 judgeHostOrder = 0x0102;
    return *(winux::byte*)&judgeHostOrder == 0x01;
}

template < typename _MAP, typename _KEY >
inline bool isset( _MAP const & m, _KEY const & k )
{
    return m.find(k) != m.end();
}

template < typename _Ty >
std::vector<_Ty> ToArray( _Ty * arr, uint count )
{
    return std::vector<_Ty>( arr, arr + count );
}

template < typename _Ty, uint _N >
std::vector<_Ty> ToArray( _Ty (&arr)[_N] )
{
    return std::vector<_Ty>( arr, arr + _N );
}

template < typename _Fx, typename... _ArgType >
int VoidReturnInt( _Fx fn, _ArgType&& ...arg )
{
    fn( std::forward<_ArgType>(arg)... );
    return 1;
}

template < uint64 n > struct Bin0
{
    enum : uint64 { val = ( Bin0< n / 8 >::val << 1 ) + n % 8 };
};
template <> struct Bin0<0>
{
    enum : uint64 { val = 0 };
};

// 二进制数 macro包装
#define BinVal(x) winux::Bin0<0##x>::val

// 引用参数包装
template < typename _Ty >
class RefParam
{
    _Ty & _r;
public:
    typedef _Ty ParamType;
    typedef _Ty & ParamTypeRef;

    explicit RefParam( ParamTypeRef r ) : _r(r) { }
    operator ParamTypeRef () { return _r; }
};

template < typename _Ty >
RefParam<_Ty> Ref( _Ty & r )
{
    return RefParam<_Ty>(r);
}

template < size_t... _Index >
struct IndexSequence { };

// 构建一个IndexSequence< 0, 1, 2, ..., _Num - 1 >
template < size_t _Num, typename _IdxSeq = IndexSequence<> >
struct MakeIndexSequence;

template < size_t _Num, size_t... _Index >
struct MakeIndexSequence< _Num, IndexSequence<_Index...> > : MakeIndexSequence< _Num - 1, IndexSequence< _Index..., sizeof...(_Index) > > { };

template < size_t... _Index >
struct MakeIndexSequence< 0, IndexSequence<_Index...> >
{
    using Type = IndexSequence<_Index...>;
};

#include "func_traits.inl"

#include "func_runable.inl"

#include "func_invoker.inl"

template < typename _PfnType, _PfnType pfn >
struct FuncWrapper
{
    template < typename... _ArgType >
    static typename FuncTraits<_PfnType>::ReturnType func( _ArgType&& ...arg )
    {
        return (*pfn)( std::forward<_ArgType>(arg)... );
    }
};

template < typename _KTy, typename _VTy >
class MapAssigner
{
    std::map< _KTy, _VTy > * _m;
public:
    MapAssigner( std::map< _KTy, _VTy > * m ) : _m(m) { }
    MapAssigner & operator()( _KTy const & k, _VTy const & v )
    {
        (*_m)[k] = v;
        //_m->insert( std::pair< _KTy, _VTy >( k, v ) );
        return *this;
    }
    operator std::map< _KTy, _VTy > & () { return *_m; }
};

template < typename _Ty >
class ArrayAssigner
{
    std::vector<_Ty> * _a;
public:
    ArrayAssigner( std::vector<_Ty> * a ) : _a(a) { }
    ArrayAssigner & operator () ( _Ty const & v )
    {
        _a->push_back(v);
        return *this;
    }
    operator std::vector<_Ty> & () { return *_a; }
};

template < typename _KTy, typename _VTy >
MapAssigner< _KTy, _VTy > Assign( std::map< _KTy, _VTy > * m )
{
    return MapAssigner< _KTy, _VTy >(m);
}

template < typename _Ty >
ArrayAssigner<_Ty> Assign( std::vector<_Ty> * a )
{
    return ArrayAssigner<_Ty>(a);
}

template < typename _TargetCls >
class MembersWrapper
{
private:
    _TargetCls * _data;

    MembersWrapper( MembersWrapper const & other ) = delete;
public:
    MembersWrapper() : _data(nullptr) { }

    MembersWrapper & operator = ( MembersWrapper const & other )
    {
        if ( &other != this )
        {
            *_data = *other._data;
        }
        return *this;
    }

#ifndef MOVE_SEMANTICS_DISABLED
    MembersWrapper( MembersWrapper && other )
    {
        _data = other._data;
        other._data = nullptr;
    }
    MembersWrapper & operator = ( MembersWrapper && other )
    {
        if ( &other != this )
        {
            this->destroy();
            _data = other._data;
            other._data = nullptr;
        }
        return *this;
    }
#endif

    void destroy()
    {
        if ( _data )
        {
            delete (_TargetCls *)_data;
            _data = nullptr;
        }
    }

    template < typename... _ArgType >
    void create( _ArgType&&... arg )
    {
        this->destroy();
        _data = new _TargetCls( std::forward<_ArgType>(arg)... );
    }

    _TargetCls * get() const
    {
        return _data;
    }

    _TargetCls * operator -> ()
    {
        return _data;
    }
    _TargetCls const * operator -> () const
    {
        return _data;
    }

    operator _TargetCls & ()
    {
        return *_data;
    }
    operator _TargetCls const & () const
    {
        return *_data;
    }

    operator bool() const
    {
        return _data != nullptr;
    }
};

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

class Error : public std::exception
{
private:
    int _errType;
    AnsiString _errStr;
public:
    Error() throw() : _errType(0) { }
    Error( int errType, AnsiString const & errStr ) throw() : _errType(errType), _errStr(errStr) { }
    virtual ~Error() throw() { }
    virtual int getErrType() const throw() { return _errType; }
    virtual char const * what() const throw() { return _errStr.c_str(); }
};

WINUX_FUNC_DECL(bool) ValueIsInArray( StringArray const & arr, String const & val, bool caseInsensitive = false );

WINUX_FUNC_DECL(int) Random( int n1, int n2 );

// -------------------------------------------------------------------------------
class GrowBuffer;

class WINUX_DLL Buffer
{
public:
    Buffer();

    Buffer( void const * buf, size_t size, bool isPeek = false );

    Buffer( AnsiString const & data, bool isPeek = false );

    virtual ~Buffer();

    Buffer( Buffer const & other );

    Buffer & operator = ( Buffer const & other );

#ifndef MOVE_SEMANTICS_DISABLED

    Buffer( Buffer && other );
    Buffer & operator = ( Buffer && other );
    Buffer( GrowBuffer && other );
    Buffer & operator = ( GrowBuffer && other );
#endif

    void setBuf( void const * buf, size_t size, size_t capacity, bool isPeek );

    void setBuf( void const * buf, size_t size, bool isPeek ) { this->setBuf( buf, size, size, isPeek ); }

    void alloc( size_t capacity, bool setDataSize = true );

    void realloc( size_t newCapacity );

    bool peekCopy( bool copyCapacity = false );

    void * detachBuf( size_t * size = nullptr );

    void free();

    void * getBuf() const { return _buf; }

    template < typename _Ty >
    _Ty * getBuf() const { return reinterpret_cast<_Ty *>(_buf); }

    void * get() const { return _buf; }

    template < typename _Ty >
    _Ty * get() const { return reinterpret_cast<_Ty *>(_buf); }

    winux::byte & operator [] ( size_t i ) { return reinterpret_cast<winux::byte *>(_buf)[i]; }
    winux::byte const & operator [] ( size_t i ) const { return reinterpret_cast<winux::byte const *>(_buf)[i]; }
    winux::byte & get( size_t i ) { return reinterpret_cast<winux::byte *>(_buf)[i]; }
    winux::byte const & get( size_t i ) const { return reinterpret_cast<winux::byte const *>(_buf)[i]; }

    winux::byte * begin() { return reinterpret_cast<winux::byte *>(_buf); }
    winux::byte * end() { return reinterpret_cast<winux::byte *>(_buf) + _dataSize; }
    winux::byte const * begin() const { return reinterpret_cast<winux::byte *>(_buf); }
    winux::byte const * end() const { return reinterpret_cast<winux::byte *>(_buf) + _dataSize; }

    size_t getSize() const { return _dataSize; }

    size_t size() const { return _dataSize; }

    void _setSize( size_t dataSize ) { _dataSize = ( dataSize > _capacity ? _capacity : dataSize ); }

    size_t getCapacity() const { return _capacity; }

    size_t capacity() const { return _capacity; }

    operator bool() const { return _buf != NULL; }

    template < typename _ChTy >
    XString<_ChTy> toString() const
    {
        typedef typename XString<_ChTy>::value_type CharType;
        return XString<_ChTy>( (CharType*)_buf, _dataSize / sizeof(CharType) );
    }

    AnsiString toAnsi() const { return this->toString<AnsiString::value_type>(); }

    UnicodeString toUnicode() const { return this->toString<UnicodeString::value_type>(); }

public:
    static void * _Alloc( size_t size );
    static void * _Realloc( void * p, size_t newSize );
    static void _Free( void * p );

protected:
    void * _buf; 
    size_t _dataSize; 
    size_t _capacity; 
    bool _isPeek; 

    friend class GrowBuffer;
};

class WINUX_DLL GrowBuffer : public Buffer
{
public:
    explicit GrowBuffer( size_t capacity = 0 );
    GrowBuffer( GrowBuffer const & other );
    GrowBuffer & operator = ( GrowBuffer const & other );
    explicit GrowBuffer( Buffer const & other );
    GrowBuffer & operator = ( Buffer const & other );

#ifndef MOVE_SEMANTICS_DISABLED

    GrowBuffer( GrowBuffer && other );
    GrowBuffer & operator = ( GrowBuffer && other );
    GrowBuffer( Buffer && other );
    GrowBuffer & operator = ( Buffer && other );
#endif

    void append( void const * data, size_t size );

    void append( AnsiString const & data ) { this->append( data.c_str(), data.size() ); }

    void append( Buffer const & data ) { this->append( data.getBuf(), data.getSize() ); }

    template < typename _PodType, size_t _Size = sizeof(_PodType) >
    void append( _PodType const & data ) { this->append( &data, _Size ); }

    template < typename _PodType, size_t _Count >
    void append( _PodType const (&data)[_Count] ) { this->append( &data, _Count * sizeof(data[0]) ); }

    template < typename _PodType >
    void append( std::initializer_list<_PodType> list )
    {
        for ( auto const & e : list )
        {
            this->append< _PodType, sizeof(e) >(e);
        }
    }

    void erase( size_t start, size_t count = (size_t)-1 );

protected:
    friend class Buffer;
};

// 混合体相关 ------------------------------------------------------------------------------
class MixedError : public Error
{
public:
    enum
    {
        meNoError,         
        meIsNull,          
        meCantConverted,   
        meUnexpectedType,  
        meOutOfArrayRange, 
    };

    MixedError( int errType, AnsiString const & errStr ) throw() : Error( errType, errStr ) { }
};

struct $a
{
    std::initializer_list<Mixed> _list;
    $a( std::initializer_list<Mixed> list ) : _list( std::move(list) )
    {
    }
};

struct $c
{
    std::initializer_list< std::pair< Mixed, Mixed > > _list;
    $c( std::initializer_list< std::pair< Mixed, Mixed > > list ) : _list( std::move(list) )
    {
    }
};

class WINUX_DLL Mixed
{
public:
    enum MixedType : ushort
    {
    #define MixedType_ENUM_ITEM(item) item,
    #define MixedType_ENUM_ITEMSTRING(item) #item,
    #define MixedType_ENUM_ITEMLIST(_)\
        _(MT_NULL)\
        _(MT_BOOLEAN)\
        _(MT_BYTE)\
        _(MT_SHORT) _(MT_USHORT)\
        _(MT_INT) _(MT_UINT)\
        _(MT_LONG) _(MT_ULONG)\
        _(MT_INT64) _(MT_UINT64)\
        _(MT_FLOAT) _(MT_DOUBLE)\
        _(MT_ANSI) _(MT_UNICODE)\
        _(MT_ARRAY) \
        _(MT_COLLECTION) \
        _(MT_BINARY)
    MixedType_ENUM_ITEMLIST(MixedType_ENUM_ITEM)
    };

    static String const & TypeString( MixedType type );

    class WINUX_DLL MixedLess
    {
    public:
        bool operator () ( Mixed const & v1, Mixed const & v2 ) const;
    };

    typedef std::map< Mixed, Mixed, MixedLess > MixedMixedMap;
    typedef MixedMixedMap::value_type  MixedMixedPair;

    MixedType _type; 

    union
    {
        double _dblVal;
        uint64 _ui64Val;
        int64 _i64Val;
        float _fltVal;
        ulong _ulVal;
        long _lVal;
        uint _uiVal;
        int _iVal;
        ushort _ushVal;
        short _shVal;
        byte _btVal;
        bool _boolVal;
        struct // 字符串
        {
            union
            {
                AnsiString * _pStr;
                UnicodeString * _pWStr;
            };
        };
        struct // Array or Collection
        {
            MixedArray * _pArr;
            MixedMixedMap * _pMap;
        };
        struct // 二进制数据
        {
            Buffer * _pBuf;
        };
    };

public:
    Mixed();
    Mixed( AnsiString const & str );                
    Mixed( UnicodeString const & str );             
    Mixed( char const * str, size_t len = npos );   
    Mixed( wchar const * str, size_t len = npos );  

    Mixed( bool boolVal );
    Mixed( byte btVal );
    Mixed( short shVal );
    Mixed( ushort ushVal );
    Mixed( int iVal );
    Mixed( uint uiVal );
    Mixed( long lVal );
    Mixed( ulong ulVal );
    Mixed( float fltVal );
    Mixed( int64 i64Val );
    Mixed( uint64 ui64Val );
    Mixed( double dblVal );

    Mixed( Buffer const & buf );
    Mixed( void const * binaryData, size_t size, bool isPeek = false );

    // Array构造函数 -----------------------------------------------------------------------
    Mixed( Mixed * arr, size_t count );

    template < typename _Ty >
    Mixed( std::vector<_Ty> const & arr )
    {
        _zeroInit();
        this->_type = MT_ARRAY;
        this->_pArr = new MixedArray( arr.size() );
        size_t i;
        for ( i = 0; i < arr.size(); ++i )
        {
            this->_pArr->at(i) = arr[i];
        }
    }

    template < typename _Ty, size_t _N >
    Mixed( _Ty (&arr)[_N] )
    {
        _zeroInit();
        this->_type = MT_ARRAY;
        this->_pArr = new MixedArray(_N);
        size_t i;
        for ( i = 0; i < _N; ++i )
        {
            this->_pArr->at(i) = arr[i];
        }
    }

    Mixed( std::initializer_list<Mixed> list );

    Mixed( $a arr );

    // Collection构造函数 ------------------------------------------------------------------
    template < typename _KTy, typename _VTy, typename _Pr, typename _Alloc >
    Mixed( std::map< _KTy, _VTy, _Pr, _Alloc > const & m )
    {
        _zeroInit();
        this->assign< _KTy, _VTy, _Pr, _Alloc >(m);
    }

    template < typename _KTy, typename _VTy, size_t _Count >
    Mixed( std::pair< _KTy, _VTy > (&pairs)[_Count] )
    {
        _zeroInit();
        this->assign< _KTy, _VTy, _Count >(pairs);
    }

    template < typename _KTy, typename _VTy, size_t _Count >
    Mixed( _KTy (&keys)[_Count], _VTy (&vals)[_Count] )
    {
        _zeroInit();
        this->assign< _KTy, _VTy, _Count >( keys, vals );
    }

    Mixed( $c coll );

    ~Mixed();

    Mixed( Mixed const & other );
    Mixed & operator = ( Mixed const & other );

#ifndef MOVE_SEMANTICS_DISABLED

    Mixed( Mixed && other );
    Mixed & operator = ( Mixed && other );

    Mixed( Buffer && buf );
    void assign( Buffer && buf );

    Mixed( GrowBuffer && buf );
    void assign( GrowBuffer && buf );

#endif

    void free();

    MixedType type() const { return this->_type; }
    String const & typeString() const { return TypeString(this->_type); }

    // 取得相关类型的引用 --------------------------------------------------------------------
    template < typename _ChTy >
    XString<_ChTy> & refString();
    template < typename _ChTy >
    XString<_ChTy> const & refString() const;
    #include "mixed_ref_specified_type.inl"

    // 类型转换 ----------------------------------------------------------------------------
    operator AnsiString() const;
    operator UnicodeString() const;
    operator Buffer() const;
    operator bool() const;
    operator byte() const;
    operator short() const;
    operator ushort() const;
    operator int() const;
    operator uint() const;
    operator long() const;
    operator ulong() const;
    operator float() const;
    operator int64() const;
    operator uint64() const;
    operator double() const;

    template < typename _ChTy >
    XString<_ChTy> toString() const ; // { throw MixedError( MixedError::meCantConverted, AnsiString("Can't convert to ") + typeid(XString<_ChTy>).name() ); }
    AnsiString toAnsi() const { return this->operator AnsiString(); }
    UnicodeString toUnicode() const { return this->operator UnicodeString(); }
    Buffer toBuffer() const { return this->operator Buffer(); }
    bool toBool() const { return this->operator bool(); }
    byte toByte() const { return this->operator winux::byte(); }
    short toShort() const { return this->operator short(); }
    ushort toUShort() const { return this->operator winux::ushort(); }
    int toInt() const { return this->operator int(); }
    uint toUInt() const { return this->operator winux::uint(); }
    long toLong() const { return this->operator long(); }
    ulong toULong() const { return this->operator winux::ulong(); }
    float toFloat() const { return this->operator float(); }
    int64 toInt64() const { return this->operator winux::int64(); }
    uint64 toUInt64() const { return this->operator winux::uint64(); }
    double toDouble() const { return this->operator double(); }

    // 比较操作符 --------------------------------------------------------------------------
    bool operator == ( Mixed const & other ) const;
    bool operator < ( Mixed const & other ) const;
    bool operator != ( Mixed const & other ) const { return !this->operator == (other); }
    bool operator > ( Mixed const & other ) const { return !this->operator <= (other); }
    bool operator >= ( Mixed const & other ) const { return !this->operator < (other); }
    bool operator <= ( Mixed const & other ) const { return this->operator < (other) || this->operator == (other); }

    // 判定特殊类型 -------------------------------------------------------------------------
    bool isNull() const { return this->_type == MT_NULL; }
    bool isArray() const { return this->_type == MT_ARRAY; }
    bool isCollection() const { return this->_type == MT_COLLECTION; }
    bool isContainer() const { return this->_type == MT_ARRAY || this->_type == MT_COLLECTION; }
    bool isBinary() const { return this->_type == MT_BINARY; }
    bool isNumeric() const { return this->_type > MT_NULL && this->_type < MT_ANSI; }
    bool isInteger() const { return this->isNumeric() && this->_type != MT_FLOAT && this->_type != MT_DOUBLE; }
    bool isAnsi() const { return this->_type == MT_ANSI; }
    bool isUnicode() const { return this->_type == MT_UNICODE; }
    bool isString() const { return this->_type == MT_ANSI || this->_type == MT_UNICODE; }

    // 创建相关类型 -------------------------------------------------------------------------
    template < typename _ChTy >
    Mixed & createString();
    Mixed & createAnsi();
    Mixed & createUnicode();
    Mixed & createArray( size_t count = 0 );
    Mixed & createCollection();
    Mixed & createBuffer( size_t size = 0 );

    // Array/Collection有关的操作 ----------------------------------------------------------

    template < typename _Ty >
    size_t getArray( std::vector<_Ty> * arr ) const
    {
        if ( !this->isArray() && !this->isCollection() ) throw MixedError( MixedError::meUnexpectedType, TypeString(this->_type) + " can't support getArray()" );
        MixedArray::const_iterator it;
        for ( it = this->_pArr->begin(); it != this->_pArr->end(); ++it )
            arr->push_back(*it);
        return arr->size();
    }

    template < typename _KTy >
    size_t getKeys( std::vector<_KTy> * keys ) const
    {
        if ( !this->isCollection() ) throw MixedError( MixedError::meUnexpectedType, TypeString(this->_type) + " can't support getKeys()" );
        MixedArray::const_iterator it;
        for ( it = this->_pArr->begin(); it != this->_pArr->end(); ++it )
            keys->push_back(*it);
        return keys->size();
    }

    template < typename _KTy, typename _VTy >
    size_t getMap( std::map< _KTy, _VTy > * m ) const
    {
        if ( !this->isCollection() ) throw MixedError( MixedError::meUnexpectedType, TypeString(this->_type) + " can't support getMap()" );
        MixedMixedMap::const_iterator it;
        for ( it = this->_pMap->begin(); it != this->_pMap->end(); ++it )
            (*m)[(_KTy)it->first] = (_VTy)it->second;
        return m->size();
    }

    bool isEmpty() const { return this->getCount() == 0; }

    size_t getCount() const
    {
        if ( ( this->isArray() || this->isCollection() ) && this->_pArr != NULL )
            return this->_pArr->size();
        return 0;
    }

    Mixed & operator [] ( Mixed const & k );
    Mixed const & operator [] ( Mixed const & k ) const;
    template < typename _ChTy >
    Mixed & operator [] ( _ChTy const * k ) { return this->operator[]( Mixed(k) ); }
    template < typename _ChTy >
    Mixed const & operator [] ( _ChTy const * k ) const { return this->operator[]( Mixed(k) ); }

    template < typename _Ty >
    _Ty get( Mixed const & k, Mixed const & defval = Mixed() ) const { return (_Ty)this->get( k, defval ); }

    Mixed const & get( Mixed const & k, Mixed const & defval = Mixed() ) const;

    MixedMixedMap::value_type & getPair( size_t i );
    MixedMixedMap::value_type const & getPair( size_t i ) const;

    class CollectionAssigner
    {
    public:
        CollectionAssigner( Mixed * mx ) : _mx(mx) { }
        CollectionAssigner & operator()( Mixed const & k, Mixed const & v )
        {
            if ( _mx->isCollection() )
            {
                _mx->_addUniqueKey(k);
                _mx->_pMap->operator[](k) = v;
            }
            return *this;
        }
        operator Mixed & () { return *_mx; }

    private:
        Mixed * _mx;
    };

    CollectionAssigner addPair()
    {
        if ( this->_type != MT_COLLECTION ) this->createCollection();
        return CollectionAssigner(this);
    }

    Mixed & addPair( Mixed const & k, Mixed const & v );

    class ArrayAssigner
    {
    public:
        ArrayAssigner( Mixed * mx ) : _mx(mx) { }
        ArrayAssigner & operator()( Mixed const & v )
        {
            if ( _mx->isArray() )
            {
                _mx->_pArr->push_back(v);
            }
            return *this;
        }
        operator Mixed & () { return *_mx; }

    private:
        Mixed * _mx;
    };

    ArrayAssigner add()
    {
        if ( this->_type != MT_ARRAY ) this->createArray();
        return ArrayAssigner(this);
    }

    size_t add( Mixed const & v );

    size_t addUnique( Mixed const & v );

    void del( Mixed const & k );

    bool has( Mixed const & ek ) const;

    Mixed & merge( Mixed const & v );

    Mixed & reverse();

    // Buffer有关操作 --------------------------------------------------------------------------
    void alloc( size_t size, bool setDataSize = true );

    bool peekCopy( bool copyCapacity = false );

    size_t getSize() const;

    void * getBuf() const;

    // 赋值操作 -------------------------------------------------------------------------------
    void assign( char const * str, size_t len = npos );
    void assign( wchar const * str, size_t len = npos );
    void assign( bool boolVal );
    void assign( byte btVal );
    void assign( short shVal );
    void assign( ushort ushVal );
    void assign( int iVal );
    void assign( uint uiVal );
    void assign( long lVal );
    void assign( ulong ulVal );
    void assign( float fltVal );
    void assign( int64 i64Val );
    void assign( uint64 ui64Val );
    void assign( double dblVal );

    void assign( Buffer const & buf );
    void assign( void const * binaryData, size_t size, bool isPeek = false );
    void assign( Mixed * arr, size_t count );

    template < typename _Ty >
    void assign( std::vector<_Ty> const & arr )
    {
        this->free();
        this->_type = MT_ARRAY;
        this->_pArr = new MixedArray( arr.size() );
        size_t i;
        for ( i = 0; i < arr.size(); ++i )
        {
            this->_pArr->at(i) = arr[i];
        }
    }

    template < typename _Ty, size_t _N >
    void assign( _Ty (&arr)[_N] )
    {
        this->free();
        this->_type = MT_ARRAY;
        this->_pArr = new MixedArray(_N);
        size_t i;
        for ( i = 0; i < _N; ++i )
        {
            this->_pArr->at(i) = arr[i];
        }
    }

    void assign( std::initializer_list<Mixed> list );

    void assign( $a arr );

    template < typename _KTy, typename _VTy, typename _Pr, typename _Alloc >
    void assign( std::map< _KTy, _VTy, _Pr, _Alloc > const & m )
    {
        this->free();
        this->_type = MT_COLLECTION;
        this->_pArr = new MixedArray(); // 存放keys
        this->_pMap = new MixedMixedMap();
        typename std::map< _KTy, _VTy, _Pr, _Alloc >::const_iterator it;
        for ( it = m.begin(); it != m.end(); ++it )
        {
            this->_pArr->push_back(it->first);
            (*this->_pMap)[it->first] = it->second;
        }
    }

    template < typename _KTy, typename _VTy, size_t _Count >
    void assign( std::pair< _KTy, _VTy > (&pairs)[_Count] )
    {
        this->free();
        this->_type = MT_COLLECTION;
        this->_pArr = new MixedArray(); // 存放keys
        this->_pMap = new MixedMixedMap();
        size_t i;
        for ( i = 0; i < _Count; ++i )
        {
            this->_addUniqueKey(pairs[i].first);
            (*this->_pMap)[pairs[i].first] = pairs[i].second;
        }
    }

    template < typename _KTy, typename _VTy, size_t _Count >
    void assign( _KTy (&keys)[_Count], _VTy (&vals)[_Count] )
    {
        this->free();
        this->_type = MT_COLLECTION;
        this->_pArr = new MixedArray(); // 存放keys
        this->_pMap = new MixedMixedMap();
        size_t i;
        for ( i = 0; i < _Count; ++i )
        {
            this->_addUniqueKey(keys[i]);
            (*this->_pMap)[keys[i]] = vals[i];
        }
    }

    void assign( $c coll );

    // JSON相关操作 ------------------------------------------------------------------------
    String myJson( bool autoKeyQuotes = true, AnsiString const & spacer = "", AnsiString const & newline = "" ) const;
    String json() const;
    Mixed & json( String const & jsonStr );

    // 类型解析功能 -------------------------------------------------------------------------
    static bool ParseBool( AnsiString const & str, bool * boolVal );
    static bool ParseBool( UnicodeString const & str, bool * boolVal );
    static bool ParseULong( AnsiString const & str, ulong * ulVal );
    static bool ParseULong( UnicodeString const & str, ulong * ulVal );
    static bool ParseDouble( AnsiString const & str, double * dblVal );
    static bool ParseDouble( UnicodeString const & str, double * dblVal );
    static bool ParseUInt64( AnsiString const & str, uint64 * ui64Val );
    static bool ParseUInt64( UnicodeString const & str, uint64 * ui64Val );

    static Mixed & ParseJson( AnsiString const & str, Mixed * val );

private:
    void _zeroInit();
    // MT_COLLECTION，给数组加入一个唯一键名
    void _addUniqueKey( Mixed const & k )
    {
        if ( this->_pMap->find(k) == this->_pMap->end() )
            this->_pArr->push_back(k);
    }
};

template <>
inline XString<char> & Mixed::refString<char>()
{
    return this->refAnsi();
}

template <>
inline XString<char> const & Mixed::refString<char>() const
{
    return this->refAnsi();
}

template <>
inline XString<wchar> & Mixed::refString<wchar>()
{
    return this->refUnicode();
}

template <>
inline XString<wchar> const & Mixed::refString<wchar>() const
{
    return this->refUnicode();
}

template <>
inline XString<char> Mixed::toString<char>() const
{
    return this->toAnsi();
}

template <>
inline XString<wchar> Mixed::toString<wchar>() const
{
    return this->toUnicode();
}

template <>
inline Mixed & Mixed::createString<char>()
{
    return this->createAnsi();
}

template <>
inline Mixed & Mixed::createString<wchar>()
{
    return this->createUnicode();
}

WINUX_FUNC_DECL(std::ostream &) operator << ( std::ostream & o, Mixed const & m );
WINUX_FUNC_DECL(std::wostream &) operator << ( std::wostream & o, Mixed const & m );

//std::istream & operator >> ( std::istream & o, Mixed const & m );
//std::wistream & operator >> ( std::wistream & o, Mixed const & m );

} // namespace winux

#endif // __UTILITIES_HPP__