424 lines
13 KiB
C++
424 lines
13 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// This source file is part of the ZipArchive library source distribution and
|
|
// is Copyrighted 2000 - 2012 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
|
|
#pragma warning( disable : 4275 ) // non dll-interface class used as base for dll-interface
|
|
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
|
|
#endif
|
|
|
|
|
|
#include <cstring>
|
|
#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
|
|
{
|
|
stdbs m_str;
|
|
|
|
void TrimInternalL(stdbs::size_type iPos)
|
|
{
|
|
if (iPos == stdbs::npos)
|
|
m_str.erase ();
|
|
if (iPos)
|
|
m_str.erase(0, iPos);
|
|
}
|
|
void TrimInternalR(stdbs::size_type iPos)
|
|
{
|
|
if (iPos == stdbs::npos)
|
|
m_str.erase ();
|
|
m_str.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):m_str(nRepeat, ch){}
|
|
CZipString( const CZipString& stringSrc ) {m_str.assign(stringSrc.m_str);}
|
|
CZipString( const stdbs& stringSrc ) {m_str.assign(stringSrc);}
|
|
CZipString( LPCTSTR lpsz ){if (!lpsz) Empty(); else m_str.assign(lpsz);}
|
|
operator LPCTSTR() const{return m_str.c_str();}
|
|
operator stdbs&() {return m_str;}
|
|
operator const stdbs&() const {return m_str;}
|
|
void SetString(stdbs& stringSrc)
|
|
{
|
|
m_str = stringSrc;
|
|
}
|
|
|
|
int GetLength() const {return (int) m_str.size();}
|
|
bool IsEmpty() const {return m_str.empty();}
|
|
void Empty() {m_str.erase(m_str.begin(), m_str.end());}
|
|
TCHAR GetAt (int iIndex) const{return m_str.at(iIndex);}
|
|
TCHAR operator[] (int iIndex) const{return m_str.at(iIndex);}
|
|
void SetAt( int nIndex, TCHAR ch ) {m_str.at(nIndex) = ch;}
|
|
LPTSTR GetBuffer(int nMinBufLength)
|
|
{
|
|
if ((int)m_str.size() < nMinBufLength)
|
|
m_str.resize(nMinBufLength);
|
|
return m_str.empty() ? const_cast<TCHAR*>(m_str.data()) : &(m_str.at(0));
|
|
}
|
|
void ReleaseBuffer( int nNewLength = -1 ) { m_str.resize(nNewLength > -1 ? nNewLength : zslen(m_str.c_str()));}
|
|
void TrimLeft( TCHAR chTarget )
|
|
{
|
|
TrimInternalL(m_str.find_first_not_of(chTarget));
|
|
}
|
|
void TrimLeft( LPCTSTR lpszTargets )
|
|
{
|
|
TrimInternalL(m_str.find_first_not_of(lpszTargets));
|
|
}
|
|
void TrimRight( TCHAR chTarget )
|
|
{
|
|
TrimInternalR(m_str.find_last_not_of(chTarget));
|
|
}
|
|
void TrimRight( LPCTSTR lpszTargets )
|
|
{
|
|
TrimInternalR(m_str.find_last_not_of(lpszTargets));
|
|
}
|
|
|
|
CZipString& operator+=(TCHAR str)
|
|
{
|
|
return operator+=(CZipString(str));
|
|
}
|
|
|
|
CZipString& operator+=(const CZipString& str)
|
|
{
|
|
m_str += str.m_str;
|
|
return *this;
|
|
}
|
|
|
|
CZipString& operator+=(const stdbs& str)
|
|
{
|
|
return operator+=(CZipString(str));
|
|
}
|
|
|
|
CZipString& operator+=(LPCTSTR str)
|
|
{
|
|
return operator+=(CZipString(str));
|
|
}
|
|
|
|
CZipString operator+(TCHAR str) const
|
|
{
|
|
return operator+(CZipString(str));
|
|
}
|
|
|
|
CZipString operator+(const CZipString& str) const
|
|
{
|
|
return CZipString(m_str + str.m_str);
|
|
}
|
|
|
|
CZipString operator+(const stdbs& str) const
|
|
{
|
|
return operator+(CZipString(str));
|
|
}
|
|
|
|
CZipString operator+(LPCTSTR str) const
|
|
{
|
|
return operator+(CZipString(str));
|
|
}
|
|
|
|
|
|
#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 ){m_str.insert(nIndex, pstr, zslen(pstr));}
|
|
void Insert( int nIndex, TCHAR ch ) {m_str.insert(nIndex, 1, ch);}
|
|
int Delete( int nIndex, int nCount = 1 )
|
|
{
|
|
int iSize = (int) m_str.size();
|
|
int iToDelete = iSize < nIndex + nCount ? iSize - nIndex : nCount;
|
|
if (iToDelete > 0)
|
|
{
|
|
m_str.erase(nIndex, iToDelete);
|
|
iSize -= iToDelete;
|
|
}
|
|
return iSize;
|
|
}
|
|
#ifndef __MINGW32__
|
|
void MakeLower()
|
|
{
|
|
std::transform(m_str.begin(),m_str.end(),m_str.begin(),tl);
|
|
}
|
|
void MakeUpper()
|
|
{
|
|
std::transform(m_str.begin(),m_str.end(),m_str.begin(),tu);
|
|
}
|
|
#else
|
|
void MakeLower()
|
|
{
|
|
std::transform(m_str.begin(),m_str.end(),m_str.begin(),tolower);
|
|
}
|
|
void MakeUpper()
|
|
{
|
|
std::transform(m_str.begin(),m_str.end(),m_str.begin(),toupper);
|
|
}
|
|
#endif
|
|
void MakeReverse()
|
|
{
|
|
std::reverse(m_str.begin(), m_str.end());
|
|
|
|
}
|
|
CZipString Left( int nCount ) const { return m_str.substr(0, nCount);}
|
|
CZipString Right( int nCount) const
|
|
{
|
|
int s = (int)m_str.size();
|
|
nCount = s < nCount ? s : nCount;
|
|
return m_str.substr(s - nCount);
|
|
}
|
|
CZipString Mid( int nFirst ) const {return m_str.substr(nFirst);}
|
|
CZipString Mid( int nFirst, int nCount ) const {return m_str.substr(nFirst, nCount);}
|
|
int Collate( LPCTSTR lpsz ) const
|
|
{
|
|
#if !defined __GNUC__ || defined __MINGW32__
|
|
return _tcscoll(m_str.c_str(), lpsz);
|
|
#else
|
|
//return m_str.compare(lpsz);
|
|
return strcoll(m_str.c_str(), lpsz);
|
|
#endif
|
|
}
|
|
|
|
int CollateNoCase( LPCTSTR lpsz ) const
|
|
{
|
|
#if !defined __GNUC__ || defined __MINGW32__
|
|
return _tcsicoll(m_str.c_str(), lpsz);
|
|
#else
|
|
if (std::locale() == std::locale::classic())
|
|
return strcasecmp(m_str.c_str(), lpsz);
|
|
else
|
|
// this may be not case-insensitive !!!
|
|
return strcoll(m_str.c_str(), lpsz);
|
|
//return stricoll(m_str.c_str(), lpsz);
|
|
#endif
|
|
}
|
|
|
|
int Compare( LPCTSTR lpsz ) const
|
|
{
|
|
return m_str.compare(lpsz);
|
|
}
|
|
|
|
int CompareNoCase( LPCTSTR lpsz ) const
|
|
{
|
|
#if !defined __GNUC__ || defined __MINGW32__
|
|
return _tcsicmp(m_str.c_str(), lpsz);
|
|
#else
|
|
return strcasecmp(m_str.c_str(), lpsz);
|
|
//return stricmp(m_str.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) m_str.find(ch, nStart);
|
|
}
|
|
|
|
int Find( LPCTSTR pstr, int nStart = 0) const
|
|
{
|
|
return (int) m_str.find(pstr, nStart);
|
|
}
|
|
|
|
int Replace( TCHAR chOld, TCHAR chNew )
|
|
{
|
|
int iCount = 0;
|
|
for (stdbs::iterator it = m_str.begin(); it != m_str.end(); ++it)
|
|
if (*it == chOld)
|
|
{
|
|
*it = chNew;
|
|
iCount++;
|
|
}
|
|
return iCount;
|
|
}
|
|
};
|
|
|
|
inline bool operator<(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) < 0);
|
|
}
|
|
|
|
inline bool operator>(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) > 0);
|
|
}
|
|
|
|
inline bool operator<=(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) <= 0);
|
|
}
|
|
|
|
inline bool operator>=(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) >= 0);
|
|
}
|
|
|
|
inline bool operator==(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) == 0);
|
|
}
|
|
|
|
inline bool operator!=(
|
|
const CZipString& left,
|
|
const CZipString& right)
|
|
{
|
|
return (left.Compare(right) != 0);
|
|
}
|
|
|
|
/**
|
|
A pointer 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
|