Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Core/FileSystemScanner.cs

@@ -0,0 +1,380 @@
+// FileSystemScanner.cs
+//
+// Copyright 2005 John Reilly
+//
+// 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.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library.  Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+// 
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module.  An independent module is a module which is not derived from
+// or based on this library.  If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so.  If you do not wish to do so, delete this
+// exception statement from your version.
+
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.SharpZipLib.Core
+{
+	/// <summary>
+	/// Event arguments for scanning.
+	/// </summary>
+	public class ScanEventArgs : EventArgs
+	{
+		/// <summary>
+		/// Initialise a new instance of <see cref="ScanEventArgs"/>
+		/// </summary>
+		/// <param name="name"></param>
+		public ScanEventArgs(string name)
+		{
+			this.name = name;
+			ContinueRunning = true;
+		}
+		
+		string name;
+		
+		/// <summary>
+		/// The name for this event.
+		/// </summary>
+		public string Name
+		{
+			get { return name; }
+		}
+		
+		bool continueRunning;
+		
+		/// <summary>
+		/// Get set a value indicating if scanning should continue or not.
+		/// </summary>
+		public bool ContinueRunning
+		{
+			get { return continueRunning; }
+			set { continueRunning = value; }
+		}
+	}
+
+	/// <summary>
+	/// Event arguments for directories.
+	/// </summary>
+	public class DirectoryEventArgs : ScanEventArgs
+	{
+		/// <summary>
+		/// Initialize an instance of <see cref="DirectoryEventArgs"></see>.
+		/// </summary>
+		/// <param name="name">The name for this directory.</param>
+		/// <param name="hasMatchingFiles">Flag value indicating if any matching files are contained in this directory.</param>
+		public DirectoryEventArgs(string name, bool hasMatchingFiles)
+			: base (name)
+		{
+			this.hasMatchingFiles = hasMatchingFiles;
+		}
+		
+		/// <summary>
+		/// Get a value indicating if the directory contains any matching files or not.
+		/// </summary>
+		public bool HasMatchingFiles
+		{
+			get { return hasMatchingFiles; }
+		}
+		
+		bool hasMatchingFiles;
+	}
+	
+	/// <summary>
+	/// Arguments passed when scan failures are detected.
+	/// </summary>
+	public class ScanFailureEventArgs
+	{
+		/// <summary>
+		/// Initialise a new instance of <see cref="ScanFailureEventArgs"></see>
+		/// </summary>
+		/// <param name="name">The name to apply.</param>
+		/// <param name="e">The exception to use.</param>
+		public ScanFailureEventArgs(string name, Exception e)
+		{
+			this.name = name;
+			this.exception = e;
+			continueRunning = true;
+		}
+		
+		string name;
+		
+		/// <summary>
+		/// The applicable name.
+		/// </summary>
+		public string Name
+		{
+			get { return name; }
+		}
+		
+		Exception exception;
+		
+		/// <summary>
+		/// The applicable exception.
+		/// </summary>
+		public Exception Exception
+		{
+			get { return exception; }
+		}
+
+		bool continueRunning;
+		
+		/// <summary>
+		/// Get / set a value indicating wether scanning should continue.
+		/// </summary>
+		public bool ContinueRunning
+		{
+			get { return continueRunning; }
+			set { continueRunning = value; }
+		}
+	}
+	
+	/// <summary>
+	/// Delegate invokked when a directory is processed.
+	/// </summary>
+	public delegate void ProcessDirectoryDelegate(object Sender, DirectoryEventArgs e);
+	
+	/// <summary>
+	/// Delegate invoked when a file is processed.
+	/// </summary>
+	public delegate void ProcessFileDelegate(object sender, ScanEventArgs e);
+	
+	/// <summary>
+	/// Delegate invoked when a directory failure is detected.
+	/// </summary>
+	public delegate void DirectoryFailureDelegate(object sender, ScanFailureEventArgs e);
+	
+	/// <summary>
+	/// Delegate invoked when a file failure is detected.
+	/// </summary>
+	public delegate void FileFailureDelegate(object sender, ScanFailureEventArgs e);
+
+	/// <summary>
+	/// FileSystemScanner provides facilities scanning of files and directories.
+	/// </summary>
+	public class FileSystemScanner
+	{
+		/// <summary>
+		/// Initialise a new instance of <see cref="FileSystemScanner"></see>
+		/// </summary>
+		/// <param name="filter">The file filter to apply when scanning.</param>
+		public FileSystemScanner(string filter)
+		{
+			fileFilter = new PathFilter(filter);
+		}
+		
+		/// <summary>
+		/// Initialise a new instance of <see cref="FileSystemScanner"></see>
+		/// </summary>
+		/// <param name="fileFilter">The file <see cref="NameFilter"></see>filter to apply.</param>
+		/// <param name="directoryFilter">The directory <see cref="NameFilter"></see>filter to apply.</param>
+		public FileSystemScanner(string fileFilter, string directoryFilter)
+		{
+			this.fileFilter = new PathFilter(fileFilter);
+			this.directoryFilter = new PathFilter(directoryFilter);
+		}
+		
+		/// <summary>
+		/// Initialise a new instance of <see cref="FileSystemScanner"></see>
+		/// </summary>
+		/// <param name="fileFilter">The file <see cref="NameFilter"></see>filter to apply.</param>
+		public FileSystemScanner(IScanFilter fileFilter)
+		{
+			this.fileFilter = fileFilter;
+		}
+		
+		/// <summary>
+		/// Initialise a new instance of <see cref="FileSystemScanner"></see>
+		/// </summary>
+		/// <param name="fileFilter">The file <see cref="IScanFilter"></see>filter to apply.</param>
+		/// <param name="directoryFilter">The directory <see cref="IScanFilter"></see>filter to apply.</param>
+		public FileSystemScanner(IScanFilter fileFilter, IScanFilter directoryFilter)
+		{
+			this.fileFilter = fileFilter;
+			this.directoryFilter = directoryFilter;
+		}
+		
+		/// <summary>
+		/// Delegate to invoke when a directory is processed.
+		/// </summary>
+		public ProcessDirectoryDelegate ProcessDirectory;
+		
+		/// <summary>
+		/// Delegate to invoke when a file is processed.
+		/// </summary>
+		public ProcessFileDelegate ProcessFile;
+
+		/// <summary>
+		/// Delegate to invoke when a directory failure is detected.
+		/// </summary>
+		public DirectoryFailureDelegate DirectoryFailure;
+		
+		/// <summary>
+		/// Delegate to invoke when a file failure is detected.
+		/// </summary>
+		public FileFailureDelegate FileFailure;
+		
+		/// <summary>
+		/// Raise the DirectoryFailure event.
+		/// </summary>
+		/// <param name="directory">Rhe directory name.</param>
+		/// <param name="e">The exception detected.</param>
+		public void OnDirectoryFailure(string directory, Exception e)
+		{
+			if ( DirectoryFailure == null ) {
+				alive = false;
+			} else {
+				ScanFailureEventArgs args = new ScanFailureEventArgs(directory, e);
+				DirectoryFailure(this, args);
+				alive = args.ContinueRunning;
+			}
+		}
+		
+		/// <summary>
+		/// Raise the FileFailure event.
+		/// </summary>
+		/// <param name="file">The file name.</param>
+		/// <param name="e">The exception detected.</param>
+		public void OnFileFailure(string file, Exception e)
+		{
+			if ( FileFailure == null ) {
+				alive = false;
+			} else {
+				ScanFailureEventArgs args = new ScanFailureEventArgs(file, e);
+				FileFailure(this, args);
+				alive = args.ContinueRunning;
+			}
+		}
+
+		/// <summary>
+		/// Raise the ProcessFile event.
+		/// </summary>
+		/// <param name="file">The file name.</param>
+		public void OnProcessFile(string file)
+		{
+			if ( ProcessFile != null ) {
+				ScanEventArgs args = new ScanEventArgs(file);
+				ProcessFile(this, args);
+				alive = args.ContinueRunning;
+			}
+		}
+		
+		/// <summary>
+		/// Raise the ProcessDirectory event.
+		/// </summary>
+		/// <param name="directory">The directory name.</param>
+		/// <param name="hasMatchingFiles">Flag indicating if the directory has matching files.</param>
+		public void OnProcessDirectory(string directory, bool hasMatchingFiles)
+		{
+			if ( ProcessDirectory != null ) {
+				DirectoryEventArgs args = new DirectoryEventArgs(directory, hasMatchingFiles);
+				ProcessDirectory(this, args);
+				alive = args.ContinueRunning;
+			}
+		}
+
+		/// <summary>
+		/// Scan a directory.
+		/// </summary>
+		/// <param name="directory">The base directory to scan.</param>
+		/// <param name="recurse">True to recurse subdirectories, false to do a single directory.</param>
+		public void Scan(string directory, bool recurse)
+		{
+			alive = true;
+			ScanDir(directory, recurse);
+		}
+		
+		void ScanDir(string directory, bool recurse)
+		{
+
+			try {
+				string[] names = System.IO.Directory.GetFiles(directory);
+				bool hasMatch = false;
+				for (int fileIndex = 0; fileIndex < names.Length; ++fileIndex) {
+					if ( !fileFilter.IsMatch(names[fileIndex]) ) {
+						names[fileIndex] = null;
+					} else {
+						hasMatch = true;
+					}
+				}
+				
+				OnProcessDirectory(directory, hasMatch);
+				
+				if ( alive && hasMatch ) {
+					foreach (string fileName in names) {
+						try {
+							if ( fileName != null ) {
+								OnProcessFile(fileName);
+								if ( !alive ) {
+									break;
+								}
+							}
+						}
+						catch (Exception e)
+						{
+							OnFileFailure(fileName, e);
+						}
+					}
+				}
+			}
+			catch (Exception e) {
+				OnDirectoryFailure(directory, e);
+			}
+
+			if ( alive && recurse ) {
+				try {
+					string[] names = System.IO.Directory.GetDirectories(directory);
+					foreach (string fulldir in names) {
+						if ((directoryFilter == null) || (directoryFilter.IsMatch(fulldir))) {
+							ScanDir(fulldir, true);
+							if ( !alive ) {
+								break;
+							}
+						}
+					}
+				}
+				catch (Exception e) {
+					OnDirectoryFailure(directory, e);
+				}
+			}
+		}
+		
+		#region Instance Fields
+		/// <summary>
+		/// The file filter currently in use.
+		/// </summary>
+		IScanFilter fileFilter;
+		/// <summary>
+		/// The directory filter currently in use.
+		/// </summary>
+		IScanFilter directoryFilter;
+		/// <summary>
+		/// Falg indicating if scanning is still alive.  Used to cancel a scan.
+		/// </summary>
+		bool alive;
+		#endregion
+	}
+}

mcs/class/ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Core/INameTransform.cs

@@ -0,0 +1,57 @@
+// INameTransform.cs
+//
+// Copyright 2005 John Reilly
+//
+// 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.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library.  Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+// 
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module.  An independent module is a module which is not derived from
+// or based on this library.  If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so.  If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace ICSharpCode.SharpZipLib.Core
+{
+	/// <summary>
+	/// INameTransform defines how file system names are transformed for use with archives.
+	/// </summary>
+	public interface INameTransform
+	{
+		/// <summary>
+		/// Given a file name determine the transformed equivalent.
+		/// </summary>
+		/// <param name="name">The name to transform.</param>
+		/// <returns>The transformed name.</returns>
+		string TransformFile(string name);
+		
+		/// <summary>
+		/// Given a directory name determine the transformed equivalent.
+		/// </summary>
+		/// <param name="name">The name to transform.</param>
+		/// <returns>The transformed directory name</returns>
+		string TransformDirectory(string name);
+	}
+}

mcs/class/ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Core/NameFilter.cs

@@ -0,0 +1,213 @@
+// NameFilter.cs
+//
+// Copyright 2005 John Reilly
+//
+// 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.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library.  Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+// 
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module.  An independent module is a module which is not derived from
+// or based on this library.  If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so.  If you do not wish to do so, delete this
+// exception statement from your version.
+
+
+using System;
+using System.Collections;
+using System.Text.RegularExpressions;
+
+namespace ICSharpCode.SharpZipLib.Core
+{
+	/// <summary>
+	/// NameFilter is a string matching class which allows for both positive and negative
+	/// matching.
+	/// A filter is a sequence of independant <see cref="Regex"></see> regular expressions separated by semi-colons ';'
+	/// Each expression can be prefixed by a plus '+' sign or a minus '-' sign to denote the expression
+	/// is intended to include or exclude names.  If neither a plus or minus sign is found include is the default
+	/// A given name is tested for inclusion before checking exclusions.  Only names matching an include spec 
+	/// and not matching an exclude spec are deemed to match the filter.
+	/// An empty filter matches any name.
+	/// </summary>
+	public class NameFilter
+	{
+		/// <summary>
+		/// Construct an instance based on the filter expression passed
+		/// </summary>
+		/// <param name="filter">The filter expression.</param>
+		public NameFilter(string filter)
+		{
+			this.filter = filter;
+			inclusions = new ArrayList();
+			exclusions = new ArrayList();
+			Compile();
+		}
+
+		/// <summary>
+		/// Test a string to see if it is a valid regular expression.
+		/// </summary>
+		/// <param name="e">The expression to test.</param>
+		/// <returns>True if expression is a valid <see cref="System.Text.RegularExpressions.Regex"/> false otherwise.</returns>
+		public static bool IsValidExpression(string e)
+		{
+			bool result = true;
+			try {
+				Regex exp = new Regex(e, RegexOptions.IgnoreCase | RegexOptions.Singleline);
+			}
+			catch {
+				result = false;
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// Test an expression to see if it is valid as a filter.
+		/// </summary>
+		/// <param name="toTest">The filter expression to test.</param>
+		/// <returns>True if the expression is valid, false otherwise.</returns>
+		public static bool IsValidFilterExpression(string toTest)
+		{
+			bool result = true;
+		
+			try
+			{
+				string[] items = toTest.Split(';');
+				for (int i = 0; i < items.Length; ++i) {
+					if (items[i] != null && items[i].Length > 0) {
+						string toCompile;
+			
+						if (items[i][0] == '+')
+							toCompile = items[i].Substring(1, items[i].Length - 1);
+						else if (items[i][0] == '-')
+							toCompile = items[i].Substring(1, items[i].Length - 1);
+						else
+							toCompile = items[i];
+			
+						Regex testRE = new Regex(toCompile, RegexOptions.IgnoreCase | RegexOptions.Singleline);
+					}
+				}
+			}
+			catch (Exception) {
+				result = false;
+		 	}
+		
+			return result;
+		}
+
+		/// <summary>
+		/// Convert this filter to its string equivalent.
+		/// </summary>
+		/// <returns>The string equivalent for this filter.</returns>
+		public override string ToString()
+		{
+			return filter;
+		}
+		
+		/// <summary>
+		/// Test a value to see if it is included by the filter.
+		/// </summary>
+		/// <param name="testValue">The value to test.</param>
+		/// <returns>True if the value is included, false otherwise.</returns>
+		public bool IsIncluded(string testValue)
+		{
+			bool result = false;
+			if (inclusions.Count == 0)
+				result = true;
+			else {
+				foreach (Regex r in inclusions) {
+					if (r.IsMatch(testValue)) {
+						result = true;
+						break;
+					}
+				}
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// Test a value to see if it is excluded by the filter.
+		/// </summary>
+		/// <param name="testValue">The value to test.</param>
+		/// <returns>True if the value is excluded, false otherwise.</returns>
+		public bool IsExcluded(string testValue)
+		{
+			bool result = false;
+			foreach (Regex r in exclusions) {
+				if (r.IsMatch(testValue)) {
+					result = true;
+					break;
+				}
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// Test a value to see if it matches the filter.
+		/// </summary>
+		/// <param name="testValue">The value to test.</param>
+		/// <returns>True if the value matches, false otherwise.</returns>
+		public bool IsMatch(string testValue)
+		{
+			return IsIncluded(testValue) == true && IsExcluded(testValue) == false;
+		}
+
+		/// <summary>
+		/// Compile this filter.
+		/// </summary>
+		void Compile()
+		{
+			if (filter == null)
+				return;
+
+			string[] items = filter.Split(';');
+			for (int i = 0; i < items.Length; ++i) {
+				if (items[i] != null && items[i].Length > 0) {
+					bool include = items[i][0] != '-';
+					string toCompile;
+
+					if (items[i][0] == '+')
+						toCompile = items[i].Substring(1, items[i].Length - 1);
+					else if (items[i][0] == '-')
+						toCompile = items[i].Substring(1, items[i].Length - 1);
+					else
+						toCompile = items[i];
+
+					// NOTE: Regular expressions can fail to compile here for a number of reasons that cause an exception
+					// these are left unhandled here as the caller is responsible for ensuring all is valid.
+					// several functions IsValidFilterExpression and IsValidExpression are provided for such checking
+					if (include)
+						inclusions.Add(new Regex(toCompile, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline));
+					else
+						exclusions.Add(new Regex(toCompile, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline));
+				}
+			}
+		}
+
+		#region Instance Fields
+			string filter;
+			ArrayList inclusions;
+			ArrayList exclusions;
+		#endregion
+	}
+}

mcs/class/ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Core/PathFilter.cs

@@ -0,0 +1,137 @@
+// PathFilter.cs
+//
+// Copyright 2005 John Reilly
+//
+// 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.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library.  Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+// 
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module.  An independent module is a module which is not derived from
+// or based on this library.  If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so.  If you do not wish to do so, delete this
+// exception statement from your version.
+
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.SharpZipLib.Core
+{
+	/// <summary>
+	/// Scanning filters support these operations.
+	/// </summary>
+	public interface IScanFilter
+	{
+		/// <summary>
+		/// Test a name to see if is 'matches' the filter.
+		/// </summary>
+		/// <param name="name">The name to test.</param>
+		/// <returns>Returns true if the name matches the filter, false if it does not match.</returns>
+		bool IsMatch(string name);
+	}
+	
+	/// <summary>
+	/// PathFilter filters directories and files by full path name.
+	/// </summary>
+	public class PathFilter : IScanFilter
+	{
+		/// <summary>
+		/// Initialise a new instance of <see cref="PathFilter"></see>.
+		/// </summary>
+		/// <param name="filter">The <see cref="NameFilter"></see>filter expression to apply.</param>
+		public PathFilter(string filter)
+		{
+			nameFilter = new NameFilter(filter);
+		}
+
+		/// <summary>
+		/// Test a name to see if it matches the filter.
+		/// </summary>
+		/// <param name="name">The name to test.</param>
+		/// <returns>True if the name matches, false otherwise.</returns>
+		public virtual bool IsMatch(string name)
+		{
+			return nameFilter.IsMatch(Path.GetFullPath(name));
+		}
+		
+		#region Instance Fields
+		NameFilter nameFilter;
+		#endregion
+	}
+
+	/// <summary>
+	/// NameAnsSizeFilter filters based on name and file size.
+	/// </summary>
+	public class NameAndSizeFilter : PathFilter
+	{
+	
+		/// <summary>
+		/// Initialise a new instance of NameAndSizeFilter.
+		/// </summary>
+		/// <param name="filter">The filter to apply.</param>
+		/// <param name="minSize">The minimum file size to include.</param>
+		/// <param name="maxSize">The maximum file size to include.</param>
+		public NameAndSizeFilter(string filter, long minSize, long maxSize) : base(filter)
+		{
+			this.minSize = minSize;
+			this.maxSize = maxSize;
+		}
+		
+		/// <summary>
+		/// Test a filename to see if it matches the filter.
+		/// </summary>
+		/// <param name="fileName">The filename to test.</param>
+		/// <returns>True if the filter matches, false otherwise.</returns>
+		public override bool IsMatch(string fileName)
+		{
+			FileInfo fileInfo = new FileInfo(fileName);
+			long length = fileInfo.Length;
+			return base.IsMatch(fileName) &&
+				(MinSize <= length) && (MaxSize >= length);
+		}
+		
+		long minSize = 0;
+		
+		/// <summary>
+		/// The minimum size for a file that will match this filter.
+		/// </summary>
+		public long MinSize
+		{
+			get { return minSize; }
+			set { minSize = value; }
+		}
+		
+		long maxSize = long.MaxValue;
+		
+		/// <summary>
+		/// The maximum size for a file that will match this filter.
+		/// </summary>
+		public long MaxSize
+		{
+			get { return maxSize; }
+			set { maxSize = value; }
+		}
+	}
+}