1281 lines
30 KiB
C++
1281 lines
30 KiB
C++
#pragma once
|
||
|
||
//±ê×¼¿âÀàÐÍÀ©Õ¹²Ù×÷
|
||
//20191212-1029
|
||
|
||
#include <cassert>
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
|
||
#include <type_traits>
|
||
#include <limits>
|
||
#include <algorithm>
|
||
#include <utility>
|
||
#include <tuple>
|
||
#include <functional>
|
||
#include <iterator>
|
||
|
||
#include <string>
|
||
|
||
#include <exception>
|
||
#include <stdexcept>
|
||
#include <random>
|
||
#include <ratio>
|
||
|
||
#include <chrono>
|
||
|
||
|
||
|
||
|
||
//************
|
||
//ÀàÐͱðÃûÀ©Õ¹
|
||
//************
|
||
|
||
|
||
//durationÀ©Õ¹
|
||
namespace std
|
||
{
|
||
namespace chrono
|
||
{
|
||
typedef duration<long, ratio<3600*24>> days;
|
||
typedef duration<long, ratio<3600*24*7>> weeks;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//************
|
||
//»ù´¡ÀàÐÍÀ©Õ¹
|
||
//************
|
||
|
||
//ÎÞÓÃռλÀàÐÍ
|
||
template<int N>
|
||
class BlankType
|
||
{
|
||
};
|
||
|
||
|
||
|
||
//²âÊÔ²ÎÊýÊÇ·ñºÏ·¨Àà
|
||
template<typename ...>
|
||
struct ParamValidTester
|
||
{
|
||
typedef void type;
|
||
};
|
||
|
||
|
||
//ÏÈÈ¥³ýÒýÓÃÔÙÈ¥³ý³£ÊýÒ×±äÊôÐÔ
|
||
template<typename Ty>
|
||
struct RemoveCVRef
|
||
{
|
||
using type = typename std::remove_cv<typename std::remove_reference<Ty>::type>::type;
|
||
};
|
||
|
||
//ºóÕßÈ¥³ýÒýÓó£ÊýÒ×±äºóÊÇ·ñΪǰÕß
|
||
template<typename TyDst, typename TySrc>
|
||
struct IsRemoveCVRefSame:
|
||
std::is_same<TyDst, typename RemoveCVRef<TySrc>::type>
|
||
{
|
||
};
|
||
|
||
|
||
//ºóÕß²ÎÊý°üÊÇ·ñÒª²»Ã»ÓвÎÊý£¬Òª²»Ö»ÓÐÒ»¸ö²¢ÇÒΪǰÕß
|
||
template<typename TyDst, typename ...TySrc_S>
|
||
struct IsNoneOrSame:
|
||
std::integral_constant<bool, sizeof...(TySrc_S)==0>
|
||
{
|
||
};
|
||
template<typename TyDst, typename TySrc>
|
||
struct IsNoneOrSame<TyDst, TySrc>:
|
||
std::is_same<TyDst, TySrc>
|
||
{
|
||
};
|
||
|
||
//ºóÕß²ÎÊý°üÊÇ·ñÒª²»Ã»ÓвÎÊý£¬Òª²»Ö»ÓÐÒ»¸ö²¢ÇÒÈ¥³ýÒýÓó£ÊýÒ×±äºóΪǰÕß
|
||
template<typename TyDst, typename ...TySrc_S>
|
||
struct IsNoneOrRemoveCVRefSame:
|
||
std::integral_constant<bool, sizeof...(TySrc_S)==0>
|
||
{
|
||
};
|
||
template<typename TyDst, typename TySrc>
|
||
struct IsNoneOrRemoveCVRefSame<TyDst, TySrc>:
|
||
IsRemoveCVRefSame<TyDst, TySrc>
|
||
{
|
||
};
|
||
|
||
|
||
//²âÊÔÊÇ·ñΪµü´úÆ÷
|
||
template<class Ty, class= void>
|
||
struct IsIteratorType:
|
||
std::false_type
|
||
{
|
||
};
|
||
template<class Ty>
|
||
struct IsIteratorType<Ty, typename ParamValidTester<
|
||
typename std::iterator_traits<Ty>::iterator_category>::type
|
||
>: std::true_type
|
||
{
|
||
};
|
||
|
||
|
||
//²âÊÔÈ¥³ý³£Ò×±äÒ×ÓÃÊôÐÔºó£¬ÊÇ·ñΪ×Ö·ûÖ¸Õ룬×Ö·ûÊý×é»òstringÀàÐÍ
|
||
template<class Ty>
|
||
struct IsRemoveCVRefSameSzOrString:
|
||
std::integral_constant<bool, IsRemoveCVRefSame<char *, Ty>::value
|
||
|| IsRemoveCVRefSame<const char *, Ty>::value
|
||
|| (std::is_array<typename RemoveCVRef<Ty>::type>::value
|
||
&& IsRemoveCVRefSame<char, typename std::remove_extent<
|
||
typename RemoveCVRef<Ty>::type>::type>::value)
|
||
|| IsRemoveCVRefSame<std::string, Ty>::value>
|
||
{
|
||
};
|
||
|
||
|
||
|
||
//Éú³Éµü´úÆ÷½âÒýÓõÄÀàÐÍ£¬±£Áô³£Ò×±äÒýÓÃÊôÐÔ
|
||
template<typename TyIt>
|
||
struct IteratorDerefType
|
||
{
|
||
using type = decltype(*std::declval<TyIt>());
|
||
};
|
||
|
||
//Éú³Éµü´úÆ÷½âÒýÓõÄÀàÐÍÔÙÈ¥³ý³£Ò×±äÒýÓÃÊôÐÔ
|
||
template<typename TyIt>
|
||
struct IteratorRemoveCVRefDerefType
|
||
{
|
||
using type = typename RemoveCVRef<typename IteratorDerefType<TyIt>::type>::type;
|
||
};
|
||
|
||
|
||
|
||
//¸ù¾ÝÌṩÀ´Ô´ÀàÐ͵ÄÒýÓᢳ£Êý¡¢Ò×±äÊôÐÔ£¬¶ÔÄ¿µÄÀàÐ͸½¼ÓͬÑùµÄÊôÐÔ
|
||
template<typename TySrc, typename TyDst>
|
||
struct TypeAttachAttribute
|
||
{
|
||
using type = TyDst;
|
||
};
|
||
//³£ÊôÐÔÌØ»¯
|
||
template<typename TySrc, typename TyDst>
|
||
struct TypeAttachAttribute<const TySrc, TyDst>
|
||
{
|
||
using type = typename std::add_const<
|
||
typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
|
||
};
|
||
//Ò×±äÊôÐÔÌØ»¯
|
||
template<typename TySrc, typename TyDst>
|
||
struct TypeAttachAttribute<volatile TySrc, TyDst>
|
||
{
|
||
using type = typename std::add_volatile<
|
||
typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
|
||
};
|
||
//×óÖµÒýÓÃÊôÐÔÌØ»¯
|
||
template<typename TySrc, typename TyDst>
|
||
struct TypeAttachAttribute<TySrc &, TyDst>
|
||
{
|
||
using type = typename std::add_lvalue_reference<
|
||
typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
|
||
};
|
||
//ÓÒÖµÒýÓÃÊôÐÔÌØ»¯
|
||
template<typename TySrc, typename TyDst>
|
||
struct TypeAttachAttribute<TySrc &&, TyDst>
|
||
{
|
||
using type = typename std::add_rvalue_reference<
|
||
typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
|
||
};
|
||
|
||
|
||
|
||
//Çóµ÷Ó÷µ»ØÖµÀàÐÍ
|
||
template<typename TyFunc, typename ...Ty_S>
|
||
struct InvokeReturnType
|
||
{
|
||
using type = decltype(std::declval<TyFunc>()(std::declval<Ty_S>()...));
|
||
};
|
||
|
||
|
||
|
||
//ÕûÊýÐòÁÐÄ£°å
|
||
template<size_t ...c_idx_s>
|
||
struct IndexSequence
|
||
{
|
||
};
|
||
template<>
|
||
struct IndexSequence<>
|
||
{
|
||
using value_type = size_t;
|
||
static constexpr size_t size()
|
||
{
|
||
return 0;
|
||
}
|
||
};
|
||
template<int c_idx, int ...c_rest_s>
|
||
struct IndexSequence<c_idx, c_rest_s...>
|
||
{
|
||
using value_type = size_t;
|
||
static constexpr size_t size()
|
||
{
|
||
return IndexSequence<c_rest_s...>::size()+1;
|
||
}
|
||
};
|
||
|
||
//ÕûÊýÄ£°åÌí¼ÓÔªËغ¯Êý
|
||
template<size_t c_new, size_t ...c_idx_s>
|
||
inline IndexSequence<c_idx_s..., c_new> AddIndexSequence(IndexSequence<c_idx_s...>)
|
||
{
|
||
return IndexSequence<c_idx_s..., c_new>();
|
||
}
|
||
|
||
//Éú³É˳ÐòµÝÔöÕûÊýÄ£°å¸¨ÖúÀà
|
||
template<size_t c_size>
|
||
struct _MakeIndexSequenceAssist
|
||
{
|
||
using type = decltype(AddIndexSequence<c_size-1>(
|
||
typename _MakeIndexSequenceAssist<c_size-1>::type()));
|
||
};
|
||
template<>
|
||
struct _MakeIndexSequenceAssist<0>
|
||
{
|
||
using type = IndexSequence<>;
|
||
};
|
||
//Éú³É˳ÐòµÝÔöÕûÊýÄ£°åÀà
|
||
template<size_t c_size>
|
||
using MakeIndexSequence = typename _MakeIndexSequenceAssist<c_size>::type;
|
||
|
||
|
||
|
||
//Ä£°å¶¨³¤ÕûÐÎ
|
||
template<bool c_bSigned, int c_size>
|
||
struct TemplateInt
|
||
{
|
||
};
|
||
template<>
|
||
struct TemplateInt<true, 1>
|
||
{
|
||
using type = int8_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<false, 1>
|
||
{
|
||
using type = uint8_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<true, 2>
|
||
{
|
||
using type = int16_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<false, 2>
|
||
{
|
||
using type = uint16_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<true, 4>
|
||
{
|
||
using type = int32_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<false, 4>
|
||
{
|
||
using type = uint32_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<true, 8>
|
||
{
|
||
using type = int64_t;
|
||
};
|
||
template<>
|
||
struct TemplateInt<false, 8>
|
||
{
|
||
using type = uint64_t;
|
||
};
|
||
|
||
|
||
|
||
//¹ãÒåµÄ±È½Ïº¯ÊýÀà
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralLess
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1<arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralEqualTo
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1==arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralLessEqual
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1<=arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralGreater
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1>arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralGreaterEqual
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1>=arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct GeneralNotEqualTo
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1!=arg2;
|
||
}
|
||
};
|
||
|
||
|
||
//À©Õ¹µÄ¹ãÒå±È½Ïº¯ÊýÀ࣬ʹÓÃСÓں͵ÈÓÚ²Ù×÷ÔËËã
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGeneralLessEqual
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return arg1<arg2 || arg1==arg2;
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGeneralGreater
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !(arg1<arg2 || arg1==arg2);
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGeneralGreaterEqual
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !(arg1<arg2);
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGeneralNotEqualTo
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !(arg1==arg2);
|
||
}
|
||
};
|
||
|
||
|
||
//±È½ÏÀàÐ͵ĺ¯Êý·â×°
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
using CompareType = std::function<bool(const Ty1 &, const Ty2 &)>;
|
||
|
||
|
||
//±È½ÏÀຯÊýÀ©Õ¹£¬Ê¹ÓÃСÓں͵ÈÓÚº¯Êý
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendLessEqualWrap
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
public:
|
||
CompareType<Ty1, Ty2> funcLT;
|
||
CompareType<Ty1, Ty2> funcEQ;
|
||
public:
|
||
explicit ExtendLessEqualWrap(const CompareType<Ty1, Ty2> &o_funcLT,
|
||
const CompareType<Ty1, Ty2> &o_funcEQ)
|
||
:
|
||
funcLT(o_funcLT), funcEQ(o_funcEQ)
|
||
{
|
||
}
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return funcLT(arg1, arg2) || funcEQ(arg1, arg2);
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGreaterWrap
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
public:
|
||
CompareType<Ty1, Ty2> funcLT;
|
||
CompareType<Ty1, Ty2> funcEQ;
|
||
public:
|
||
explicit ExtendGreaterWrap(const CompareType<Ty1, Ty2> &o_funcLT,
|
||
const CompareType<Ty1, Ty2> &o_funcEQ)
|
||
:
|
||
funcLT(o_funcLT), funcEQ(o_funcEQ)
|
||
{
|
||
}
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !(funcLT(arg1, arg2) || funcEQ(arg1, arg2));
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendGreaterEqualWrap
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
public:
|
||
CompareType<Ty1, Ty2> funcLT;
|
||
CompareType<Ty1, Ty2> funcEQ;
|
||
public:
|
||
explicit ExtendGreaterEqualWrap(const CompareType<Ty1, Ty2> &o_funcLT,
|
||
const CompareType<Ty1, Ty2> &o_funcEQ)
|
||
:
|
||
funcLT(o_funcLT), funcEQ(o_funcEQ)
|
||
{
|
||
}
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !funcLT(arg1, arg2);
|
||
}
|
||
};
|
||
template<typename Ty1, typename Ty2= Ty1>
|
||
struct ExtendNotEqualToWrap
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty1 first_argument_type;
|
||
typedef Ty2 second_argument_type;
|
||
public:
|
||
CompareType<Ty1, Ty2> funcLT;
|
||
CompareType<Ty1, Ty2> funcEQ;
|
||
public:
|
||
explicit ExtendNotEqualToWrap(const CompareType<Ty1, Ty2> &o_funcLT,
|
||
const CompareType<Ty1, Ty2> &o_funcEQ)
|
||
:
|
||
funcLT(o_funcLT), funcEQ(o_funcEQ)
|
||
{
|
||
}
|
||
result_type operator()(const first_argument_type &arg1,
|
||
const second_argument_type &arg2) const
|
||
{
|
||
return !funcEQ(arg1, arg2);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
//´æ´¢Ä³ÀàÐÍ£¬¿ÉÒÔΪֵ»òÒýÓ㬶Ը÷ÖÖÇé¿öÒѽøÐÐÌØ»¯
|
||
//ÖµÀàÐÍÌØ»¯
|
||
template<typename Ty>
|
||
struct TypeHolder
|
||
{
|
||
Ty hold;
|
||
public:
|
||
//¹¹Ôì
|
||
TypeHolder(const Ty &o_hold):
|
||
hold(o_hold)
|
||
{
|
||
}
|
||
TypeHolder(Ty &&o_hold):
|
||
hold(std::move(o_hold))
|
||
{
|
||
}
|
||
};
|
||
//×óÖµÒýÓÃÌØ»¯
|
||
template<typename Ty>
|
||
struct TypeHolder<Ty &>
|
||
{
|
||
Ty &hold;
|
||
public:
|
||
//¹¹Ôì
|
||
TypeHolder(Ty &o_hold):
|
||
hold(o_hold)
|
||
{
|
||
}
|
||
};
|
||
//ÓÒÖµÒýÓÃÌØ»¯
|
||
template<typename Ty>
|
||
struct TypeHolder<Ty &&>
|
||
{
|
||
Ty &&hold;
|
||
public:
|
||
//¹¹Ôì
|
||
TypeHolder(Ty &&o_hold):
|
||
hold(std::move(o_hold))
|
||
{
|
||
}
|
||
};
|
||
|
||
|
||
|
||
//´æ´¢Ä³ÖµÀàÐÍ£¬²»ÄÜΪÒýÓã¬ÀàÐÍÖ§³Övoid
|
||
template<typename Ty>
|
||
struct ValueHolder
|
||
{
|
||
public:
|
||
using RefType = Ty &;
|
||
using ConstRefType = const Ty &;
|
||
using PtrType = Ty *;
|
||
using ConstPtrType = const Ty *;
|
||
public:
|
||
Ty hold;
|
||
public:
|
||
//Ä£°å¹¹Ôì
|
||
template<typename ...Ty_S>
|
||
explicit ValueHolder(Ty_S &&...args):
|
||
hold(std::forward<Ty_S>(args)...)
|
||
{
|
||
}
|
||
};
|
||
//voidÌØ»¯
|
||
template<>
|
||
struct ValueHolder<void>
|
||
{
|
||
using RefType = void;
|
||
using ConstRefType = void;
|
||
using PtrType = void;
|
||
using ConstPtrType = void;
|
||
};
|
||
|
||
|
||
|
||
//**********************
|
||
//ÀàÐͳÉÔ±»ò¸¨Öúº¯ÊýÀ©Õ¹
|
||
//**********************
|
||
|
||
//µ÷ÓñäÁ¿µÄÎö¹¹º¯Êý
|
||
template<typename Ty>
|
||
inline void CallDestruct(Ty &value)
|
||
{
|
||
value.~Ty();
|
||
}
|
||
|
||
//µ÷ÓñäÁ¿µÄ¹¹Ô캯Êý£¬ÒªÇó±äÁ¿ÒѾÎö¹¹
|
||
template<typename Ty, typename ...Ty_S>
|
||
inline void CallConstruct(Ty &value, Ty_S &&...arg_s)
|
||
{
|
||
new(&value) Ty(std::forward<Ty_S>(arg_s)...);
|
||
}
|
||
|
||
//µ÷ÓñäÁ¿µÄÎö¹¹º¯ÊýºÍ¹¹Ô캯Êý
|
||
template<typename Ty, typename ...Ty_S>
|
||
inline void CallRestruct(Ty &value, Ty_S &&...arg_s)
|
||
{
|
||
CallDestruct(value);
|
||
CallConstruct(value, std::forward<Ty_S>(arg_s)...);
|
||
}
|
||
|
||
|
||
|
||
//ÌáÈ¡±äÁ¿µÄ×óÖµÒýÓÃ
|
||
template<typename Ty>
|
||
inline Ty &GetLref(Ty &&value)
|
||
{
|
||
return value;
|
||
}
|
||
//ÌáÈ¡±äÁ¿µÄ³£×óÖµÒýÓÃ
|
||
template<typename Ty>
|
||
inline const Ty &GetConstLref(Ty &&value)
|
||
{
|
||
return value;
|
||
}
|
||
|
||
|
||
//¶Ô±äÁ¿½øÐÐÖµ¿½±´
|
||
template<typename Ty>
|
||
inline Ty GetValueCopy(const Ty &value)
|
||
{
|
||
return Ty(value);
|
||
}
|
||
|
||
|
||
|
||
//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬×Ö·ûÖ¸ÕëÖØÔØ
|
||
inline std::string OverrideSzToStr(const char *sz)
|
||
{
|
||
return std::string(sz);
|
||
}
|
||
inline std::string OverrideSzToStr(char *sz)
|
||
{
|
||
return std::string(sz);
|
||
}
|
||
//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬×Ö·ûÊý×éÖØÔØ
|
||
template<typename Ty>
|
||
inline typename std::enable_if<std::is_array<typename RemoveCVRef<Ty>::type>::value
|
||
&& IsRemoveCVRefSame<char, typename std::remove_extent<
|
||
typename RemoveCVRef<Ty>::type>::type>::value, std::string
|
||
>::type OverrideSzToStr(Ty &&sz)
|
||
{
|
||
return std::string(std::forward<Ty>(sz));
|
||
}
|
||
//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬ÆäÓàÇé¿öÖØÔØ
|
||
template<typename Ty>
|
||
inline Ty &&OverrideSzToStr(Ty &&arg)
|
||
{
|
||
return std::forward<Ty>(arg);
|
||
}
|
||
|
||
|
||
|
||
//ÕûÐαȽϸ¨Öúºê
|
||
#define _IS_INT_TYPE(Ty1, Ty2) \
|
||
(std::is_integral<Ty1>::value && std::is_integral<Ty2>::value)
|
||
#define _INT_SIGN_UNSIGN(Ty1, Ty2) \
|
||
((std::is_integral<Ty1>::value && std::is_signed<Ty1>::value)\
|
||
&& std::is_unsigned<Ty2>::value)
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«ÅжÏСÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty1, Ty2), bool
|
||
>::type IntLT(Ty1 num1, Ty2 num2)
|
||
{
|
||
return (num1<0) ? (true)
|
||
: (static_cast<typename std::make_unsigned<Ty1>::type>(num1)<num2);
|
||
}
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty2, Ty1), bool
|
||
>::type IntLT(Ty1 num1, Ty2 num2)
|
||
{
|
||
return (num2<0) ? (false)
|
||
: (num1<static_cast<typename std::make_unsigned<Ty2>::type>(num2));
|
||
}
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2)
|
||
&& !_INT_SIGN_UNSIGN(Ty1, Ty2) && !_INT_SIGN_UNSIGN(Ty2, Ty1), bool
|
||
>::type IntLT(Ty1 num1, Ty2 num2)
|
||
{
|
||
return num1<num2;
|
||
}
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«ÅжϵÈÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty1, Ty2), bool
|
||
>::type IntEQ(Ty1 num1, Ty2 num2)
|
||
{
|
||
return (num1<0) ? (false)
|
||
: (static_cast<typename std::make_unsigned<Ty1>::type>(num1)==num2);
|
||
}
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty2, Ty1), bool
|
||
>::type IntEQ(Ty1 num1, Ty2 num2)
|
||
{
|
||
return (num2<0) ? (false)
|
||
: (num1==static_cast<typename std::make_unsigned<Ty2>::type>(num2));
|
||
}
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2)
|
||
&& !_INT_SIGN_UNSIGN(Ty1, Ty2) && !_INT_SIGN_UNSIGN(Ty2, Ty1), bool
|
||
>::type IntEQ(Ty1 num1, Ty2 num2)
|
||
{
|
||
return num1==num2;
|
||
}
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«ÅжÏСÓÚµÈÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
|
||
>::type IntLTE(Ty1 num1, Ty2 num2)
|
||
{
|
||
return IntLT(num1, num2) || IntEQ(num1, num2);
|
||
}
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«ÅжϴóÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
|
||
>::type IntGT(Ty1 num1, Ty2 num2)
|
||
{
|
||
return !(IntLT(num1, num2) || IntEQ(num1, num2));
|
||
}
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«ÅжϴóÓÚµÈÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
|
||
>::type IntGTE(Ty1 num1, Ty2 num2)
|
||
{
|
||
return !IntLT(num1, num2);
|
||
}
|
||
|
||
//ÕûÐÎÀàÐÍ°²È«Åжϲ»µÈÓÚ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
|
||
>::type IntNEQ(Ty1 num1, Ty2 num2)
|
||
{
|
||
return !IntEQ(num1, num2);
|
||
}
|
||
#undef _IS_INT_TYPE
|
||
#undef _INT_SIGN_UNSIGN
|
||
|
||
|
||
|
||
//¸¡µãÊý±È½Ï¸¨Öúºê
|
||
#define _FLOAT_DEFAULT_ULP 10
|
||
#define _FLOAT_DEFAULT_ABS_MODE true
|
||
#define _IS_FLOAT_TYPE(Ty1, Ty2) \
|
||
(std::is_floating_point<Ty1>::value && std::is_floating_point<Ty2>::value)
|
||
#define _FLOAT_COMMON_EPSILON(Ty1, Ty2) \
|
||
(std::max(std::numeric_limits<Ty1>::epsilon(), std::numeric_limits<Ty2>::epsilon()))
|
||
#define _FLOAT_COMMON_MIN(Ty1, Ty2) \
|
||
(std::max(std::numeric_limits<Ty1>::min(), std::numeric_limits<Ty2>::min()))
|
||
#define _FLOAT_ABS(num) ((num)>=0? (num):-(num))
|
||
|
||
//¸¡µãÊý±È½ÏÏàµÈ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatEQ(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return bAbs ?
|
||
(_FLOAT_ABS(num1-num2)<_FLOAT_COMMON_EPSILON(Ty1, Ty2)*ulp)
|
||
:
|
||
(_FLOAT_ABS(num1-num2)<_FLOAT_COMMON_EPSILON(Ty1, Ty2)
|
||
*(_FLOAT_ABS(num1)+_FLOAT_ABS(num2))*ulp
|
||
|| _FLOAT_ABS(num1-num2)<_FLOAT_COMMON_MIN(Ty1, Ty2)*ulp);
|
||
}
|
||
|
||
//¸¡µãÊý±È½ÏСÓÚ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatLT(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return num1<num2 && !FloatEQ(num1, num2, bAbs, ulp);
|
||
}
|
||
|
||
//¸¡µãÊý±È½ÏСÓÚµÈÓÚ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatLTE(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return FloatLT(num1, num2, bAbs, ulp) || FloatEQ(num1, num2, bAbs, ulp);
|
||
}
|
||
|
||
//¸¡µãÊý±È½Ï´óÓÚ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatGT(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return !(FloatLT(num1, num2, bAbs, ulp) || FloatEQ(num1, num2, bAbs, ulp));
|
||
}
|
||
|
||
//¸¡µãÊý±È½Ï´óÓÚµÈÓÚ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatGTE(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return !FloatLT(num1, num2, bAbs, ulp);
|
||
}
|
||
|
||
//¸¡µãÊý±È½Ï²»µÈÓÚ£¬±£Ö¤Âß¼¹Øϵ
|
||
template<typename Ty1, typename Ty2>
|
||
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
|
||
>::type FloatNEQ(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
return !FloatEQ(num1, num2, bAbs, ulp);
|
||
}
|
||
|
||
|
||
//¸¡µãÊýÏÂת»¯ÕûÊý
|
||
template<typename Ty>
|
||
inline typename std::enable_if<std::is_floating_point<Ty>::value, Ty
|
||
>::type FloatFloor(Ty num, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
Ty res = std::round(num);
|
||
if(FloatEQ(num, res, bAbs, ulp))
|
||
return res;
|
||
return std::floor(num);
|
||
}
|
||
|
||
//¸¡µãÊýÉÏת»¯ÕûÊý
|
||
template<typename Ty>
|
||
inline typename std::enable_if<std::is_floating_point<Ty>::value, Ty
|
||
>::type FloatCeil(Ty num, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
|
||
{
|
||
Ty res = std::round(num);
|
||
if(FloatEQ(num, res, bAbs, ulp))
|
||
return res;
|
||
return std::ceil(num);
|
||
}
|
||
#undef _FLOAT_DEFAULT_ULP
|
||
#undef _IS_FLOAT_TYPE
|
||
#undef _FLOAT_COMMON_EPSILON
|
||
#undef _FLOAT_COMMON_MIN
|
||
#undef _FLOAT_ABS
|
||
|
||
|
||
|
||
//stringµÄÀÛ¼Ó²Ù×÷£¬Ê¹ÓÃ×óÒÆÔËËã·û
|
||
template<typename Ele, typename Ty>
|
||
inline std::string &operator <<(std::basic_string<Ele> &str, Ty &&arg)
|
||
{
|
||
return str += std::forward<Ty>(arg);
|
||
}
|
||
|
||
|
||
|
||
//·¶Î§ÄÚ×ÖµäÐò±È½Ï²Ù×÷£¬Ê¹Óõü´úÆ÷£¬Ð¡ÓÚµÈÓÚ´óÓڷֱ𷵻Ø-1,0,1
|
||
template<typename TyIt1, typename TyIt2,
|
||
typename TyLess= GeneralLess<typename IteratorRemoveCVRefDerefType<TyIt1>::type,
|
||
typename IteratorRemoveCVRefDerefType<TyIt2>::type>,
|
||
typename TyEqual= GeneralEqualTo<typename IteratorRemoveCVRefDerefType<TyIt1>::type,
|
||
typename IteratorRemoveCVRefDerefType<TyIt2>::type>
|
||
> inline int SequenceCompare(TyIt1 st1, TyIt1 ed1, TyIt2 st2, TyIt2 ed2,
|
||
TyLess funcLess= TyLess(), TyEqual funcEqual= TyEqual())
|
||
{
|
||
for(; ; ++st1, ++st2) {
|
||
//ÅжϽáÊøÌõ¼þ
|
||
if(st1==ed1) {
|
||
if(st2==ed2)
|
||
return 0;
|
||
else
|
||
return -1;
|
||
}
|
||
else if(st2==ed2)
|
||
return 1;
|
||
//ÅжϴóС
|
||
if(funcLess(*st1, *st2))
|
||
return -1;
|
||
else if(!(funcEqual(*st1, *st2)))
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//¼ì²éÊÇ·ñΪtupleÀà
|
||
template<typename Ty>
|
||
struct IsTupleType:
|
||
std::false_type
|
||
{
|
||
};
|
||
template<typename ...Ty_S>
|
||
struct IsTupleType<std::tuple<Ty_S...>>:
|
||
std::true_type
|
||
{
|
||
};
|
||
|
||
|
||
//tupleÀàÐÍת»»À©Õ¹¸¨Öúº¯Êý
|
||
template<typename TyDst, typename TySrc, size_t ...c_idx_s>
|
||
inline TyDst _TupleCastAssist(TySrc &&src, IndexSequence<c_idx_s...>)
|
||
{
|
||
return TyDst(std::get<c_idx_s>(std::forward<TySrc>(src))...);
|
||
}
|
||
//tupleÀàÐÍת»»À©Õ¹£¬Ö±½ÓÍêÃÀת·¢ÒÔÖ§³ÖËùÓеÄÒýÓÃÇé¿ö£¬ÈôÐèÓÒÖµÔò½«tupleÒÔÓÒÖµ´«Èë
|
||
//Ô´ÀàÐÍÐèÒªÄܱ»getº¯Êý²ð½â£¬Ä¿µÄÀàÐÍÐèÒªÄܽÓÊÜÔ´ÀàÐͲð½âºóµÄ¹¹Ô캯Êý
|
||
template<typename TyDst, typename TySrc>
|
||
inline TyDst TupleCast(TySrc &&src)
|
||
{
|
||
return _TupleCastAssist<TyDst>(std::forward<TySrc>(src), MakeIndexSequence<
|
||
std::tuple_size<typename std::remove_reference<TySrc>::type>::value>());
|
||
}
|
||
|
||
|
||
|
||
//tupleÀàÐ͵÷Óú¯Êý·µ»ØÖµÀàÐ͸¨ÖúÀàÐÍ
|
||
template<typename TyFunc, typename TyTup, typename TyIdx>
|
||
struct _TupleInvokeReturnTypeAssist
|
||
{
|
||
};
|
||
template<typename TyFunc, typename TyTup, size_t ...c_idx_s>
|
||
struct _TupleInvokeReturnTypeAssist<TyFunc, TyTup, IndexSequence<c_idx_s...>>
|
||
{
|
||
using type = decltype(std::declval<TyFunc>()(std::get<c_idx_s>(std::declval<TyTup>())...));
|
||
};
|
||
//tupleÀàÐ͵÷Óú¯Êý·µ»ØÖµÀàÐÍ£¬Ê¹ÓôøcvrefµÄÀàÐÍ´«Èë
|
||
template<typename TyFunc, typename TyTup>
|
||
struct TupleInvokeReturnType
|
||
{
|
||
using type = typename _TupleInvokeReturnTypeAssist<TyFunc, TyTup, MakeIndexSequence<
|
||
std::tuple_size<typename std::remove_reference<TyTup>::type>::value>>::type;
|
||
};
|
||
|
||
//tupleÀàÐ͵÷Óú¯Êý¸¨Öúº¯Êý
|
||
template<typename TyFunc, typename TyTup, size_t ...c_idx_s>
|
||
inline typename TupleInvokeReturnType<TyFunc &&, TyTup &&
|
||
>::type _TupleInvokeAssist(TyFunc &&func, TyTup &&tup, IndexSequence<c_idx_s...>)
|
||
{
|
||
return std::forward<TyFunc>(func)(std::get<c_idx_s>(std::forward<TyTup>(tup))...);
|
||
}
|
||
//tupleÀàÐ͵÷Óú¯Êý£¬±¾ÖÊÉÏÖ»ÒªÄܱ»getº¯Êý²ð½â¼´¿É£¬ÈôÐèÓÒÖµÔò½«tupleÒÔÓÒÖµ´«Èë
|
||
template<typename TyFunc, typename TyTup>
|
||
inline typename TupleInvokeReturnType<TyFunc &&, TyTup &&
|
||
>::type TupleInvoke(TyFunc &&func, TyTup &&tup)
|
||
{
|
||
return _TupleInvokeAssist(std::forward<TyFunc>(func), std::forward<TyTup>(tup),
|
||
MakeIndexSequence<std::tuple_size<typename std::remove_reference<TyTup>::type>::value>());
|
||
}
|
||
|
||
|
||
|
||
//hashµ÷Óú¯Êý
|
||
template<typename Ty>
|
||
inline auto HashFunc(Ty &&arg)->
|
||
decltype(std::hash<typename RemoveCVRef<Ty>::type>()(std::forward<Ty>(arg)))
|
||
{
|
||
return std::hash<typename RemoveCVRef<Ty>::type>()(std::forward<Ty>(arg));
|
||
}
|
||
|
||
|
||
//hashµÄÌØÀý»¯
|
||
namespace std
|
||
{
|
||
//¶ÔpairÌØÀý»¯£¬Ã»Óн»»»²»±äÐÔ£¬Óëtuple¼æÈÝ
|
||
template<typename Ty1, typename Ty2>
|
||
struct hash<std::pair<Ty1, Ty2>>
|
||
{
|
||
typedef size_t result_type;
|
||
typedef std::pair<Ty1, Ty2> argument_type;
|
||
result_type operator()(const argument_type &pr) const
|
||
{
|
||
return HashFunc(HashFunc(pr.first))
|
||
^ HashFunc(pr.second);
|
||
}
|
||
};
|
||
|
||
//¶ÔtupleÌØÀý»¯£¬Ã»Óн»»»²»±äÐÔ
|
||
template<typename ...Tys>
|
||
struct hash<std::tuple<Tys...>>
|
||
{
|
||
typedef size_t result_type;
|
||
typedef std::tuple<Tys...> argument_type;
|
||
result_type operator()(const argument_type &tup) const
|
||
{
|
||
return Assist<sizeof...(Tys)>(tup);
|
||
}
|
||
private:
|
||
template<size_t c_index>
|
||
static typename std::enable_if<c_index>=2, result_type
|
||
>::type Assist(const std::tuple<Tys...> &tup)
|
||
{
|
||
return HashFunc(Assist<c_index-1>(tup))
|
||
^ HashFunc(std::get<c_index-1>(tup));
|
||
}
|
||
template<size_t c_index>
|
||
static typename std::enable_if<c_index==1, result_type
|
||
>::type Assist(const std::tuple<Tys...> &tup)
|
||
{
|
||
return HashFunc(std::get<0>(tup));
|
||
}
|
||
template<size_t c_index>
|
||
static typename std::enable_if<c_index==0, result_type
|
||
>::type Assist(const std::tuple<Tys...> &tup)
|
||
{
|
||
return 0;
|
||
}
|
||
};
|
||
}
|
||
|
||
|
||
//¸÷Ààµü´úÆ÷hashÀ࣬βºóµü´úÆ÷½âÒýÓò»°²È«
|
||
template<typename Ty>
|
||
struct IteratorHash
|
||
{
|
||
typedef size_t result_type;
|
||
typedef Ty argument_type;
|
||
result_type operator()(argument_type it) const
|
||
{
|
||
return std::hash<decltype(&*it)>()(&*it);
|
||
}
|
||
};
|
||
|
||
|
||
|
||
//¸÷Ààµü´úÆ÷±È½ÏÀ࣬βºóµü´úÆ÷½âÒýÓò»°²È«
|
||
template<typename Ty>
|
||
struct IteratorLess
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty first_argument_type;
|
||
typedef Ty second_argument_type;
|
||
result_type operator()(const first_argument_type &it1,
|
||
const second_argument_type &it2) const
|
||
{
|
||
return &*it1<&*it2;
|
||
}
|
||
};
|
||
template<typename Ty>
|
||
struct IteratorEuqalTo
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty first_argument_type;
|
||
typedef Ty second_argument_type;
|
||
result_type operator()(const first_argument_type &it1,
|
||
const second_argument_type &it2) const
|
||
{
|
||
return &*it1==&*it2;
|
||
}
|
||
};
|
||
|
||
|
||
//¸÷Ààµü´úÆ÷½âÒýÓÃÖµ±È½ÏÀà
|
||
template<typename Ty>
|
||
struct IteratorDerefLess
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty first_argument_type;
|
||
typedef Ty second_argument_type;
|
||
result_type operator()(const first_argument_type &it1,
|
||
const second_argument_type &it2) const
|
||
{
|
||
return *it1<*it2;
|
||
}
|
||
};
|
||
template<typename Ty>
|
||
struct IteratorDerefEuqalTo
|
||
{
|
||
typedef bool result_type;
|
||
typedef Ty first_argument_type;
|
||
typedef Ty second_argument_type;
|
||
result_type operator()(const first_argument_type &it1,
|
||
const second_argument_type &it2) const
|
||
{
|
||
return *it1==*it2;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
//×Ö·ûÊý×ÖÅжÏ
|
||
inline constexpr bool IsNumChar(char ch)
|
||
{
|
||
return ch>='0' && ch<='9';
|
||
}
|
||
inline constexpr bool IsNotNumChar(char ch)
|
||
{
|
||
return !IsNumChar(ch);
|
||
}
|
||
//×Ö·û´óд×ÖĸÅжÏ
|
||
inline constexpr bool IsUppChar(char ch)
|
||
{
|
||
return (ch>='A' && ch<='Z');
|
||
}
|
||
inline constexpr bool IsNotUppChar(char ch)
|
||
{
|
||
return !IsUppChar(ch);
|
||
}
|
||
//×Ö·û´óд×ÖĸÅжÏ
|
||
inline constexpr bool IsLowChar(char ch)
|
||
{
|
||
return (ch>='a' && ch<='z');
|
||
}
|
||
inline constexpr bool IsNotLowChar(char ch)
|
||
{
|
||
return !IsLowChar(ch);
|
||
}
|
||
//×Ö·û×ÖĸÅжÏ
|
||
inline constexpr bool IsLetChar(char ch)
|
||
{
|
||
return IsUppChar(ch) || IsLowChar(ch);
|
||
}
|
||
inline constexpr bool IsNotLetChar(char ch)
|
||
{
|
||
return !IsLetChar(ch);
|
||
}
|
||
//×Ö·ûÊý×Ö×ÖĸÅжÏ
|
||
inline constexpr bool IsNumLetChar(char ch)
|
||
{
|
||
return IsNumChar(ch) || IsLetChar(ch);
|
||
}
|
||
inline constexpr bool IsNotNumLetChar(char ch)
|
||
{
|
||
return !IsNumLetChar(ch);
|
||
}
|
||
//×Ö·û±êʶ·ûÅжÏ
|
||
inline constexpr bool IsIdChar(char ch)
|
||
{
|
||
return IsNumLetChar(ch) || (ch=='_');
|
||
}
|
||
inline constexpr bool IsNotIdChar(char ch)
|
||
{
|
||
return !IsIdChar(ch);
|
||
}
|
||
//×Ö·ûÊ®Áù½øÖÆÅжÏ
|
||
inline constexpr bool IsHexChar(char ch)
|
||
{
|
||
return (ch>='0' && ch<='9')
|
||
|| (ch>='a' && ch<='f') || (ch>='A' && ch<='F');
|
||
}
|
||
inline constexpr bool IsNotHexChar(char ch)
|
||
{
|
||
return !IsHexChar(ch);
|
||
}
|
||
//×Ö·ûasciiÅжÏ
|
||
inline constexpr bool IsAsciiChar(char ch)
|
||
{
|
||
return ch>=0x00 && ch<=0x7F;
|
||
}
|
||
inline constexpr bool IsNotAsciiChar(char ch)
|
||
{
|
||
return !IsAsciiChar(ch);
|
||
}
|
||
//×Ö·û¹ãÒå±êʶ·ûÅжÏ
|
||
inline constexpr bool IsBroadIdChar(char ch)
|
||
{
|
||
return IsIdChar(ch) || IsNotAsciiChar(ch);
|
||
}
|
||
inline constexpr bool IsNotBroadIdChar(char ch)
|
||
{
|
||
return !IsBroadIdChar(ch);
|
||
}
|
||
//×Ö·û¿Õ°×·ûÅжÏ
|
||
inline constexpr bool IsBlankChar(char ch)
|
||
{
|
||
return ch==' ' || ch=='\t' || ch=='\r' || ch=='\n'
|
||
|| ch=='\v' || ch=='\f';
|
||
}
|
||
inline constexpr bool IsNotBlankChar(char ch)
|
||
{
|
||
return !IsBlankChar(ch);
|
||
}
|
||
|
||
|
||
//Сд×Öĸת»»´óд×Öĸ
|
||
inline constexpr char LowCharToUppChar(char ch)
|
||
{
|
||
return (char)
|
||
(IsLowChar(ch) ?
|
||
'A'+(ch-'a')
|
||
:
|
||
ch);
|
||
}
|
||
//´óд×ÖĸתСд×Öĸ
|
||
inline constexpr char UppCharToLowChar(char ch)
|
||
{
|
||
return (char)
|
||
(IsUppChar(ch) ?
|
||
'a'+(ch-'A')
|
||
:
|
||
ch);
|
||
}
|
||
|
||
|
||
//Êý×Ö×Ö·ûת»¯Êý×Ö
|
||
inline constexpr int NumCharToNum(char ch)
|
||
{
|
||
return IsNumChar(ch) ?
|
||
ch-'0'
|
||
:
|
||
-1;
|
||
}
|
||
//×Öĸ×Ö·ûת»¯Êý×Ö
|
||
inline constexpr int LetCharToNum(char ch)
|
||
{
|
||
return IsLowChar(ch) ?
|
||
ch-'a'
|
||
: IsUppChar(ch) ?
|
||
ch-'A'
|
||
:
|
||
-1;
|
||
}
|
||
//Ê®Áù½øÖÆ×Ö·ûת»¯Êý×Ö
|
||
inline constexpr int HexCharToNum(char ch)
|
||
{
|
||
return (ch>='0' && ch<='9') ?
|
||
ch-'0'
|
||
: (ch>='a' && ch<='f') ?
|
||
ch-'a'+10
|
||
: (ch>='A' && ch<='F') ?
|
||
ch-'A'+10
|
||
:
|
||
-1;
|
||
}
|
||
|
||
|
||
//Êý×Öת»¯Êý×Ö×Ö·û
|
||
inline constexpr char NumToNumChar(int i)
|
||
{
|
||
return (char)
|
||
((i>=0 && i<=9) ?
|
||
i+'0'
|
||
:
|
||
0);
|
||
}
|
||
//Êý×Öת»¯´óд×Öĸ×Ö·û
|
||
inline constexpr char NumToUppChar(int i)
|
||
{
|
||
return (char)
|
||
((i>=0 && i<=25) ?
|
||
i+'A'
|
||
:
|
||
0);
|
||
}
|
||
//Êý×Öת»¯Ð¡Ð´×Öĸ×Ö·û
|
||
inline constexpr char NumToLowChar(int i)
|
||
{
|
||
return (char)
|
||
((i>=0 && i<=25) ?
|
||
i+'a'
|
||
:
|
||
0);
|
||
}
|
||
//Êý×Öת»¯´óдʮÁù½øÖÆ×Ö·û
|
||
inline constexpr char NumToUppHexChar(int i)
|
||
{
|
||
return (char)
|
||
((i>=0 && i<=9) ?
|
||
i+'0'
|
||
: (i>=10 && i<=15) ?
|
||
i+'A'
|
||
:
|
||
0);
|
||
}
|
||
//Êý×Öת»¯Ð¡Ð´Ê®Áù½øÖÆ×Ö·û
|
||
inline constexpr char NumToLowHexChar(int i)
|
||
{
|
||
return (char)
|
||
((i>=0 && i<=9) ?
|
||
i+'0'
|
||
: (i>=10 && i<=15) ?
|
||
i+'a'
|
||
:
|
||
0);
|
||
}
|
||
|