yb_base.cpp

简单实用, 功能强大的 C++ Builder 串口控件! 本控件是免费的, 不需要注册, 有关授权及许可协议详见 license.txt 文件。 1.支持二进制数据和文本数据的收发 2.支

  v.SetLocale(Locale);
  v.AllocBuf(Length()+s.Length()+1);
  wcscpy(v._wsbuf,_wsbuf);
  wcscat(v._wsbuf,s._wsbuf);
  return v;
}
//----------------------------------------------------------------------------
TVictorWideString operator + (const wchar_t *s1, const TVictorWideString &s2)
{
  TVictorWideString v;
  v.SetLocale(s2.Locale);
  v.AllocBuf(wcslen(s1)+s2.Length()+1);
  wcscpy(v._wsbuf,s1);
  wcscat(v._wsbuf,s2._wsbuf);
  return v;
}
//----------------------------------------------------------------------------
int TVictorWideString::printf(const wchar_t *format,...)
{
  int rc;
  va_list paramList;
  va_start(paramList, format);
  rc = vprintf(format, paramList);
  va_end(paramList);
  return rc;
}
//----------------------------------------------------------------------------
TVictorWideString &TVictorWideString::sprintf(const wchar_t *format,...)
{
  va_list paramList;
  va_start(paramList, format);
  vprintf(format, paramList);
  va_end(paramList);
  return *this;
}
//----------------------------------------------------------------------------
int TVictorWideString::vprintf(const wchar_t* format, va_list paramList)
{
  int nSize = vsnwprintf(NULL, 0, format, paramList)+1;
  AllocBuf(nSize);
  return vsnwprintf(_wsbuf, nSize, format, paramList);
}
//----------------------------------------------------------------------------
int TVictorWideString::Pos(const TVictorWideString &s) const
{
  int Ln = Length();
  int Sn = s.Length();

  for(int i=0; i<=Ln-Sn; i++)
   if(wcsncmp(_wsbuf+i, s._wsbuf, Sn)==0)
    return i;
  return -1;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::UpperCase(void) const
{
  TVictorWideString s(*this);
  CharUpperBuffW(s._wsbuf,s.Length());
  return s;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::LowerCase(void) const
{
  TVictorWideString s(*this);
  CharLowerBuffW(s._wsbuf,s.Length());
  return s;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Replace(const TVictorWideString &from, const TVictorWideString &to, bool bIgnoreCase) const
{
  TVictorWideString s(*this),v;
  int fn=from.Length();
  if(fn>0)
   {
     if(bIgnoreCase)
      {
        TVictorWideString sFromUc=from.UpperCase();
        while(!s.IsEmpty())
         {
           int p = s.UpperCase().Pos(sFromUc);
           if(p>=0)
            {
              v+=s.SubString(0,p)+to;
              s=s.SubString(p+fn,-1);
            }
           else
            {
              v+=s;
              s.Clear();
            }
         }
      }
     else
      {
        while(!s.IsEmpty())
         {
           int p = s.Pos(from);
           if(p>=0)
            {
              v+=s.SubString(0,p)+to;
              s=s.SubString(p+fn,-1);
            }
           else
            {
              v+=s;
              s.Clear();
            }
         }
      }
   }
  return v;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Left(int cnt) const
{
  TVictorWideString v;
  if(cnt>=0)
   {
     int n=Length();
     if(n>cnt)n=cnt;
     v.AllocBuf(n+1);
     wcsncpy(v._wsbuf,_wsbuf,n);
     v._wsbuf[n]=0;
   }
  return v;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Right(int cnt) const
{
  TVictorWideString v;
  if(cnt>=0)
   {
     int Ln=Length();
     int n=Ln<cnt?Ln:cnt;
     v.AllocBuf(n+1);
     wcsncpy(v._wsbuf,_wsbuf+Ln-n,n);
     v._wsbuf[n]=0;
   }
  return v;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::SubString(int idx, int cnt) const
{
  TVictorWideString v;
  int Ln=Length()-idx;
  if(Ln>=0)
   {
     int n=cnt<0?Ln:cnt;
     v.AllocBuf(n+1);
     wcsncpy(v._wsbuf,_wsbuf+idx,n);
     v._wsbuf[n]=0;
   }
  return v;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Trim(void) const
{
  TVictorWideString s;
  int nSp, Ln=Length();
  for(nSp=0; nSp<Ln; nSp++)
   if((_wsbuf[nSp]!=0x20)&&(_wsbuf[nSp]!=0x0d)&&(_wsbuf[nSp]!=0x0a)&&(_wsbuf[nSp]!=0x09))
    break;

  for(; Ln>nSp; Ln--)
   if((_wsbuf[Ln-1]!=0x20)&&(_wsbuf[Ln-1]!=0x0d)&&(_wsbuf[Ln-1]!=0x0a)&&(_wsbuf[Ln-1]!=0x09))
    break;

  s.AllocBuf(Ln-nSp+1);
  wcsncpy(s._wsbuf,_wsbuf+nSp,Ln-nSp);
  s._wsbuf[Ln-nSp]=0;

  return s;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::TrimLeft(void) const
{
  int nSp, Ln=Length();
  for(nSp=0; nSp<Ln; nSp++)
   if((_wsbuf[nSp]!=0x20)&&(_wsbuf[nSp]!=0x0d)&&(_wsbuf[nSp]!=0x0a)&&(_wsbuf[nSp]!=0x09))
    break;
  return TVictorWideString(_wsbuf+nSp);
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::TrimRight(void) const
{
  TVictorWideString s;
  int Ln=Length();
  for(; Ln>0; Ln--)
   if((_wsbuf[Ln-1]!=0x20)&&(_wsbuf[Ln-1]!=0x0d)&&(_wsbuf[Ln-1]!=0x0a)&&(_wsbuf[Ln-1]!=0x09))
    break;
  s.AllocBuf(Ln+1);
  wcsncpy(s._wsbuf,_wsbuf,Ln);
  s._wsbuf[Ln]=0;
  return s;
}
//----------------------------------------------------------------------------
bool TVictorWideString::CharIsChinese(int n) const
{
  int nLen = Length();
  if((n>=0) && (n<nLen))
    return _vcs_is_charchinese(_wsbuf[n]);
  return false;
}
//----------------------------------------------------------------------------
int TVictorWideString::CharStrokeCount(int n) const
{
  int nLen = Length();
  if((n>=0) && (n<nLen))
    return _vcs_get_strokecount(_wsbuf[n]);
  return false;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::CharBopomofo(int n) const
{
  TVictorWideString ws;
  int nLen = Length();
  if((n>=0) && (n<nLen))
    ws = _vcs_get_bopomofo(_wsbuf[n]);
  return ws;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::CharPinyin(int n) const
{
  TVictorWideString ws;
  int nLen = Length();
  if((n>=0) && (n<nLen))
    ws = _vcs_get_pinyin(_wsbuf[n]);
  return ws;
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Bopomofo(void) const
{
  return _vcs_get_bopomofo(*this);
}
//----------------------------------------------------------------------------
TVictorWideString TVictorWideString::Pinyin(void) const
{
  return _vcs_get_pinyin(*this);
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator == (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) == 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) == 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator != (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) != 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) != 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator <  (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) < 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) < 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator >  (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) > 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) > 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator <= (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) <= 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) <= 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator >= (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType) >= 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType) >= 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator == (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) == 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) == 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator != (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) != 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) != 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator <  (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) < 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) < 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator >  (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) > 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) > 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator <= (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) <= 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) <= 0); //區分大小寫
}
//----------------------------------------------------------------------------
bool TVictorWideString::operator >= (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType) >= 0): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType) >= 0); //區分大小寫
}
//----------------------------------------------------------------------------
int TVictorWideString::operator - (const TVictorWideString &s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s._wsbuf, _Locale->StringSortType)): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s._wsbuf, _Locale->StringSortType)); //區分大小寫
}
//----------------------------------------------------------------------------
int TVictorWideString::operator - (const wchar_t *s) const
{
  return (_Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(_wsbuf, s, _Locale->StringSortType)): //不區分大小寫
         (_vcs_wcscmp(_wsbuf, s, _Locale->StringSortType)); //區分大小寫
}
//----------------------------------------------------------------------------
int operator - (const wchar_t *s1, const TVictorWideString &s2)
{
  return (s2._Locale->CaseInsensitive)? //是否區分大小寫
         (_vcs_wcsicmp(s1, s2._wsbuf, s2._Locale->StringSortType)): //不區分大小寫
         (_vcs_wcscmp(s2, s2._wsbuf, s2._Locale->StringSortType)); //區分大小寫
}
//----------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
TVictorStringList::TVictorStringList()
{
}
//----------------------------------------------------------------------------
TVictorStringList::TVictorStringList(TVictorString s)
{
  Text = s;
}
//----------------------------------------------------------------------------
TVictorStringList::TVictorStringList(const TVictorStringList &sl)
{
  Text = sl.Text;
}
//----------------------------------------------------------------------------
TVictorString TVictorStringList::fGetItem(int idx)const
{
  if((idx>=0)&&(idx<Count))
    return _Items[idx];
  return TVictorString();
}
//----------------------------------------------------------------------------
void TVictorStringList::fSetItem(int idx, const TVictorString &s)
{
  if((idx>=0)&&(idx<Count))
    _Items[idx] = s;
}
//----------------------------------------------------------------------------
void TVictorStringList::Add(TVictorString s)
{
  _Items.push_back(s);
}
//----------------------------------------------------------------------------
void TVictorStringList::Insert(TVictorString s, int idx)
{
  _Items.insert(_Items.begin()+idx,s);
}
//----------------------------------------------------------------------------
void TVictorStringList::Delete(int idx)
{
  _Items.erase(_Items.begin()+idx);
}
//----------------------------------------------------------------------------
TVictorString TVictorStringList::fGetText(void)const
{
  int n = Count;
  TVictorString s;
  for(int i=0; i<n; i++)
    s+=Item[i]+"\r\n";
  return s;
}
//----------------------------------------------------------------------------
void TVictorStringList::fSetText(TVictorString s)
{
  Clear();
  int p = s.Pos("\r\n"); //0123pp678
  while(p>=0)
   {
     Add(s.Left(p));
     s = s.SubString(p+2,-1);
     p = s.Pos("\r\n");
   }
  if(!s.IsEmpty())Add(s);
}
//----------------------------------------------------------------------------
TVictorString TVictorStringList::fGetValue(TVictorString sItem) const
{
  int n = Count;
  TVictorString sName, sValue, sUpperItem=sItem.UpperCase();
  for(int idx=0; idx<n; idx++)
   {
     fStrToNameValue(Item[idx], sName, sValue);
     if(sName.UpperCase()==sUpperItem)
       return sValue;
   }
  return TVictorString();
}
//----------------------------------------------------------------------------