diff options
Diffstat (limited to 'zip/ZipArchive/ZipString_stl.h')
| -rw-r--r-- | zip/ZipArchive/ZipString_stl.h | 328 |
1 files changed, 328 insertions, 0 deletions
diff --git a/zip/ZipArchive/ZipString_stl.h b/zip/ZipArchive/ZipString_stl.h new file mode 100644 index 0000000..330ce65 --- /dev/null +++ b/zip/ZipArchive/ZipString_stl.h @@ -0,0 +1,328 @@ +////////////////////////////////////////////////////////////////////////////////
+// This source file is part of the ZipArchive library source distribution and
+// is Copyrighted 2000 - 2007 by Artpol Software - Tadeusz Dracz
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// For the licensing details refer to the License.txt file.
+//
+// Web Site: http://www.artpol-software.com
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef ZIPARCHIVE_ZIPSTRING_DOT_H
+ #error Do not include this file directly. Include ZipString.h instead
+#endif
+
+#include "stdafx.h"
+
+#if _MSC_VER > 1000
+ #pragma warning( push, 3 ) // STL requirements
+#endif
+
+
+#include <string>
+#include <algorithm>
+#include <stdarg.h>
+#include <stdio.h>
+#include <cctype>
+#include <locale>
+
+#include "ZipExport.h"
+
+#ifndef __GNUC__
+ #ifndef _vsntprintf
+ #ifdef _UNICODE
+ #define _vsntprintf _vsnwprintf
+ #else
+ #define _vsntprintf _vsnprintf
+ #endif
+ #endif
+#elif !defined(_vsntprintf)
+ #define _vsntprintf vsnprintf
+#endif
+
+typedef std::basic_string<TCHAR> stdbs;
+/**
+ It contains mostly the methods required by ZipArchive Library.
+*/
+class ZIP_API CZipString : public stdbs
+{
+ void TrimInternalL(size_type iPos)
+ {
+ if (iPos == npos)
+ erase ();
+ if (iPos)
+ erase(0, iPos);
+ }
+ void TrimInternalR(size_type iPos)
+ {
+ if (iPos == npos)
+ erase ();
+ erase(++iPos);
+ }
+
+#ifndef __GNUC__
+ static int zslen(const TCHAR* lpsz)
+ {
+ if (!lpsz) return 0;
+
+ // we want to take into account the locale stuff (by using standard templates)
+
+ #ifdef _UNICODE
+ return (int)std::wstring(lpsz).length();
+ #else
+ return (int)std::string(lpsz).length();
+ #endif
+ }
+#else
+ static int zslen(const TCHAR* lpsz)
+ {
+ #if (__GNUC__ < 3) // I'm not sure which precisely version should be put here
+ return lpsz ? std::string_char_traits<TCHAR>::length(lpsz) : 0;
+ #else
+ return lpsz ? std::char_traits<TCHAR>::length(lpsz) : 0;
+ #endif
+
+ }
+#endif
+
+static TCHAR tl(TCHAR c)
+{
+ // use_facet doesn't work here well (doesn't convert all the local characters properly)
+ return std::tolower(c, std::locale());
+}
+static TCHAR tu(TCHAR c)
+{
+ // use_facet doesn't work here well (doesn't convert all the local characters properly)
+ return std::toupper(c, std::locale());
+}
+
+public:
+ CZipString(){}
+ explicit CZipString (TCHAR ch, int nRepeat = 1):stdbs(nRepeat, ch){}
+ CZipString( const CZipString& stringSrc ) {assign(stringSrc);}
+ CZipString( const stdbs& stringSrc ) {assign(stringSrc);}
+ CZipString( LPCTSTR lpsz ){if (!lpsz) Empty(); else assign(lpsz);}
+ operator LPCTSTR() const{return c_str();}
+
+ int GetLength() const {return (int) size();}
+ bool IsEmpty() const {return empty();}
+ void Empty() {erase(begin(), end());}
+ TCHAR GetAt (int iIndex) const{return at(iIndex);}
+ TCHAR operator[] (int iIndex) const{return at(iIndex);}
+ void SetAt( int nIndex, TCHAR ch ) {at(nIndex) = ch;}
+ LPTSTR GetBuffer(int nMinBufLength)
+ {
+ if ((int)size() < nMinBufLength)
+ resize(nMinBufLength);
+ return empty() ? const_cast<TCHAR*>(data()) : &(at(0));
+ }
+ void ReleaseBuffer( int nNewLength = -1 ) { resize(nNewLength > -1 ? nNewLength : zslen(c_str()));}
+ void TrimLeft( TCHAR chTarget )
+ {
+ TrimInternalL(find_first_not_of(chTarget));
+ }
+ void TrimLeft( LPCTSTR lpszTargets )
+ {
+ TrimInternalL(find_first_not_of(lpszTargets));
+ }
+ void TrimRight( TCHAR chTarget )
+ {
+ TrimInternalR(find_last_not_of(chTarget));
+ }
+ void TrimRight( LPCTSTR lpszTargets )
+ {
+ TrimInternalR(find_last_not_of(lpszTargets));
+ }
+
+#if _MSC_VER >= 1300
+ #pragma warning( push )
+ #pragma warning (disable : 4793) // 'vararg' : causes native code generation for function 'void CZipString::Format(LPCTSTR,...)'
+#endif
+
+ void Format(LPCTSTR lpszFormat, ...)
+ {
+ va_list arguments;
+ va_start (arguments, lpszFormat);
+ TCHAR* pBuf = NULL;
+ int iCounter = 1, uTotal = 0;
+ do
+ {
+ int nChars = iCounter * 1024;
+ int nLen = sizeof(TCHAR) * nChars;
+
+ TCHAR* pTempBuf = (TCHAR*)realloc((void*)pBuf, nLen);
+ if (!pTempBuf)
+ {
+ if (pBuf != NULL)
+ free(pBuf);
+ va_end (arguments);
+ return;
+ }
+ pBuf = pTempBuf;
+
+#if _MSC_VER >= 1400
+ uTotal = _vsntprintf_s(pBuf, nChars, nChars - 1, lpszFormat, arguments);
+#else
+ uTotal = _vsntprintf(pBuf, nChars - 1, lpszFormat, arguments);
+#endif
+
+ if (uTotal == -1 || (uTotal == nChars - 1) ) // for some implementations
+ {
+ pBuf[nChars - 1] = _T('\0');
+ if (iCounter == 7)
+ break;
+ }
+ else
+ {
+ pBuf[uTotal] = _T('\0');
+ break;
+ }
+ iCounter++;
+
+ } while (true);
+
+ va_end (arguments);
+ *this = pBuf;
+ free(pBuf);
+ }
+
+#if _MSC_VER >= 1300
+ #pragma warning( pop )
+#endif
+
+ void Insert( int nIndex, LPCTSTR pstr ){insert(nIndex, pstr, zslen(pstr));}
+ void Insert( int nIndex, TCHAR ch ) {insert(nIndex, 1, ch);}
+ int Delete( int nIndex, int nCount = 1 )
+ {
+ int iSize = (int) size();
+ int iToDelete = iSize < nIndex + nCount ? iSize - nIndex : nCount;
+ if (iToDelete > 0)
+ {
+ erase(nIndex, iToDelete);
+ iSize -= iToDelete;
+ }
+ return iSize;
+ }
+#ifndef __MINGW32__
+ void MakeLower()
+ {
+ std::transform(begin(),end(),begin(),tl);
+ }
+ void MakeUpper()
+ {
+ std::transform(begin(),end(),begin(),tu);
+ }
+#else
+ void MakeLower()
+ {
+ std::transform(begin(),end(),begin(),tolower);
+ }
+ void MakeUpper()
+ {
+ std::transform(begin(),end(),begin(),toupper);
+ }
+#endif
+ void MakeReverse()
+ {
+ std::reverse(begin(), end());
+
+ }
+ CZipString Left( int nCount ) const { return substr(0, nCount);}
+ CZipString Right( int nCount) const
+ {
+ nCount = (int)size() < nCount ? (int)size() : nCount;
+ return substr(size() - nCount);
+ }
+ CZipString Mid( int nFirst ) const {return substr(nFirst);}
+ CZipString Mid( int nFirst, int nCount ) const {return substr(nFirst, nCount);}
+ int Collate( LPCTSTR lpsz ) const
+ {
+#if !defined __GNUC__ || defined __MINGW32__
+ return _tcscoll(c_str(), lpsz);
+#else
+ //return compare(lpsz);
+ return strcoll(c_str(), lpsz);
+#endif
+ }
+
+ int CollateNoCase( LPCTSTR lpsz ) const
+ {
+#if !defined __GNUC__ || defined __MINGW32__
+ return _tcsicoll(c_str(), lpsz);
+#else
+ if (std::locale() == std::locale::classic())
+ return strcasecmp(c_str(), lpsz);
+ else
+ // this may be not case-insensitive !!!
+ return strcoll(c_str(), lpsz);
+ //return stricoll(c_str(), lpsz);
+#endif
+ }
+
+ int Compare( LPCTSTR lpsz ) const
+ {
+ return compare(lpsz);
+ }
+
+ int CompareNoCase( LPCTSTR lpsz ) const
+ {
+#if !defined __GNUC__ || defined __MINGW32__
+ return _tcsicmp(c_str(), lpsz);
+#else
+ return strcasecmp(c_str(), lpsz);
+ //return stricmp(c_str(), lpsz);
+#endif
+ }
+
+ bool operator != (LPCTSTR lpsz)
+ {
+ return Compare(lpsz) != 0;
+ }
+ bool operator == (LPCTSTR lpsz)
+ {
+ return Compare(lpsz) == 0;
+ }
+ int Find( TCHAR ch, int nStart = 0) const
+ {
+ return (int) find(ch, nStart);
+ }
+
+ int Find( LPCTSTR pstr, int nStart = 0) const
+ {
+ return (int) find(pstr, nStart);
+ }
+
+ int Replace( TCHAR chOld, TCHAR chNew )
+ {
+ int iCount = 0;
+ for (iterator it = begin(); it != end(); ++it)
+ if (*it == chOld)
+ {
+ *it = chNew;
+ iCount++;
+ }
+ return iCount;
+ }
+
+};
+
+/**
+ A poiter type to point to CZipString to Collate or CollateNoCase
+ or Compare or CompareNoCase
+*/
+typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const;
+
+/**
+ return a pointer to the function in CZipString structure,
+ used to compare elements depending on the arguments
+*/
+ ZIP_API ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate = true);
+
+
+#if _MSC_VER > 1000
+ #pragma warning( pop)
+#endif
|