软件架构设计之Utility模块——string

YKString类是对STL 中的std::wstring的功能扩展，没有什么好解释的了，就直接看代码吧。

头文件：

class YKString : public std::wstring
{
public:
  typedef std::wstring::size_type size_type;

  YKString() : std::wstring() {}
  YKString(const std::wstring& str, size_type pos = 0, size_type n = npos)
    : std::wstring(str, pos, n) {}
  YKString(const value_type* str) : std::wstring(str) {}
  YKString(const value_type* str, size_type n) : std::wstring(str, n) {}
  YKString(size_type n, value_type val) : std::wstring(n, val) {}
  YKString(value_type ch) : std::wstring(1, ch) {}
  YKString(const std::string& str) { Assign(str.c_str()); }
  YKString(const YK_CHAR* str) { Assign(str); }

  template <class InputIter>
  YKString(InputIter fIter, InputIter lIter) : std::wstring(fIter, lIter) { }

  ~YKString() {}

  YKString& operator= (const value_type str)
  { assign(1, str); return *this; }
  YKString& operator= (const value_type* str)
  { assign(str); return *this; }
  YKString& operator= (const std::wstring& str)
  { assign(str.c_str()); return *this; }
  YKString& operator= (const std::string& str)
  { Assign(str.c_str()); return *this; }
  YKString& operator= (const YK_CHAR* str)
  { Assign(str); return *this; }

  YKString& operator+= (const YKString& str) 
  { return (*this += str.c_str());}
  YKString& operator+= (const value_type* str)
  { append(str); return *this; }

//////////////////////////////////////////////////////////////////////////
//  非变更操作

  // 指定pos的字符是否为小写字母、pos==npos则是否全为小写字母
  YK_BOOL IsLower(size_type pos = npos) const;
  // 指定pos的字符是否为大写字母、pos==npos则是否全为大写字母
  YK_BOOL IsUpper(size_type pos = npos) const;
  // 指定pos的字符是否为数字、pos==npos则是否全为数字
  YK_BOOL IsNumeric(size_type pos = npos) const;
  // 指定pos的字符是否为字母（不分大小写）、pos==npos则是否全为字母（不分大小写）
  YK_BOOL IsAlpha(size_type pos = npos) const;
  // 指定pos的字符是否为字母或数字、pos==npos则是否全为字母或数字
  YK_BOOL IsAlnum(size_type pos = npos) const;
  // 指定pos的字符是否为空白字符、pos==npos则是否全为空白字符
  YK_BOOL IsBlank(size_type pos = npos) const;
  // 忽略大小写的比较两个字符串
  YK_INT iCompare(const YKString& rhs) const;

  // know-C++
  // 意义是将*this设置为const，即将this指针指向用来调用该成员函数的对象设置为const，那么该成员函数不可以修改这个对象
  // const成员函数只能调用const成员函数，不能调用非const成员函数
  // const成员函数可以调用成员变量，但是不能修改成员变量
  // const成员函数可以修改mutable修饰的成员变量；如果成员变量是指针的话，可以修改指针指向的变量的值

//////////////////////////////////////////////////////////////////////////
//  变更操作


  // 将字母全转为小写
  YKString& ToLower();
  // 将字母全转为大写
  YKString& ToUpper();
  // 以rVal替换所有lVal字符串
  YKString& Replace(const YKString& lVal, const YKString& rVal);
  // 去除字符串左边的空白字符
  void TrimLeft();
  // 去除字符串右边的空白字符
  void TrimRight();
  // 去除字符串左右两边的空白字符
  void Trim();

  // 字符串追加指定类型的值，precision为double型的精度
  template <typename T>
  void Append(T val, size_type precision = 0) {
    append(Format(val, precision).c_str());
  }

//////////////////////////////////////////////////////////////////////////
/// 查找

  // 为find_first_of的忽略大小写版本
  size_type ifind_first_of(const YKString& str, size_type off = 0, size_type count = 0);
  // 为find_first_not_of的忽略大小写版本
  size_type ifind_first_not_of();
  // 为find_last_of的忽略大小写版本
  size_type ifind_last_of();
  // 为find_last_not_of的忽略大小写版本
  size_type ifind_last_not_of();
  // 
  size_type find_nth();
  size_type ifind_nth();
  YKString find_head(const YKString& sep) const;
  YKString find_tail(const YKString& sep) const;

//////////////////////////////////////////////////////////////////////////
// 高级操作

  // 转换为string
  std::string ToString() const;

  // 将容器内的内容以sep字符串作为分隔符拼接
  // bPair = false，格式形如：XXXwstrSepXXX
  // bPari = true,格式形如：XXXwstrSepXXXwstrSep
  template <typename T>
  static YKString Join(const T& container, const YKString& sep, YK_BOOL bPair = false) {
    T::const_iterator fIter = container.begin();
    T::const_iterator lIter = container.end();
    return Join(fIter, lIter, sep, bPair);
  }
  // 将迭代器内的内容以sep字符串作为分隔符拼接
  // bPair = false，格式形如：XXXwstrSepXXX
  // bPari = true,格式形如：XXXwstrSepXXXwstrSep
  template <typename InputIter>
  static YKString Join(InputIter fIter, InputIter lIter, const YKString& sep, YK_BOOL bPair = false) {
    YKString strRt;
    for (; fIter != lIter; ++fIter)
    {
      strRt.Append(*fIter);
      strRt.append(sep.c_str());
    }
    if (false == bPair && !strRt.empty())
    {
      strRt.erase(strRt.length() - sep.length());
    }

    return strRt;
  }

  // 将以sep分隔的字符串分解到vector容器中
  template <typename T>
  std::vector<T> Parse(const YKString& sep) const {
    std::vector<T> vecVal;
    size_type idxPre = 0;
    size_type idx = find(sep.c_str());
    while (idx != YKString::npos)
    {
      YKString strTemp = substr(idxPre, idx-idxPre);
      vecVal.push_back(strTemp.Convert<T>());
      idx += sep.size();
      idxPre = idx;
      idx = find(sep, idx);
    }

    if (idxPre <= size() - sep.size())
    {
      YKString strTemp = substr(idxPre);
      vecVal.push_back(strTemp.Convert<T>());
    }

    return vecVal;
  }

  // 将值转换为YKString，可指定浮点数的格式化精度
  template <typename T>
  static YKString Format(T val, size_type precision = 0) {
    std::wostringstream stream;
    if (precision > 0)
    {
      stream.precision(precision);
      stream.flags(std::wostringstream::fixed);
    }
    stream << val;
    return YKString(stream.str());
  }

  // 数字转为YKString，按宽度格式化，左边填充0
  static YKString FormatDigit(YK_LONG val, size_type width);

  // 将字符串里内容转换为指定的类型
  template <typename T>
  T Convert() const {
    try
    {
      return boost::lexical_cast<T>(c_str());
    }
    catch (boost::bad_lexical_cast&)
    {
      if (!empty()) // 字符串内存在不符合指定类型的字符
        assert(0);

      return T(); // 空字符串返回类型的默认值
    }
  }

  // 将字符串里的RGB转换为整形值，字符串内容形式要求：（RGB(xxx,xxx,xxx)）
  YK_ULONG ConvertRGB();

private:
  void Assign(const YK_CHAR* pChar);

};

实现文件：

YK_BOOL YKString::IsLower( size_type pos /* = npos */ ) const
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::islower(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsLower();
  }

  return true;
}

YK_BOOL YKString::IsUpper( size_type pos /* = npos */ ) const
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::isupper(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsUpper();
  }

  return true;
}

YK_BOOL YKString::IsNumeric( size_type pos /* = npos */ ) const
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::isdigit(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsNumeric();
  }

  return true;
}

YK_BOOL YKString::IsAlpha( size_type pos /* = npos */ ) const 
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::isalpha(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsAlpha();
  }

  return true;
}

YK_BOOL YKString::IsAlnum( size_type pos /* = npos */ ) const
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::isalnum(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsAlnum();
  }

  return true;
}

YK_BOOL YKString::IsBlank( size_type pos /* = npos */ ) const
{
  if (empty())
    return false;

  if (pos == npos)
  {
    for (const_iterator i = begin(); i != end(); ++i)
    {
      if (!std::isblank(*i, std::locale()))
        return false;
    }
  }
  else
  {
    YKString strTemp = at(pos);
    return strTemp.IsBlank();
  }

  return true;
}

YK_INT YKString::iCompare( const YKString& rhs ) const
{
  const_iterator iter = begin();
  const_iterator iterEnd = end();
  const_iterator iterRhs = rhs.begin();
  const_iterator iterRhsEnd = rhs.end();
  while (iter != iterEnd && iterRhs != iterRhsEnd)
  {
    value_type c1(std::tolower(*iter, std::locale()));
    value_type c2(std::tolower(*iterRhs, std::locale()));
    if (c1 < c2)
      return -1;
    else if (c1 > c2)
      return 1;
    ++iter; ++iterRhs;
  }

  if (iter == iterEnd)
    return iterRhs == iterRhsEnd ? 0 : -1;

  return 1;
}

YKString& YKString::ToLower()
{
  for (iterator i = begin(); i != end(); ++i)
  {
    *i = std::tolower(*i, std::locale());
  }

  return *this;
}

YKString& YKString::ToUpper()
{
  for (iterator i = begin(); i != end(); ++i)
  {
    *i = std::toupper(*i, std::locale());
  }

  return *this;
}

YKString& YKString::Replace( const YKString& lVal, const YKString& rVal )
{
  size_type lastpos = 0, thispos;
  while ((thispos = find(lVal, lastpos)) != npos)
  {
    replace(thispos, lVal.size(), rVal);
    lastpos = thispos + rVal.size();
  }
  return *this;
}

void YKString::TrimLeft()
{
  const_iterator i = begin();
  for (; i != end(); ++i)
  {
    if (!std::isspace(*i, std::locale()))
      break;
  }

  erase(begin(), i);
}

void YKString::TrimRight()
{
  const_reverse_iterator ri = rbegin();
  for (; ri != rend(); ++ri)
  {
    if (!std::isspace(*ri, std::locale()))
      break;
  }

  erase(rbegin().base(), ri.base());
}

void YKString::Trim()
{
  TrimLeft();
  TrimRight();
}

YKString::size_type YKString::ifind_first_of(const YKString& str, size_type off /* = 0 */, size_type count /* = 0 */)
{
  YKString temp = str;
  temp.ToLower();
  count = count > 0 ? count : temp.length();
  return find_first_of(temp.c_str(), off, count);
}

YKString::size_type YKString::ifind_first_not_of()
{
  return 0;
}

YKString::size_type YKString::ifind_last_of()
{
  return 0;
}

YKString::size_type YKString::ifind_last_not_of()
{
  return 0;
}

YKString::size_type YKString::find_nth()
{
  return 0;
}

YKString::size_type YKString::ifind_nth()
{
  return 0;
}

YKString YKString::find_head(const YKString& sep) const
{
  size_type pos = find(sep.c_str());
  if (pos != YKString::npos)
  {
    return std::move(substr(0, pos));
  }
  return L"";
}

YKString YKString::find_tail(const YKString& sep) const
{
  size_type pos = find_last_of(sep.c_str());
  if (pos != YKString::npos)
  {
    return std::move(substr(pos+sep.size()));
  }
  return L"";
}

YKString YKString::FormatDigit( YK_LONG val, size_type width )
{
  YKBuffer<YK_WCHAR> temp(20);
  YKString str = L"%0";
  str += YKString::Format(width);
  str += L"d";
  swprintf(temp.Begin(), temp.Size(), str.c_str(), val);
  return temp.Begin();
}

YK_ULONG YKString::ConvertRGB()
{
  YK_ULONG rgbVal = 0;
  size_type fPos = find(L'(');
  size_type lPos = find(L')');
  if (fPos != npos && lPos != npos)
  {
    YKString strVal = substr(fPos+1, lPos-fPos-1);
    std::vector<YK_ULONG> vecVal = strVal.Parse<YK_ULONG>(L",");
    if (vecVal.size() == 3)
    {
// #ifdef _MSC_VER && _WINDOWS
//      rgbVal = RGB(vecVal[0], vecVal[1], vecVal[2]);
// #endif // _MSC_VER
    }
  }

  return rgbVal;
}

std::string YKString::ToString() const
{
  size_t size = this->size();
  YKBuffer<YK_CHAR> buff(size+1);
  size_t rtValue = 0;
  wcstombs_s(&rtValue, buff.Begin(), size+1, c_str(), YK_UINT_MAX);
  buff[size] = 0;
  return buff.Begin();
}

void YKString::Assign( const YK_CHAR* pChar )
{
  size_t size = strlen(pChar);
  YKBuffer<YK_WCHAR> buff(size+1);
  size_t rtValue = 0;
  mbstowcs_s(&rtValue, buff.Begin(), size+1, pChar,  YK_UINT_MAX);
  buff[size] = 0x00;
  assign(buff.Begin());
}