8.10

1 files changed, 24 insertions, 87 deletions

diff --git a/zen/zstring.h b/zen/zstring.h
index 12bda29f..fdb71da0 100755
--- a/zen/zstring.h
+++ b/zen/zstring.h
@@ -19,35 +19,39 @@
 using Zstring = zen::Zbase<Zchar>;

 

 

-int cmpStringNoCase(const wchar_t* lhs, size_t lhsLen, const wchar_t* rhs, size_t rhsLen);

-    int cmpStringNoCase(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen);

-

-template <class S>

-S makeUpperCopy(S str);

-

-

 //Compare filepaths: Windows/OS X does NOT distinguish between upper/lower-case, while Linux DOES

-int cmpFilePath(const wchar_t* lhs, size_t lhsLen, const wchar_t* rhs, size_t rhsLen);

-    int cmpFilePath(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen);

+struct CmpFilePath

+{

+    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;

+};

 

+struct CmpNaturalSort

+{

+    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;

+};

 

-template <class S, class T> inline

-bool equalFilePath(const S& lhs, const T& rhs) { using namespace zen; return cmpFilePath(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) == 0;  }

 

 struct LessFilePath

 {

-    template <class S, class T>

-    bool operator()(const S& lhs, const T& rhs) const { using namespace zen; return cmpFilePath(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }

+    template <class S> //don't support heterogenous input! => use as container predicate only!

+    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpFilePath()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }

 };

 

-

-struct LessNoCase

+struct LessNaturalSort

 {

-    template <class S, class T>

-    bool operator()(const S& lhs, const T& rhs) const { using namespace zen; return cmpStringNoCase(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }

+    template <class S> //don't support heterogenous input! => use as container predicate only!

+    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpNaturalSort()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }

 };

 

 

+template <class S>

+S makeUpperCopy(S str);

+

+

+template <class S, class T> inline

+bool equalFilePath(const S& lhs, const T& rhs) { using namespace zen; return strEqual(lhs, rhs, CmpFilePath());  }

+

+

 inline

 Zstring appendSeparator(Zstring path) //support rvalue references!

 {

@@ -63,35 +67,6 @@ Zstring getFileExtension(const Zstring& filePath)
 }

 

 

-template <class S, class T> inline

-bool ciEqual(const S& lhs, const T& rhs) { using namespace zen; return cmpStringNoCase(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) == 0;  }

-

-

-template <class S, class T> inline

-bool ciStartsWith(const S& str, const T& prefix)

-{

-    using namespace zen;

-    const size_t pfLen = strLength(prefix);

-    if (strLength(str) < pfLen)

-        return false;

-

-    return cmpStringNoCase(strBegin(str), pfLen, strBegin(prefix), pfLen) == 0;

-}

-

-

-template <class S, class T> inline

-bool ciEndsWith(const S& str, const T& postfix)

-{

-    using namespace zen;

-    const size_t strLen = strLength(str);

-    const size_t pfLen  = strLength(postfix);

-    if (strLen < pfLen)

-        return false;

-

-    return cmpStringNoCase(strBegin(str) + strLen - pfLen, pfLen, strBegin(postfix), pfLen) == 0;

-}

-

-

 template <class S, class T, class U>

 S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm);

 

@@ -110,37 +85,11 @@ inline
 void makeUpperInPlace(char* str, size_t strLen)

 {

     std::for_each(str, str + strLen, [](char& c) { c = std::toupper(static_cast<unsigned char>(c)); }); //locale-dependent!

-    //result of toupper() is an unsigned char mapped to int range, so the char representation is in the last 8 bits and we need not care about signedness!

+    //result of toupper() is an unsigned char mapped to int range: the char representation is in the last 8 bits and we need not care about signedness!

     //this should work for UTF-8, too: all chars >= 128 are mapped upon themselves!

 }

 

 

-inline

-int cmpStringNoCase(const wchar_t* lhs, size_t lhsLen, const wchar_t* rhs, size_t rhsLen)

-{

-    assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!

-    assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //

-

-    const int rv = ::wcsncasecmp(lhs, rhs, std::min(lhsLen, rhsLen)); //locale-dependent!

-    if (rv != 0)

-        return rv;

-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);

-}

-

-

-inline

-int cmpStringNoCase(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)

-{

-    assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!

-    assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //

-

-    const int rv = ::strncasecmp(lhs, rhs, std::min(lhsLen, rhsLen)); //locale-dependent!

-    if (rv != 0)

-        return rv;

-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);

-}

-

-

 template <class S> inline

 S makeUpperCopy(S str)

 {

@@ -153,20 +102,7 @@ S makeUpperCopy(S str)
 

 

 inline

-int cmpFilePath(const wchar_t* lhs, size_t lhsLen, const wchar_t* rhs, size_t rhsLen)

-{

-    assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!

-    assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //

-

-    const int rv = std::wcsncmp(lhs, rhs, std::min(lhsLen, rhsLen));

-    if (rv != 0)

-        return rv;

-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);

-}

-

-

-inline

-int cmpFilePath(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)

+int CmpFilePath::operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const

 {

     assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!

     assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //

@@ -214,6 +150,7 @@ S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm)
     }

 }

 

+    int cmpStringNaturalLinux(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen);

 

 //---------------------------------------------------------------------------

 //ZEN macro consistency checks: