regularexpression_helper.h

Go to the documentation of this file.

 
#ifndef _REGULAR_EXPRESSION_HELPER_CLASS_HEADER_
#define _REGULAR_EXPRESSION_HELPER_CLASS_HEADER_
 
namespace A_UTILS_NS
{
 
class DOEXPORT cStringPiece
{
    A_UTILS_D(cStringPiece)
 
    class cStringPiecePrivate : public d_ptr_impl<cStringPiece, cStringPiecePrivate>
    {
        friend class cStringPiece;
        public:
            cStringPiecePrivate(){};
            virtual ~cStringPiecePrivate(){};
    };
 
    private:
        const tChar* ptr_;    
        tInt         length_; 
 
    public:
        // We provide non-explicit singleton constructors so users can pass
        // in a "const tChar*" or a "string" wherever a "cStringPiece" is
        // expected.
        cStringPiece()
        : ptr_(nullptr)
        , length_(0)
        {
        }
 
        cStringPiece(const cStringPiece& i_oOther) :
            _d(),   //currently no need to copy _d, not used
            ptr_(i_oOther.GetPtr()),
            length_(i_oOther.GetSize())
        {
        }
 
        cStringPiece& operator= (const cStringPiece& i_oOther)
        {
            if (this != &i_oOther)
            {
                _d = nullptr;   //currently no need to copy _d, not used
                ptr_ = i_oOther.GetPtr();
                length_ = i_oOther.GetSize();
            }
            return *this;
        }
 
        cStringPiece(const tChar* str)
        : ptr_(str)
        , length_(static_cast<tInt>(cStringUtil::GetLength(str)))
        {
        }
 
        cStringPiece(const cString& str)
        : ptr_(str.GetPtr())
        , length_(static_cast<tInt>(str.GetLength()))
        {
        }
 
        cStringPiece(const tChar* offset, tInt len)
        : ptr_(offset)
        , length_(len)
        {
        }
 
        const tChar* GetPtr() const
        {
            return ptr_;
        }
 
        tInt GetSize() const
        {
            return length_;
        }
 
        tBool IsEmpty() const
        {
            return length_ == 0;
        }
 
        tVoid Clear()
        {
            ptr_ = nullptr;
            length_ = 0;
        }
 
        tVoid Set(const tChar* buffer, tInt len)
        {
            ptr_ = buffer;
            length_ = len;
        }
 
        tVoid Set(const tChar* str)
        {
            if (nullptr != str)
            {
                ptr_ = str;
                length_ = static_cast<tInt>(cStringUtil::GetLength(str));
            }
        }
 
        tVoid Set(const tVoid* buffer, tInt len)
        {
            if ((nullptr != buffer)
               && (len >=0))
            {
                ptr_ = reinterpret_cast<const tChar*>(buffer);
                length_ = len;
            }
        }
 
        tChar operator[](tInt i) const
        {
            if ((i > 0) &&
                (i < length_))
            {
                return ptr_[i];
            }
            return 0;
        }
 
        tVoid RemovePrefix(tInt n)
        {
            if (0 < length_)
            {
                ptr_ += n;
                length_ -= n;
            }
        }
 
        tVoid RemoveSuffix(tInt n)
        {
            if (0 < length_)
            {
                length_ -= n;
            }
        }
 
        tBool operator==(const cStringPiece& x) const
        {
            return ((length_ == x.length_) && (cMemoryBlock::MemCmp(ptr_, x.ptr_, length_) == 0));
        }
 
        tBool operator!=(const cStringPiece& x) const
        {
            return !(*this == x);
        }
 
        #define STRINGPIECE_BINARY_PREDICATE(cmp,auxcmp)\
            tBool operator cmp (const cStringPiece& x) const {\
            tInt r = cMemoryBlock::MemCmp(ptr_, x.ptr_, length_ < x.length_ ? length_ : x.length_);\
            return ((r auxcmp 0) || ((r == 0) && (length_ cmp x.length_)));\
            }
            STRINGPIECE_BINARY_PREDICATE(<,  <);
            STRINGPIECE_BINARY_PREDICATE(<=, <);
            STRINGPIECE_BINARY_PREDICATE(>=, >);
            STRINGPIECE_BINARY_PREDICATE(>,  >);
        #undef STRINGPIECE_BINARY_PREDICATE
 
        tInt Compare(const cStringPiece& x) const
        {
            tInt r = cMemoryBlock::MemCmp(ptr_, x.ptr_, length_ < x.length_ ? length_ : x.length_);
            if (r == 0)
            {
                if (length_ < x.length_)
                {
                    r = -1;
                }
                else if (length_ > x.length_)
                {
                    r = +1;
                }
            }
            return r;
        }
 
        cString AsString() const
        {
            if (nullptr == GetPtr())
            {
                return cString::Empty;
            }
            cString strTmp;
            CopyToString(&strTmp);
            return strTmp;
        }
 
        tVoid CopyToString(cString* target) const
        {
            if ((nullptr != ptr_) &&
                (nullptr != target))
            {
                target->Set(ptr_, length_);
            }
        }
 
        // Does "this" start with "x"
        tBool StartsWith(const cStringPiece& x) const
        {
            if ((nullptr == GetPtr())
                || (nullptr == x.GetPtr()))
            {
                return tFalse;
            }
            return ((length_ >= x.length_) && (cMemoryBlock::MemCmp(ptr_, x.ptr_, x.length_) == 0));
        }
};
 
typedef tBool (*fnRegExpParser)(const tChar* str, tInt n, tVoid* dest);
 
 
template<bool B, class T = void>
struct a_utils_enable_if
{
};
 
template<class T>
struct a_utils_enable_if<true, T>
{
    typedef T type;
};
 
template<class T>
struct a_utils_size_of_helper
{
    static const tSize nSize = sizeof(T);
};
 
template<>
struct a_utils_size_of_helper<tVoid>
{
    static const tSize nSize = 0;
};
 
class DOEXPORT cRegularExpressionArg
{
    private:
        tVoid* arg_;
        fnRegExpParser parser_;
 
        static tBool parse_null       (const tChar* str, tInt n, tVoid* dest);
        static tBool parse_tChar      (const tChar* str, tInt n, tVoid* dest);
        static tBool parse_tFloat32   (const tChar* str, tInt n, tVoid* dest);
        static tBool parse_tFloat64   (const tChar* str, tInt n, tVoid* dest);
        static tBool parse_stdstring  (const tChar* str, tInt n, tVoid* dest);
 
        static tBool parse_string     (const tChar* str, tInt n, tVoid* dest);
        static tBool parse_stringpiece(const tChar* str, tInt n, tVoid* dest);
        static tBool A_UTILS_DEPRECATED(parse_int)(const tChar* str, tInt n, tVoid* dest);
 
    #define AEVREGEXP_DECLARE_INTEGER_PARSER(name)\
    private:\
        static tBool parse_ ## name(const tChar* str, tInt n, tVoid* dest);\
        static tBool parse_ ## name ## _radix(\
        const tChar* str, tInt n, tVoid* dest, tInt radix);\
    public:\
        static tBool parse_ ## name ## _hex(const tChar* str, tInt n, tVoid* dest);\
        static tBool parse_ ## name ## _octal(const tChar* str, tInt n, tVoid* dest);\
        static tBool parse_ ## name ## _cradix(const tChar* str, tInt n, tVoid* dest)
 
        AEVREGEXP_DECLARE_INTEGER_PARSER(tInt8);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tUInt8);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tInt16);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tUInt16);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tInt32);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tUInt32);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tInt64);
        AEVREGEXP_DECLARE_INTEGER_PARSER(tUInt64);
 
    #undef AEVREGEXP_DECLARE_INTEGER_PARSER
 
    public:
        cRegularExpressionArg(): arg_(nullptr), parser_(parse_null)
        {
        }
 
        cRegularExpressionArg(fnRegExpParser pParser, tVoid* pData)
        {
            arg_ = pData;
            parser_ = pParser;
        }
 
        tVoid Set(fnRegExpParser pParser, tVoid* pData)
        {
            arg_ = pData;
            parser_ = pParser;
        }
 
        tVoid* GetData() const { return arg_; };
        fnRegExpParser GetParser() const { return parser_; };
 
        // Type-specific parsers
        #define REG_EXP_CONST_INTEGER(size, name) \
        template<class T> \
        cRegularExpressionArg(T* pRef, fnRegExpParser parser = name, \
                    typename a_utils_enable_if<std::numeric_limits<T>::is_integer, T>::type* = nullptr, \
                    typename a_utils_enable_if<std::numeric_limits<T>::is_signed, T>::type* = nullptr, \
                    typename a_utils_enable_if<a_utils_size_of_helper<T>::nSize == size, T>::type* = nullptr) \
                    : arg_(pRef), parser_(parser) {}
 
        #define REG_EXP_CONST_UNSIGNED_INTEGER(size, name) \
        template<class T> \
        cRegularExpressionArg(T* pRef, fnRegExpParser parser = name, \
                    typename a_utils_enable_if<std::numeric_limits<T>::is_integer, T>::type* = nullptr, \
                    typename a_utils_enable_if<!std::numeric_limits<T>::is_signed, T>::type* = nullptr, \
                    typename a_utils_enable_if<a_utils_size_of_helper<T>::nSize == size, T>::type* = nullptr) \
                    : arg_(pRef), parser_(parser) {}
 
        #define REG_EXP_CONST_FLOAT(size, name) \
        template<class T> \
        cRegularExpressionArg(T* pRef, fnRegExpParser parser = name, \
                    typename a_utils_enable_if<!std::numeric_limits<T>::is_integer, T>::type* = nullptr, \
                    typename a_utils_enable_if<a_utils_size_of_helper<T>::nSize == size, T>::type* = nullptr) \
                    : arg_(pRef), parser_(parser) {}
 
        REG_EXP_CONST_INTEGER(1, parse_tInt8)
        REG_EXP_CONST_UNSIGNED_INTEGER(1, parse_tUInt8)
        REG_EXP_CONST_INTEGER(2, parse_tInt16)
        REG_EXP_CONST_UNSIGNED_INTEGER(2, parse_tUInt16)
        REG_EXP_CONST_INTEGER(4, parse_tInt32)
        REG_EXP_CONST_UNSIGNED_INTEGER(4, parse_tUInt32)
        REG_EXP_CONST_INTEGER(8, parse_tInt64)
        REG_EXP_CONST_UNSIGNED_INTEGER(8, parse_tUInt64)
 
        REG_EXP_CONST_FLOAT(4, parse_tFloat32)
        REG_EXP_CONST_FLOAT(8, parse_tFloat64)
 
        
        cRegularExpressionArg(tChar* p) : arg_(p), parser_(parse_tChar) {}
 
        cRegularExpressionArg(cString* p) : arg_(p), parser_(parse_string) {}
 
        cRegularExpressionArg(cStringPiece* p) : arg_(p), parser_(parse_stringpiece) {}
 
        cRegularExpressionArg(tVoid* pRef): arg_(pRef), parser_(parse_null) {}
 
        #undef REG_EXP_CONST_FLOAT
        #undef REG_EXP_CONST_UNSIGNED_INTEGER
        #undef REG_EXP_CONST_INTEGER
 
        tBool Parse(const tChar* str, tInt n) const
        {
            return (*parser_)(str, n, arg_);
        }
};
 
#define A_UTILS_MAKE_INTEGER_PARSER_HELPER(size, parser, func, parser_name) \
template<class T> \
inline cRegularExpressionArg func(T* pArg, \
                                 typename a_utils_enable_if<std::numeric_limits<T>::is_integer, T>::type* = nullptr, \
                                 typename a_utils_enable_if<std::numeric_limits<T>::is_signed, T>::type* = nullptr, \
                                 typename a_utils_enable_if<a_utils_size_of_helper<T>::nSize == size, T>::type* = nullptr) \
{ \
    return cRegularExpressionArg(pArg, cRegularExpressionArg::parse_tInt ## parser ## parser_name); \
} \
 
#define A_UTILS_MAKE_INTEGER_PARSER(size, parser) \
    A_UTILS_MAKE_INTEGER_PARSER_HELPER(size, parser, Hex, _hex) \
    A_UTILS_MAKE_INTEGER_PARSER_HELPER(size, parser, Octal, _octal) \
    A_UTILS_MAKE_INTEGER_PARSER_HELPER(size, parser, CRadix, _cradix)
 
#define A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER_HELPER(size, parser, func, parser_name) \
template<class T> \
inline cRegularExpressionArg func(T* pArg, \
                                 typename a_utils_enable_if<std::numeric_limits<T>::is_integer, T>::type* = nullptr, \
                                 typename a_utils_enable_if<!std::numeric_limits<T>::is_signed, T>::type* = nullptr, \
                                 typename a_utils_enable_if<a_utils_size_of_helper<T>::nSize == size, T>::type* = nullptr) \
{ \
    return cRegularExpressionArg(pArg, cRegularExpressionArg::parse_tUInt ## parser ## parser_name); \
} \
 
#define A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER(size, parser) \
    A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER_HELPER(size, parser, Hex, _hex) \
    A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER_HELPER(size, parser, Octal, _octal) \
    A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER_HELPER(size, parser, CRadix, _cradix)
 
A_UTILS_MAKE_INTEGER_PARSER(1, 8)
A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER(1, 8)
A_UTILS_MAKE_INTEGER_PARSER(2, 16)
A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER(2, 16)
A_UTILS_MAKE_INTEGER_PARSER(4, 32)
A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER(4, 32)
A_UTILS_MAKE_INTEGER_PARSER(8, 64)
A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER(8, 64)
 
#undef A_UTILS_MAKE_INTEGER_PARSER
#undef A_UTILS_MAKE_INTEGER_PARSER_HELPER
#undef A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER
#undef A_UTILS_MAKE_UNSIGNED_INTEGER_PARSER_HELPER
 
} // namespace A_UTILS_NS
 
#endif // _REGULAR_EXPRESSION_HELPER_CLASS_HEADER_