dwstring.cpp.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 2,010 行 · 第 1/4 页

    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r < 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator < (const DwString<tchar>& aStr1, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r < 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator < (const tchar* aCstr, const DwString<tchar>& aStr2)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r < 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator > (const DwString<tchar>& aStr1, const DwString<tchar>& aStr2)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r > 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator > (const DwString<tchar>& aStr1, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r > 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator > (const tchar* aCstr, const DwString<tchar>& aStr2)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r > 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator <= (const DwString<tchar>& aStr1, const DwString<tchar>& aStr2)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r <= 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator <= (const DwString<tchar>& aStr1, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r <= 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator <= (const tchar* aCstr, const DwString<tchar>& aStr2)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r <= 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator >= (const DwString<tchar>& aStr1, const DwString<tchar>& aStr2)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r >= 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator >= (const DwString<tchar>& aStr1, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r >= 0) ? 1 : 0;
    return !!r;
}


template<class tchar> bool operator >= (const tchar* aCstr, const DwString<tchar>& aStr2)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    int r = dw_strcmp(s1, len1, s2, len2);
    r = (r >= 0) ? 1 : 0;
    return !!r;
}

template<class tchar> int DwStrcasecmp(const DwString<tchar>& aStr1, const DwString<tchar>& aStr2)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrcasecmp(const DwString<tchar>& aStr, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr.data();
    size_t len1 = aStr.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrcasecmp(const tchar* aCstr, const DwString<tchar>& aStr)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 =  (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr.data();
    size_t len2 = aStr.length();
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncasecmp(const DwString<tchar>& aStr1, const DwString<tchar>& aStr2, size_t n)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    len1 = std::min(len1, n);
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    len2 = std::min(len2, n);
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncasecmp(const DwString<tchar>& aStr, const tchar* aCstr, size_t n)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr.data();
    size_t len1 = aStr.length();
    len1 = std::min(len1, n);
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    len2 = std::min(len2, n);
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncasecmp(const tchar* aCstr, const DwString<tchar>& aStr, size_t n)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    len1 = std::min(len1, n);
    const tchar* s2 = aStr.data();
    size_t len2 = aStr.length();
    len2 = std::min(len2, n);
    return dw_strcasecmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrcmp(const DwString<tchar>& aStr1, const DwString<tchar>& aStr2)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrcmp(const DwString<tchar>& aStr, const tchar* aCstr)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr.data();
    size_t len1 = aStr.length();
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrcmp(const tchar* aCstr, const DwString<tchar>& aStr)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    const tchar* s2 = aStr.data();
    size_t len2 = aStr.length();
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncmp(const DwString<tchar>& aStr1, const DwString<tchar>& aStr2, size_t n)
{
    const tchar* s1 = aStr1.data();
    size_t len1 = aStr1.length();
    len1 = std::min(len1, n);
    const tchar* s2 = aStr2.data();
    size_t len2 = aStr2.length();
    len2 = std::min(len2, n);
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncmp(const DwString<tchar>& aStr, const tchar* aCstr, size_t n)
{
    assert(aCstr != 0);
    const tchar* s1 = aStr.data();
    size_t len1 = aStr.length();
    len1 = std::min(len1, n);
    const tchar* s2 = aCstr;
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    len2 = std::min(len2, n);
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> int DwStrncmp(const tchar* aCstr, const DwString<tchar>& aStr, size_t n)
{
    assert(aCstr != 0);
    const tchar* s1 = aCstr;
    size_t len1 = (aCstr) ? strlen(aCstr) : 0;
    len1 = std::min(len1, n);
    const tchar* s2 = aStr.data();
    size_t len2 = aStr.length();
    len2 = std::min(len2, n);
    return dw_strcmp(s1, len1, s2, len2);
}


template<class tchar> void DwStrcpy(DwString<tchar>& aStrDest, const DwString<tchar>& aStrSrc)
{
    aStrDest.assign(aStrSrc);
}


template<class tchar> void DwStrcpy(DwString<tchar>& aStrDest, const tchar* aCstrSrc)
{
    aStrDest.assign(aCstrSrc);
}


template<class tchar> void DwStrcpy(tchar* aCstrDest, const DwString<tchar>& aStrSrc)
{
    assert(aCstrDest != 0);
    const tchar* buf = aStrSrc.data();
    size_t len = aStrSrc.length();
    mem_copy(buf, len, aCstrDest);
    aCstrDest[len] = 0;
}


template<class tchar> void DwStrncpy(DwString<tchar>& aStrDest, const DwString<tchar>& aStrSrc, size_t n)
{
    aStrDest.assign(aStrSrc, 0, n);
}


template<class tchar> void DwStrncpy(DwString<tchar>& aStrDest, const tchar* aCstrSrc, size_t n)
{
    aStrDest.assign(aCstrSrc, 0, n);
}


template<class tchar> void DwStrncpy(tchar* aCstrDest, const DwString<tchar>& aStrSrc, size_t n)
{
    assert(aCstrDest != 0);
    const tchar* buf = aStrSrc.data();
    size_t len = aStrSrc.length();
    len = std::min(len, n);
    mem_copy(buf, len, aCstrDest);
    for (size_t i=len; i < n; ++i) {
        aCstrDest[i] = 0;
    }
}


template<class tchar> tchar* DwStrdup(const DwString<tchar>& aStr)
{
    size_t len = aStr.length();
    tchar* buf = new tchar[len+1];
    assert(buf != 0);
    if (buf != 0) {
        DwStrncpy(buf, aStr, len);
        buf[len] = 0;
    }
    return buf;
}

template<class tchar> DwString<tchar> DwString<tchar>::intToStr(int i)
{
 tchar s[20];
 return DwString(_itoa(i,s,10));
}

DwString<char> toansi(const DwString<wchar_t> &u)
{
 char *a=unicode16toAnsi(u.c_str());
 DwString<char> s(a);
 free(a);
 return s;
}

template<std::size_t=sizeof(std::size_t)> struct Fnv_hash
{
 static std::size_t hash(const char* first, std::size_t length)
  {
   std::size_t result = 0;
   for (; length > 0; --length)
    result = (result * 131) + *first++;
   return result;
  }
};
template<> struct Fnv_hash<4>
{
 static std::size_t hash(const char* first, std::size_t length)
  {
   std::size_t result = 2166136261UL;
   for (; length > 0; --length)
    {
     result ^= (std::size_t)*first++;
     result *= 16777619UL;
    }
   return result;
  }
};
#ifdef WIN64
template<> struct Fnv_hash<8>
{
 static std::size_t hash(const char* first, std::size_t length)
  {
   std::size_t result = 14695981039346656037ULL;
   for (; length > 0; --length)
    {
     result ^= (std::size_t)*first++;
     result *= 1099511628211ULL;
    }
   return result;
  }
};
#endif

size_t std::hash< DwString<char> >::operator()(const DwString<char> &s) const
{
 return Fnv_hash<>::hash(s.data(),s.size());
}
size_t std::hash< DwString<wchar_t> >::operator()(const DwString<wchar_t> &s) const
{
 return Fnv_hash<>::hash((const char*)s.data(),s.size()*sizeof(wchar_t));
}

template class DwString<char>;
template DwString<char> operator + (const DwString<char>& aStr1, const DwString<char>& aStr2);
template DwString<char> operator + (const char* aCstr, const DwString<char>& aStr2);
template DwString<char> operator + (char aChar, const DwString<char>& aStr2);
template DwString<char> operator + (const DwString<char>& aStr1, const char* aCstr);
template DwString<char> operator + (const DwString<char>& aStr1, char aChar);
template bool operator == (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator == (const DwString<char>& aStr1, const char* aCstr);
template bool operator == (const char* aCstr, const DwString<char>& aStr2);
template bool operator != (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator != (const DwString<char>& aStr1, const char* aCstr);
template bool operator != (const char* aCstr, const DwString<char>& aStr2);
template bool operator < (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator < (const DwString<char>& aStr1, const char* aCstr);
template bool operator < (const char* aCstr, const DwString<char>& aStr2);
template bool operator > (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator > (const DwString<char>& aStr1, const char* aCstr);
template bool operator > (const char* aCstr, const DwString<char>& aStr2);
template bool operator <= (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator <= (const DwString<char>& aStr1, const char* aCstr);
template bool operator <= (const char* aCstr, const DwString<char>& aStr2);
template bool operator >= (const DwString<char>& aStr1, const DwString<char>& aStr2);
template bool operator >= (const DwString<char>& aStr1, const char* aCstr);
template bool operator >= (const char* aCstr, const DwString<char>& aStr2);
template int DwStrcasecmp(const DwString<char>& aStr1, const DwString<char>& aStr2);
template int DwStrcasecmp(const DwString<char>& aStr1, const char* aCstr);
template int DwStrcasecmp(const char* aCstr, const DwString<char>& aStr2);
template int DwStrncasecmp(const DwString<char>& aStr1, const DwString<char>& aStr2, size_t aLen);
template int DwStrncasecmp(const DwString<char>& aStr, const char* aCstr, size_t aLen);
template int DwStrncasecmp(const char* aCstr, const DwString<char>& aStr, size_t aLen);
template int DwStrcmp(const DwString<char>& aStr1, const DwString<char>& aStr2);
template int DwStrcmp(const DwString<char>& aStr, const char* aCstr);
template int DwStrcmp(const char* aCstr, const DwString<char>& aStr);
template int DwStrncmp(const DwString<char>& aStr1, const DwString<char>& aStr2, size_t aLen);
template int DwStrncmp(const DwString<char>& aStr, const char* aCstr, size_t aLen);
template int DwStrncmp(const char* aCstr, const DwString<char>& aStr, size_t aLen);
template void DwStrcpy(DwString<char>& aStrDest, const DwString<char>& aStrSrc);
template void DwStrcpy(DwString<char>& aStrDest, const char* aCstrSrc);
template void DwStrcpy(char* aCstrDest, const DwString<char>& aStrSrc);
template void DwStrncpy(DwString<char>& aStrDest, const DwString<char>& aStrSrc, size_t aLen);
template void DwStrncpy(DwString<char>& aStrDest, const char* aCstrSrc, size_t aLen);
template void DwStrncpy(char* aCstrDest, const DwString<char>& aStrSrc, size_t aLen);
template char* DwStrdup(const DwString<char>& aStr);

template class DwString<wchar_t>;
template DwString<wchar_t> operator + (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template DwString<wchar_t> operator + (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template DwString<wchar_t> operator + (wchar_t aChar, const DwString<wchar_t>& aStr2);
template DwString<wchar_t> operator + (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template DwString<wchar_t> operator + (const DwString<wchar_t>& aStr1, wchar_t aChar);
template bool operator == (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator == (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator == (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template bool operator != (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator != (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator != (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template bool operator < (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator < (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator < (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template bool operator > (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator > (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator > (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template bool operator <= (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator <= (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator <= (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template bool operator >= (const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template bool operator >= (const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template bool operator >= (const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template int DwStrcasecmp(const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template int DwStrcasecmp(const DwString<wchar_t>& aStr1, const wchar_t* aCstr);
template int DwStrcasecmp(const wchar_t* aCstr, const DwString<wchar_t>& aStr2);
template int DwStrncasecmp(const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2, size_t aLen);
template int DwStrncasecmp(const DwString<wchar_t>& aStr, const wchar_t* aCstr, size_t aLen);
template int DwStrncasecmp(const wchar_t* aCstr, const DwString<wchar_t>& aStr, size_t aLen);
template int DwStrcmp(const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2);
template int DwStrcmp(const DwString<wchar_t>& aStr, const wchar_t* aCstr);
template int DwStrcmp(const wchar_t* aCstr, const DwString<wchar_t>& aStr);
template int DwStrncmp(const DwString<wchar_t>& aStr1, const DwString<wchar_t>& aStr2, size_t aLen);
template int DwStrncmp(const DwString<wchar_t>& aStr, const wchar_t* aCstr, size_t aLen);
template int DwStrncmp(const wchar_t* aCstr, const DwString<wchar_t>& aStr, size_t aLen);
template void DwStrcpy(DwString<wchar_t>& aStrDest, const DwString<wchar_t>& aStrSrc);
template void DwStrcpy(DwString<wchar_t>& aStrDest, const wchar_t* aCstrSrc);
template void DwStrcpy(wchar_t* aCstrDest, const DwString<wchar_t>& aStrSrc);
template void DwStrncpy(DwString<wchar_t>& aStrDest, const DwString<wchar_t>& aStrSrc, size_t aLen);
template void DwStrncpy(DwString<wchar_t>& aStrDest, const wchar_t* aCstrSrc, size_t aLen);
template void DwStrncpy(wchar_t* aCstrDest, const DwString<wchar_t>& aStrSrc, size_t aLen);
template wchar_t* DwStrdup(const DwString<wchar_t>& aStr);

//============================= passtring ===========================
template<> char passtring<char>::chr='\0';
template<> wchar_t passtring<wchar_t>::chr=L'\0';