////////////////////////////////////////////////////////////////////////////////
|
// This source file is part of the ZipArchive library source distribution and
|
// is Copyrighted 2000 - 2011 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
|
////////////////////////////////////////////////////////////////////////////////
|
|
/**
|
* \file FileFilter.h
|
* Includes the ZipArchiveLib::CFileFilter and the derived classes.
|
*
|
*/
|
|
|
#if !defined(ZIPARCHIVE_FILEFILTER_DOT_H)
|
#define ZIPARCHIVE_FILEFILTER_DOT_H
|
|
#if _MSC_VER > 1000
|
#pragma once
|
#pragma warning( push )
|
#pragma warning (disable : 4100) // unreferenced formal parameter
|
#endif
|
|
#include "stdafx.h"
|
#include "ZipExport.h"
|
#include "FileInfo.h"
|
#include "Wildcard.h"
|
#include "ZipPlatform.h"
|
#include "ZipCollections.h"
|
|
namespace ZipArchiveLib
|
{
|
/**
|
A base class for filters used in the directory enumeration process.
|
|
\see
|
<a href="kb">0610231446|filters</a>
|
\see
|
CDirEnumerator::Start
|
*/
|
class ZIP_API CFileFilter
|
{
|
public:
|
|
/**
|
Initializes a new instance of the CFileFilter class.
|
|
\param bInverted
|
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
|
|
\see
|
SetInverted
|
*/
|
CFileFilter(bool bInverted = false)
|
:m_bInverted(bInverted)
|
{
|
}
|
|
/**
|
This method is directly called by the CDirEnumerator::Start for each file or directory that was
|
previously accepted with the #HandlesFile method.
|
|
It internally calls the #Accept method and inverts its result, if the filter is in the inverted
|
mode and does not handle the inversion internally.
|
|
- If this method returns \c true for a file, then the file is processed (the CDirEnumerator::Process method
|
is called for the file). Otherwise the file is not processed.
|
- If this method returns \c true for a directory, then the directory can be traversed for files and subfolders
|
(depending on the CDirEnumerator::IsRecursive() method). Otherwise the directory is not traversed.
|
|
|
\param lpszParentDir
|
The parent directory containing the file to accept.
|
|
\param lpszName
|
The name of the file to accept (without a path).
|
|
\param info
|
The structure containing the information about the current file.
|
|
\return
|
\c true, if the file is accepted (taking inversion into account); \c false otherwise.
|
|
\see
|
Accept
|
\see
|
HandlesFile
|
\see
|
HandlesInversion
|
\see
|
SetInverted
|
\see
|
IsInverted
|
\see
|
CDirEnumerator::Start
|
\see
|
CDirEnumerator::Process
|
*/
|
bool Evaluate(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info)
|
{
|
bool ret = Accept(lpszParentDir, lpszName, info);
|
if (!HandlesInversion())
|
return m_bInverted ? !ret : ret;
|
return ret;
|
}
|
|
/**
|
Sets the filter to operate in the inverted or in the normal mode.
|
If the filter operates in an inverted mode, the file that this filer accepts
|
is \b not processed and vice versa. Normal mode means that a file is processed
|
(the CDirEnumerator::Process method is called for that file),
|
if the filter accepts the file.
|
|
\param bInverted
|
\c true to make the filter operate in an inverted mode or \c false to make
|
the filter operate in a normal mode.
|
|
\see
|
HandlesInversion
|
\see
|
IsInverted
|
*/
|
void SetInverted(bool bInverted = true) { m_bInverted = bInverted;}
|
|
/**
|
Returns the value indicating whether the filter operates in an inverted mode or in a normal mode.
|
|
\return
|
\c true, if the filter operates in an inverted mode; \c false otherwise.
|
|
\see
|
SetInverted
|
\see
|
HandlesInversion
|
*/
|
bool IsInverted() const {return m_bInverted;}
|
|
/**
|
Returns the value indicating whether the filter can decide about processing of the \a info file.
|
If it can, then the #Evaluate method will be called for the \a info file.
|
By default this method returns \c true for files and \c false for directories. Override this method
|
to change its behavior.
|
|
- If \a info is a file and this method returns \c false, then the file is not processed.
|
- If \a info is a directory and this method returns \c false, then the directory can still be traversed for files
|
and subfolders (depending on the CDirEnumerator::IsRecursive() method).
|
|
The #Evaluate method is not called in both cases.
|
|
\param info
|
The structure containing the information about the file.
|
|
\return
|
\c true, if the \a info file should be evaluated by the #Evaluate method; \c false otherwise.
|
|
\note
|
This method is particularly useful when the filter operates in the inverted mode (see #SetInverted).
|
For example, if a filter should accept directories in both inverted and non-inverted mode, it would need
|
to specially handle inversion for directories without this method. With this method it can just not accept
|
directories for evaluation and they still will be traversed.
|
*/
|
virtual bool HandlesFile(const CFileInfo& info)
|
{
|
return !info.IsDirectory();
|
}
|
|
virtual ~CFileFilter()
|
{
|
}
|
protected:
|
/**
|
This method is directly called by the #Evaluate method during an enumeration process.
|
|
If this method returns \c true, the file will later be processed
|
by the CDirEnumerator::Process method. If this method returns \c false for a directory,
|
the directory is not enumerated at all.
|
|
The meaning of the return value can be reversed by the #SetInverted method.
|
If this filter handles the inversion internally, the return value from this method
|
is not reversed by the #Evaluate method.
|
|
\param lpszParentDir
|
The parent directory containing the file to accept.
|
|
\param lpszName
|
The name of the file to accept (without a path).
|
|
\param info
|
The structure containing the information about the current file.
|
|
\return
|
\c true, if the file is accepted; \c false otherwise.
|
|
\see
|
Evaluate
|
\see
|
HandlesInversion
|
\see
|
CDirEnumerator::Start
|
\see
|
CDirEnumerator::Process
|
*/
|
virtual bool Accept(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info)
|
{
|
return true;
|
}
|
|
/**
|
Returns the value indicating whether the current filter handles the inversion mode internally
|
or not.
|
- If the filter is in the inverted mode and it handles the inversion, then the return value \c true
|
from the #Accept method means that the file should be processed.
|
- If the filter is in the inverted mode and it does not handle the inversion, then the return value \c true
|
from the #Accept method means that the file should not be processed.
|
|
It may be more efficient to handle the inversion internally in some cases.
|
|
\return
|
\c true, if the filter handles the inversion internally; \c false otherwise.
|
|
\note
|
This method returns \c false by default. Override this method to change this behavior.
|
|
\see
|
SetInverted
|
\see
|
IsInverted
|
*/
|
virtual bool HandlesInversion() const
|
{
|
return false;
|
}
|
bool m_bInverted;
|
|
};
|
|
|
/**
|
A filter that allows filtering files by a filename mask while an enumeration process.
|
|
\see
|
<a href="kb">0610231446|filters</a>
|
\see
|
<a href="kb">0610242025|wildcards</a>
|
\see
|
CDirEnumerator::Start
|
*/
|
class ZIP_API CNameFileFilter : public CFileFilter
|
{
|
CWildcard m_matcher;
|
int m_iAppliesToTypes;
|
public:
|
|
/**
|
The file type to which the CNameFileFilter filter can be applied.
|
You can use the logical \c OR to combine them.
|
|
\see
|
SetAppliesToTypes
|
\see
|
GetAppliesToTypes
|
*/
|
enum AppliesToTypes
|
{
|
toFile = 0x1, ///< Regular files only.
|
toDirectory = 0x2, ///< Directories only.
|
toAll = toFile | toDirectory ///< Both regular files and directories.
|
};
|
|
/**
|
Initializes a new instance of the CNameFileFilter class.
|
|
\param lpszPattern
|
A mask to match against a filename. This filter uses the CWildcard functionality for this purpose.
|
|
\param iAppliesToTypes
|
The file type to which this filter applies. It an be one or more of the #AppliesToTypes values.
|
|
\param bInverted
|
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
|
|
\param bCaseSensitive
|
\c true, if the matching process is case-sensitive; \c false otherwise.
|
By default, a system case-sensitivity setting is used.
|
|
\see
|
<a href="kb">0610231446|filters</a>
|
\see
|
<a href="kb">0610242025|wildcards</a>
|
\see
|
SetInverted
|
\see
|
SetAppliesToTypes
|
\see
|
CWildcard
|
\see
|
ZipPlatform::GetSystemCaseSensitivity
|
*/
|
CNameFileFilter(LPCTSTR lpszPattern = _T("*"), bool bInverted = false, int iAppliesToTypes = toFile, bool bCaseSensitive = ZipPlatform::GetSystemCaseSensitivity())
|
:CFileFilter(bInverted), m_matcher(lpszPattern, bCaseSensitive)
|
{
|
m_iAppliesToTypes = iAppliesToTypes;
|
}
|
|
/**
|
Returns the value indicating whether the filter can be applied to the given \a iType type.
|
|
\param iType
|
It can be one or more of the #AppliesToTypes values.
|
|
\return
|
\c true, if the filter can be applied to \a iType type; \c false otherwise.
|
|
\see
|
SetAppliesToTypes
|
\see
|
GetAppliesToTypes
|
*/
|
bool AppliesToType(int iType)
|
{
|
return (m_iAppliesToTypes & iType) == iType;
|
}
|
|
/**
|
Sets the file type to which this filter applies.
|
|
\param iType
|
The file type to which this filter applies. It can be one or more of the #AppliesToTypes values.
|
|
\see
|
GetAppliesToTypes
|
|
*/
|
void SetAppliesToTypes(int iType) { m_iAppliesToTypes = iType; }
|
|
/**
|
Returns the file type to which this filter applies.
|
|
\return
|
The file type to which this filter applies. It can be one or more of the #AppliesToTypes values.
|
|
\see
|
SetAppliesToTypes
|
*/
|
int GetAppliesToTypes() {return m_iAppliesToTypes;}
|
|
/**
|
Returns the value indicating whether the filter can decide about processing of the \a info file.
|
The CNameFileFilter returns the value depending on the #GetAppliesToTypes value.
|
|
\param info
|
The structure containing the information about the file.
|
|
\return
|
\c true, if the \a info file will be evaluated by the #Evaluate method; \c false otherwise.
|
|
\see
|
GetAppliesToTypes
|
\see
|
SetAppliesToTypes
|
|
*/
|
bool HandlesFile(const CFileInfo& info)
|
{
|
return info.IsDirectory() ? AppliesToType(toDirectory) : AppliesToType(toFile);
|
}
|
protected:
|
virtual bool Accept(LPCTSTR, LPCTSTR lpszName, const CFileInfo& info)
|
{
|
return m_matcher.IsMatch(lpszName);
|
}
|
};
|
|
/**
|
A filter that allows grouping of other filters.
|
|
\see
|
<a href="kb">0610231446|filters</a>
|
\see
|
CDirEnumerator::Start
|
*/
|
class ZIP_API CGroupFileFilter : public CFileFilter
|
{
|
|
public:
|
|
/**
|
The grouping type.
|
*/
|
enum GroupType
|
{
|
And, ///< Logical AND. All the grouped filters must accept a file for the file to be processed.
|
Or ///< Logical OR. At least one of the grouped filters must accept a file for the file to be processed.
|
};
|
|
/**
|
Initializes a new instance of the CGroupFileFilter class.
|
|
\param groupType
|
The grouping type. Should be one of the #GroupType values.
|
|
\param bAutoDelete
|
\c true, if the grouped filters should be automatically destroyed by this filter; \c false otherwise.
|
|
\param bInverted
|
Set to \c true to invert the behavior of the filter or to \c false for the normal behavior.
|
This filter handles the inversion mode internally.
|
|
\see
|
<a href="kb">0610231446|filters</a>
|
\see
|
SetType
|
\see
|
SetAutoDelete
|
\see
|
SetInverted
|
\see
|
HandlesInversion
|
*/
|
CGroupFileFilter(GroupType groupType = CGroupFileFilter::And, bool bAutoDelete = true, bool bInverted = false)
|
:CFileFilter(bInverted), m_iType(groupType), m_bAutoDelete(bAutoDelete)
|
{
|
}
|
|
/**
|
Adds \a pFilter to the filter's group.
|
|
\param pFilter
|
The filter to add.
|
*/
|
void Add(CFileFilter* pFilter)
|
{
|
m_filters.Add(pFilter);
|
}
|
|
/**
|
Returns the filter at the given position.
|
|
\param uIndex
|
The index of the filter to return.
|
*/
|
CFileFilter* GetAt(ZIP_ARRAY_SIZE_TYPE uIndex)
|
{
|
return m_filters[uIndex];
|
}
|
|
/**
|
Returns the filter at the given position.
|
|
\param uIndex
|
The index of the filter to return.
|
*/
|
const CFileFilter* GetAt(ZIP_ARRAY_SIZE_TYPE uIndex) const
|
{
|
return m_filters[uIndex];
|
}
|
|
/**
|
Returns the filter at the given position.
|
|
\param uIndex
|
The index of the filter to return.
|
*/
|
const CFileFilter* operator[] (ZIP_ARRAY_SIZE_TYPE uIndex) const
|
{
|
return GetAt(uIndex);
|
}
|
|
/**
|
Returns the filter at the given position.
|
|
\param uIndex
|
The index of the filter to return.
|
*/
|
CFileFilter* operator[] (ZIP_ARRAY_SIZE_TYPE uIndex)
|
{
|
return GetAt(uIndex);
|
}
|
|
/**
|
Remove the filter at the given position.
|
The removed filter is deleted from memory,
|
if the CGroupFileFilter object is in the auto-delete mode.
|
|
\param uIndex
|
The index of the filter to remove.
|
|
\see
|
SetAutoDelete
|
*/
|
void RemoveAt(ZIP_ARRAY_SIZE_TYPE uIndex)
|
{
|
CFileFilter* filter = m_filters[uIndex];
|
// first remove, then delete
|
m_filters.RemoveAt(uIndex);
|
if (m_bAutoDelete)
|
delete filter;
|
}
|
|
|
/**
|
Removes all contained filters from the collection.
|
|
The removed filters are deleted from memory,
|
if the CGroupFileFilter object is in the auto-delete mode.
|
|
\see
|
SetAutoDelete
|
|
*/
|
void Clear()
|
{
|
if (m_filters.GetSize() == 0)
|
return;
|
|
ZIP_ARRAY_SIZE_TYPE i = m_filters.GetSize() - 1;
|
for (; ;)
|
{
|
RemoveAt(i);
|
if (i == 0)
|
break;
|
i--;
|
}
|
}
|
|
/**
|
Returns the number of grouped filters.
|
|
\return
|
The number of grouped filters.
|
|
*/
|
ZIP_ARRAY_SIZE_TYPE GetSize()
|
{
|
return m_filters.GetSize();
|
}
|
|
/**
|
Sets the type of grouping.
|
|
\param iType
|
The type of grouping. Should be one of the #GroupType values.
|
|
\see
|
GetType
|
*/
|
void SetType(GroupType iType) {m_iType = iType;}
|
|
/**
|
Returns the type of grouping.
|
|
\return
|
The type of grouping. It can be one of the #GroupType values.
|
|
\see
|
SetType
|
*/
|
GroupType GetType() const {return m_iType;}
|
|
/**
|
Enables or disables auto-deletion of grouped filters.
|
If auto-deletion is enabled, the grouped filters are released from memory
|
when they are removed from the group or when the CGroupFileFilter
|
object is destroyed.
|
|
\param bAutoDelete
|
\c true, to enable auto-deletion; \c false to disable.
|
|
\see
|
IsAutoDelete
|
*/
|
void SetAutoDelete(bool bAutoDelete) {m_bAutoDelete = bAutoDelete;}
|
|
/**
|
Returns the value indicating whether the auto-deletion is enabled.
|
|
\return
|
\c true, if the auto-deletion is enabled; \c false otherwise.
|
|
\see
|
SetAutoDelete
|
*/
|
bool IsAutoDelete() const {return m_bAutoDelete;}
|
|
/**
|
Returns the value indicating whether the filter can decide about processing of the \a info file.
|
The CGroupFileFilter returns the value depending on the value returned by the grouped filters.
|
|
\param info
|
The structure containing the information about the file.
|
|
\return
|
\c true, if any of the grouped filters accepts \a info; \c false otherwise.
|
|
*/
|
bool HandlesFile(const CFileInfo& info)
|
{
|
for (ZIP_ARRAY_SIZE_TYPE i = 0; i < m_filters.GetSize(); i++)
|
// it is enough that one filter handles it
|
if (m_filters[i]->HandlesFile(info))
|
return true;
|
return false;
|
}
|
|
|
~CGroupFileFilter()
|
{
|
Clear();
|
}
|
|
protected:
|
|
virtual bool Accept(LPCTSTR lpszParentDir, LPCTSTR lpszName, const CFileInfo& info);
|
/**
|
This filter handles the inversion mode internally.
|
|
\return
|
This method returns \c true for this class.
|
|
\see
|
CFileFilter::HandlesInversion
|
*/
|
bool HandlesInversion() const
|
{
|
return true;
|
}
|
GroupType m_iType; ///< Set with the #SetType method or in constructor.
|
bool m_bAutoDelete; ///< Set with the #SetAutoDelete or in constructor.
|
|
private:
|
|
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
|
#pragma warning (push)
|
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
|
#endif
|
|
CZipArray<CFileFilter*> m_filters;
|
|
#if (_MSC_VER > 1000) && (defined ZIP_HAS_DLL)
|
#pragma warning( pop)
|
#endif
|
|
};
|
}
|
|
#if _MSC_VER > 1000
|
#pragma warning( pop )
|
#endif
|
|
#endif
|
