public void CreateZip(Stream outputStream, string sourceDirectory, bool recurse, string fileFilter, string directoryFilter)
{
this.NameTransform = new ZipNameTransform(sourceDirectory);
this.sourceDirectory_ = sourceDirectory;
using (this.outputStream_ = new ZipOutputStream(outputStream))
{
FileSystemScanner scanner;
if (this.password_ != null)
{
this.outputStream_.Password = this.password_;
}
this.outputStream_.UseZip64 = this.UseZip64;
scanner = new FileSystemScanner(fileFilter, directoryFilter) {
ProcessFile = (ProcessFileHandler) Delegate.Combine(scanner.ProcessFile, new ProcessFileHandler(this.ProcessFile))
};
if (this.CreateEmptyDirectories)
{
scanner.ProcessDirectory = (ProcessDirectoryHandler) Delegate.Combine(scanner.ProcessDirectory, new ProcessDirectoryHandler(this.ProcessDirectory));
}
if (this.events_ != null)
{
if (this.events_.FileFailure != null)
{
scanner.FileFailure = (FileFailureHandler) Delegate.Combine(scanner.FileFailure, this.events_.FileFailure);
}
if (this.events_.DirectoryFailure != null)
{
scanner.DirectoryFailure = (DirectoryFailureHandler) Delegate.Combine(scanner.DirectoryFailure, this.events_.DirectoryFailure);
}
}
scanner.Scan(sourceDirectory, recurse);
}
}
void ListFileSystem(string directory, bool recurse, string fileFilter, string directoryFilter)
{
var scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessDirectory += ListDir;
scanner.ProcessFile += ListFile;
scanner.Scan(directory, recurse);
}
/// <summary>
/// Create a zip archive sending output to the <paramref name="outputStream"/> passed.
/// </summary>
/// <param name="outputStream">The stream to write archive data to.</param>
/// <param name="sourceDirectory">The directory to source files from.</param>
/// <param name="recurse">True to recurse directories, false for no recursion.</param>
/// <param name="fileFilter">The <see cref="PathFilter">file filter</see> to apply.</param>
/// <param name="directoryFilter">The <see cref="PathFilter">directory filter</see> to apply.</param>
public void CreateZip(Stream outputStream, string sourceDirectory, bool recurse, string fileFilter, string directoryFilter)
{
NameTransform = new ZipNameTransform(sourceDirectory);
sourceDirectory_ = sourceDirectory;
using ( outputStream_ = new ZipOutputStream(outputStream) ) {
#if !NETCF_1_0
if ( password_ != null ) {
outputStream_.Password = password_;
}
#endif
FileSystemScanner scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessFile += new ProcessFileHandler(ProcessFile);
if ( this.CreateEmptyDirectories ) {
scanner.ProcessDirectory += new ProcessDirectoryHandler(ProcessDirectory);
}
if (events_ != null) {
if ( events_.FileFailure != null ) {
scanner.FileFailure += events_.FileFailure;
}
if ( events_.DirectoryFailure != null ) {
scanner.DirectoryFailure += events_.DirectoryFailure;
}
}
scanner.Scan(sourceDirectory, recurse);
}
}
void ListFileSystem(string directory, bool recurse, string fileFilter, string directoryFilter)
{
FileSystemScanner scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessDirectory += new ProcessDirectoryHandler(ListDir);
scanner.ProcessFile += new ProcessFileHandler(ListFile);
scanner.Scan(directory, recurse);
}
/// <summary>
/// Create a zip archive sending output to the <paramref name="outputStream"/> passed.
/// </summary>
/// <param name="outputStream">The stream to write archive data to.</param>
/// <param name="sourceDirectory">The directory to source files from.</param>
/// <param name="recurse">True to recurse directories, false for no recursion.</param>
/// <param name="fileFilter">The <see cref="PathFilter">file filter</see> to apply.</param>
/// <param name="directoryFilter">The <see cref="PathFilter">directory filter</see> to apply.</param>
public void CreateZip(Stream outputStream, string sourceDirectory, bool recurse, string fileFilter,
string directoryFilter)
{
entryFactory_.NameTransform = new ZipNameTransform(sourceDirectory);
using (outputStream_ = new ZipOutputStream(outputStream))
{
var scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessFile += ProcessFile;
scanner.Scan(sourceDirectory, recurse);
}
}
/// <summary>
/// Create archives based on specifications passed and internal state
/// </summary>
void Create(ArrayList fileSpecs)
{
string zipFileName = fileSpecs[0] as string;
if (Path.GetExtension(zipFileName).Length == 0)
{
zipFileName = Path.ChangeExtension(zipFileName, ".zip");
}
fileSpecs.RemoveAt(0);
if ( (overwriteFiles == Overwrite.Never) && File.Exists(zipFileName))
{
Console.Error.WriteLine("File {0} already exists", zipFileName);
return;
}
try
{
using (ZipFile zf = ZipFile.Create(zipFileName) )
{
zf.Password = password_;
zf.UseZip64 = useZip64_;
zf.BeginUpdate();
activeZipFile_ = zf;
foreach (string spec in fileSpecs)
{
// This can fail with wildcards in spec...
string path = Path.GetDirectoryName(Path.GetFullPath(spec));
string fileSpec = Path.GetFileName(spec);
zf.NameTransform = new ZipNameTransform(path);
FileSystemScanner scanner = new FileSystemScanner(WildcardToRegex(fileSpec));
scanner.ProcessFile = new ProcessFileHandler(ProcessFile);
scanner.ProcessDirectory = new ProcessDirectoryHandler(ProcessDirectory);
scanner.Scan(path, recursive_);
}
zf.CommitUpdate();
}
}
catch (Exception ex)
{
Console.WriteLine("Problem creating archive - '{0}'", ex.Message);
}
}
/// <summary>
/// Add files to an archive
/// </summary>
/// <param name="fileSpecs">The specification for files to add.</param>
void Add(ArrayList fileSpecs)
{
string zipFileName = fileSpecs[0] as string;
if (Path.GetExtension(zipFileName).Length == 0)
{
zipFileName = Path.ChangeExtension(zipFileName, ".zip");
}
fileSpecs.RemoveAt(0);
ZipFile zipFile;
try
{
if ( File.Exists(zipFileName) )
{
zipFile = new ZipFile(zipFileName);
}
else
{
zipFile = ZipFile.Create(zipFileName);
}
using (zipFile)
{
zipFile.Password = password_;
zipFile.UseZip64 = useZip64_;
zipFile.BeginUpdate();
activeZipFile_ = zipFile;
foreach (string spec in fileSpecs)
{
string path = Path.GetDirectoryName(Path.GetFullPath(spec));
string fileSpec = Path.GetFileName(spec);
zipFile.NameTransform = new ZipNameTransform(path);
FileSystemScanner scanner = new FileSystemScanner(WildcardToRegex(fileSpec));
scanner.ProcessFile = new ProcessFileHandler(ProcessFile);
scanner.ProcessDirectory = new ProcessDirectoryHandler(ProcessDirectory);
scanner.Scan(path, recursive_);
}
zipFile.CommitUpdate();
}
}
catch(Exception ex)
{
Console.WriteLine("Problem adding to archive - '{0}'", ex.Message);
}
}
/// <summary>
/// Create a zip file.
/// </summary>
/// <param name="zipFileName">The name of the zip file to create.</param>
/// <param name="sourceDirectory">The directory to source files from.</param>
/// <param name="recurse">True to recurse directories, false for no recursion.</param>
/// <param name="fileFilter">The file filter to apply.</param>
/// <param name="directoryFilter">The directory filter to apply.</param>
public void CreateZip(string zipFileName, string sourceDirectory, bool recurse, string fileFilter, string directoryFilter)
{
NameTransform = new ZipNameTransform(true, sourceDirectory);
this.sourceDirectory = sourceDirectory;
outputStream = new ZipOutputStream(File.Create(zipFileName));
try {
FileSystemScanner scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessFile += new ProcessFileDelegate(ProcessFile);
if ( this.CreateEmptyDirectories ) {
scanner.ProcessDirectory += new ProcessDirectoryDelegate(ProcessDirectory);
}
scanner.Scan(sourceDirectory, recurse);
}
finally {
outputStream.Close();
}
}
/// <summary>
/// Create a zip archive sending output to the <paramref name="outputStream"/> passed.
/// </summary>
/// <param name="outputStream">The stream to write archive data to.</param>
/// <param name="sourceDirectory">The directory to source files from.</param>
/// <param name="recurse">True to recurse directories, false for no recursion.</param>
/// <param name="fileFilter">The <see cref="PathFilter">file filter</see> to apply.</param>
/// <param name="directoryFilter">The <see cref="PathFilter">directory filter</see> to apply.</param>
public void CreateZip(Stream outputStream, string sourceDirectory, bool recurse, string fileFilter, string directoryFilter)
{
NameTransform = new ZipNameTransform(sourceDirectory);
sourceDirectory_ = sourceDirectory;
using ( outputStream_ = new ZipOutputStream(outputStream) ) {
FileSystemScanner scanner = new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessFile += new ProcessFileDelegate(ProcessFile);
if ( this.CreateEmptyDirectories ) {
scanner.ProcessDirectory += new ProcessDirectoryDelegate(ProcessDirectory);
}
if (events_ != null) {
if ( events_.FileFailure != null ) {
scanner.FileFailure += events_.FileFailure;
}
if ( events_.DirectoryFailure != null ) {
scanner.DirectoryFailure += events_.DirectoryFailure;
}
}
scanner.Scan(sourceDirectory, recurse);
}
}
/// <summary>
/// Create archives based on specifications passed and internal state
/// </summary>
void Create(string zipFileName, ArrayList fileSpecs, ref ToolStripProgressBar ProgressBar)
{
if (Path.GetExtension(zipFileName).Length == 0)
{
zipFileName = Path.ChangeExtension(zipFileName, ".zip");
}
try
{
using (ZipFile zf = ZipFile.Create(zipFileName))
{
zf.BeginUpdate();
activeZipFile_ = zf;
foreach (string spec in fileSpecs)
{
// This can fail with wildcards in spec...
string path = Path.GetDirectoryName(Path.GetFullPath(spec));
string fileSpec = Path.GetFileName(spec);
zf.NameTransform = new ZipNameTransform(Settings.Global.Properties["POLPath"]);
FileSystemScanner scanner = new FileSystemScanner(fileSpec);
scanner.ProcessFile = new ProcessFileHandler(ProcessFile);
scanner.Scan(path, false);
ProgressBar.PerformStep();
}
zf.CommitUpdate();
ProgressBar.PerformStep();
}
}
catch (Exception ex)
{
ExceptionBox.ExceptionForm tmp = new ExceptionBox.ExceptionForm(ref ex);
tmp.ShowDialog();
}
}
/// <summary>
/// Create a zip archive sending output to the <paramref name="outputStream"/> passed.
/// </summary>
/// <param name="outputStream">The stream to write archive data to.</param>
/// <param name="sourceDirectory">The directory to source files from.</param>
/// <param name="recurse">True to recurse directories, false for no recursion.</param>
/// <param name="fileFilter">The <see cref="PathFilter">file filter</see> to apply.</param>
/// <param name="directoryFilter">The <see cref="PathFilter">directory filter</see> to apply.</param>
/// <remarks>The <paramref name="outputStream"/> is closed after creation.</remarks>
public void CreateZip(Stream outputStream, string sourceDirectory, bool recurse, string fileFilter,
string directoryFilter) {
NameTransform=new ZipNameTransform(sourceDirectory);
sourceDirectory_=sourceDirectory;
using (outputStream_=new ZipOutputStream(outputStream)) {
if (password_!=null) {
outputStream_.Password=password_;
}
outputStream_.UseZip64=UseZip64;
var scanner=new FileSystemScanner(fileFilter, directoryFilter);
scanner.ProcessFile+=ProcessFile;
if (CreateEmptyDirectories) {
scanner.ProcessDirectory+=ProcessDirectory;
}
if (events_!=null) {
if (events_.FileFailure!=null) {
scanner.FileFailure+=events_.FileFailure;
}
if (events_.DirectoryFailure!=null) {
scanner.DirectoryFailure+=events_.DirectoryFailure;
}
}
scanner.Scan(sourceDirectory, recurse);
}
}
