/Utilities/Compression/ZipEntry.cs

// Based on Mike Krueger's SharpZipLib, Copyright (C) 2001 (GNU license).

// Authors of the original java version: Jochen Hoenicke, John Leuner

// See http://www.ISeeSharpCode.com for more information.



using System;

using System.IO;

using Delta.Utilities.Helpers;



namespace Delta.Utilities.Compression

{

	/// <summary>

	/// This class represents an entry in a zip archive. This can be a file

	/// or a directory ZipFile and ZipInputStream will give you instances of

	/// this class as information about the members in an archive.

	/// ZipOutputStream uses an instance of this class when creating an entry

	/// in a Zip file.

	/// <br/>Author of the original java version : Jochen Hoenicke

	/// </summary>

	public class ZipEntry //: ICloneable

	{

		#region Constants

		private const int KnownSize = 1;



		private const int KnownCSize = 2;



		private const int KnownCrc = 4;



		private const int KnownTime = 8;



		private const int KnownExternAttributes = 16;

		#endregion



		#region CleanName (Static)

		/// <summary>

		/// Cleans a name making it conform to Zip file conventions.

		/// Devices names ('c:\') and UNC share names ('\\server\share') are

		/// removed and forward slashes ('\') are converted to back slashes ('/').

		/// </summary>

		/// <param name="name">Name to clean</param>

		/// <param name="relativePath">Make names relative if true or absolute if

		/// false</param>

		public static string CleanName(string name, bool relativePath)

		{

			if (name == null)

			{

				return "";

			}



			if (Path.IsPathRooted(name))

			{

				// NOTE:

				// for UNC names...  \\machine\share\zoom\beet.txt gives \zoom\beet.txt

				name = name.Substring(Path.GetPathRoot(name).Length);

			}



			name = name.Replace(@"\", "/");



			if (relativePath)

			{

				if (name.Length > 0 &&

				    (name[0] == Path.AltDirectorySeparatorChar ||

				     name[0] == Path.DirectorySeparatorChar))

				{

					name = name.Remove(0, 1);

				}

			}

			else

			{

				if (name.Length > 0 &&

				    name[0] != Path.AltDirectorySeparatorChar &&

				    name[0] != Path.DirectorySeparatorChar)

				{

					name = name.Insert(0, "/");

				}

			}

			return name;

		}



		/// <summary>

		/// Cleans a name making it conform to Zip file conventions.

		/// Devices names ('c:\') and UNC share names ('\\server\share') are

		/// removed and forward slashes ('\') are converted to back slashes ('/').

		/// Names are made relative by trimming leading slashes which is

		/// compatible with Windows-XPs built in Zip file handling.

		/// </summary>

		/// <param name="name">Name to clean</param>

		public static string CleanName(string name)

		{

			return CleanName(name, true);

		}

		#endregion



		#region IsCrypted (Public)

		/// <summary>

		/// Get/Set flag indicating if entry is encrypted.

		/// A simple helper routine to aid interpretation of

		/// <see cref="Flags">flags</see>

		/// </summary>

		public bool IsCrypted

		{

			get

			{

				return (flags & 1) != 0;

			} // get

			set

			{

				if (value)

				{

					flags |= 1;

				} // if

				else

				{

					flags &= ~1;

				} // else

			} // set

		}

		#endregion



		#region Flags (Public)

		/// <summary>

		/// Get/Set general purpose bit flag for entry

		/// </summary>

		/// <remarks>

		/// General purpose bit flag<br/>

		/// Bit 0: If set, indicates the file is encrypted<br/>

		/// Bit 1-2 Only used for compression type 6 Imploding, and 8, 9

		/// deflating<br/>

		/// Imploding:<br/>

		/// Bit 1 if set indicates an 8K sliding dictionary was used.

		/// If clear a 4k dictionary was used<br/>

		/// Bit 2 if set indicates 3 Shannon-Fanno trees were used to encode the

		/// sliding dictionary, 2 otherwise<br/>

		/// <br/>

		/// Deflating:<br/>

		///   Bit 2    Bit 1<br/>

		///     0        0       Normal compression was used<br/>

		///     0        1       Maximum compression was used<br/>

		///     1        0       Fast compression was used<br/>

		///     1        1       Super fast compression was used<br/>

		/// <br/>

		/// Bit 3: If set, the fields crc-32, compressed size

		/// and uncompressed size are were not able to be written during zip file

		/// creation. The correct values are held in a data descriptor immediately

		/// following the compressed data. <br/>

		/// Bit 4: Reserved for use by PKZIP for enhanced deflating<br/>

		/// Bit 5: If set indicates the file contains compressed patch data<br/>

		/// Bit 6: If set indicates strong encryption was used.<br/>

		/// Bit 7-15: Unused or reserved<br/>

		/// </remarks>

		public int Flags

		{

			get

			{

				return flags;

			} // get

			set

			{

				flags = value;

			} // set

		}

		#endregion



		#region ZipFileIndex (Public)

		/// <summary>

		/// Get/Set index of this entry in Zip file

		/// </summary>

		public int ZipFileIndex

		{

			get

			{

				return zipFileIndex;

			} // get

			set

			{

				zipFileIndex = value;

			} // set

		}

		#endregion



		#region Offset (Public)

		/// <summary>

		/// Get/set offset for use in central header

		/// </summary>

		public int Offset

		{

			get

			{

				return offset;

			}

			set

			{

				if (((ulong)value & 0xFFFFFFFF00000000L) != 0)

				{

					throw new ArgumentOutOfRangeException("Offset");

				} // if

				offset = value;

			} // set

		}

		#endregion



		#region ExternalFileAttributes (Public)

		/// <summary>

		/// Get/Set external file attributes as an integer.

		/// The values of this are operating system dependant see

		/// <see cref="HostSystemId">HostSystem</see> for details

		/// </summary>

		public int ExternalFileAttributes

		{

			get

			{

				if ((known & KnownExternAttributes) == 0)

				{

					return MathHelper.InvalidIndex;

				} // if

				else

				{

					return externalFileAttributes;

				} // else

			} // get

			set

			{

				externalFileAttributes = value;

				known |= KnownExternAttributes;

			} // set

		}

		#endregion



		#region VersionMadeBy (Public)

		/// <summary>

		/// Get the version made by for this entry or zero if unknown.

		/// The value / 10 indicates the major version number, and 

		/// the value mod 10 is the minor version number

		/// </summary>

		public int VersionMadeBy

		{

			get

			{

				return versionMadeBy & 0xff;

			} // get

		}

		#endregion



		#region HostSystemId (Public)

		/// <summary>

		/// Gets the compatability information for the

		/// <see cref="ExternalFileAttributes">external file attribute</see>

		/// If the external file attributes are compatible with MS-DOS and can be

		/// read by PKZIP for DOS version 2.04g then this value will be zero.

		/// Otherwise the value will be non-zero and identify the host system on

		/// which the attributes are compatible.

		/// </summary>

		/// <remarks>

		/// The values for this as defined in the Zip File format and by others

		/// are shown below. The values are somewhat misleading in some cases as

		/// they are not all used as shown. You should consult the relevant

		/// documentation to obtain up to date and correct information. The

		/// modified appnote by the infozip group is particularly helpful as it

		/// documents a lot of peculiarities. The document is however a little

		/// dated.

		/// <list type="table">

		/// <item>0 - MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)</item>

		/// <item>1 - Amiga</item>

		/// <item>2 - OpenVMS</item>

		/// <item>3 - Unix</item>

		/// <item>4 - VM/CMS</item>

		/// <item>5 - Atari ST</item>

		/// <item>6 - OS/2 HPFS</item>

		/// <item>7 - Macintosh</item>

		/// <item>8 - Z-System</item>

		/// <item>9 - CP/M</item>

		/// <item>10 - Windows NTFS</item>

		/// <item>11 - MVS (OS/390 - Z/OS)</item>

		/// <item>12 - VSE</item>

		/// <item>13 - Acorn Risc</item>

		/// <item>14 - VFAT</item>

		/// <item>15 - Alternate MVS</item>

		/// <item>16 - BeOS</item>

		/// <item>17 - Tandem</item>

		/// <item>18 - OS/400</item>

		/// <item>19 - OS/X (Darwin)</item>

		/// <item>99 - WinZip AES</item>

		/// <item>remainder - unused</item>

		/// </list>

		/// </remarks>

		public int HostSystemId

		{

			get

			{

				return (versionMadeBy >> 8) & 0xff;

			} // get

		}

		#endregion



		#region Version (Public)

		/// <summary>

		/// Get minimum Zip feature version required to extract this

		/// entry

		/// </summary>		

		/// <remarks>

		/// Minimum features are defined as:<br/>

		/// 1.0 - Default value<br/>

		/// 1.1 - File is a volume label<br/>

		/// 2.0 - File is a folder/directory<br/>

		/// 2.0 - File is compressed using Deflate compression<br/>

		/// 2.0 - File is encrypted using traditional encryption<br/>

		/// 2.1 - File is compressed using Deflate64<br/>

		/// 2.5 - File is compressed using PKWARE DCL Implode<br/>

		/// 2.7 - File is a patch data set<br/>

		/// 4.5 - File uses Zip64 format extensions<br/>

		/// 4.6 - File is compressed using BZIP2 compression<br/>

		/// 5.0 - File is encrypted using DES<br/>

		/// 5.0 - File is encrypted using 3DES<br/>

		/// 5.0 - File is encrypted using original RC2 encryption<br/>

		/// 5.0 - File is encrypted using RC4 encryption<br/>

		/// 5.1 - File is encrypted using AES encryption<br/>

		/// 5.1 - File is encrypted using corrected RC2 encryption<br/>

		/// 5.1 - File is encrypted using corrected RC2-64 encryption<br/>

		/// 6.1 - File is encrypted using non-OAEP key wrapping<br/>

		/// 6.2 - Central directory encryption (not confirmed yet)<br/>

		/// </remarks>

		public int Version

		{

			get

			{

				if (versionToExtract != 0)

				{

					return versionToExtract;

				} // if

				else

				{

					int result = 10;

					if (CompressionMethod.Deflated == method)

					{

						result = 20;

					} // if

					else if (IsDirectory)

					{

						result = 20;

					} // else if

					else if (IsCrypted)

					{

						result = 20;

					} // else if

					else if ((known & KnownExternAttributes) != 0 &&

					         (externalFileAttributes & 0x08) != 0)

					{

						result = 11;

					} // else if

					return result;

				} // else

			} // get

		}

		#endregion



		#region RequiresZip64 (Public)

		/// <summary>

		/// Gets a value indicating if the entry requires Zip64 extensions to be

		/// stored.

		/// </summary>

		public bool RequiresZip64

		{

			get

			{

				return (size > uint.MaxValue) ||

				       (compressedSize > uint.MaxValue);

			} // get

		}

		#endregion



		#region DosTime (Public)

		/// <summary>

		/// Gets/Sets DosTime

		/// </summary>		

		public long DosTime

		{

			get

			{

				if ((known & KnownTime) == 0)

				{

					return 0;

				} // if

				else

				{

					return dosTime;

				} // else

			} // get

			set

			{

				dosTime = (uint)value;

				known |= KnownTime;

			} // set

		}

		#endregion



		#region DateTime (Public)

		/// <summary>

		/// Gets/Sets the time of last modification of the entry.

		/// </summary>

		public DateTime DateTime

		{

			get

			{

				// Although technically not valid some archives have dates set to zero.

				// This mimics some archivers handling and is a good a cludge as any

				// probably.

				if (dosTime == 0)

				{

					return DateTime.Now;

				} // if

				else

				{

					uint sec = 2 * (dosTime & 0x1f);

					uint min = (dosTime >> 5) & 0x3f;

					uint hrs = (dosTime >> 11) & 0x1f;

					uint day = (dosTime >> 16) & 0x1f;

					uint mon = ((dosTime >> 21) & 0xf);

					uint year = ((dosTime >> 25) & 0x7f) + 1980;

					return new DateTime((int)year, (int)mon, (int)day,

						(int)hrs, (int)min, (int)sec);

				} // else

			} // get

			set

			{

				DosTime =

					((uint)value.Year - 1980 & 0x7f) << 25 |

					((uint)value.Month) << 21 |

					((uint)value.Day) << 16 |

					((uint)value.Hour) << 11 |

					((uint)value.Minute) << 5 |

					((uint)value.Second) >> 1;

			} // set

		}

		#endregion



		#region Name (Public)

		/// <summary>

		/// Returns the entry name.  The path components in the entry should

		/// always separated by slashes ('/').  Dos device names like C: should

		/// also be removed. See <see cref="CleanName(string)">CleanName</see>.

		/// </summary>

		public string Name

		{

			get

			{

				return name;

			} // get

		}

		#endregion



		#region Comment (Public)

		/// <summary>

		/// Gets/Sets the entry comment.

		/// </summary>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// If comment is longer than 0xffff.

		/// </exception>

		/// <returns>

		/// The comment or null if not set.

		/// </returns>

		public string Comment

		{

			get

			{

				return comment;

			}

			set

			{

				// While the test is correct in that a comment of this length or

				// greater is definitely invalid, shorter comments may also have an

				// invalid length.

				if (value != null &&

				    value.Length > 0xffff)

				{

					throw new ArgumentOutOfRangeException();

				}

				comment = value;

			}

		}

		#endregion



		#region IsDirectory (Public)

		/// <summary>

		/// Gets a value indicating of the if the entry is a directory.

		/// A directory is determined by an entry name with a trailing slash '/'.

		/// The external file attributes can also mark a file as a directory.

		/// The trailing slash convention should always be followed however.

		/// </summary>

		public bool IsDirectory

		{

			get

			{

				int nlen = name.Length;

				bool result = nlen > 0 && name[nlen - 1] == '/';



				if (result == false &&

				    (known & KnownExternAttributes) != 0)

				{

					if (HostSystemId == 0 &&

					    (ExternalFileAttributes & 16) != 0)

					{

						result = true;

					}

				}

				return result;

			}

		}

		#endregion



		#region IsFile (Public)

		/// <summary>

		/// Get a value of true if the entry appears to be a file; false otherwise

		/// </summary>

		/// <remarks>

		/// This only takes account Windows attributes. Other operating systems

		/// are ignored. For Linux and others the result may be incorrect.

		/// </remarks>

		public bool IsFile

		{

			get

			{

				bool result = !IsDirectory;



				// Exclude volume labels

				if (result && (known & KnownExternAttributes) != 0)

				{

					if (HostSystemId == 0 &&

					    (ExternalFileAttributes & 8) != 0)

					{

						result = false;

					}

				}

				return result;

			}

		}

		#endregion



		#region Size (Public)

		/// <summary>

		/// Gets/Sets the size of the uncompressed data.

		/// </summary>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// If the size is not in the range 0..0xffffffffL

		/// </exception>

		/// <returns>

		/// The size or -1 if unknown.

		/// </returns>

		public long Size

		{

			get

			{

				return (known & KnownSize) != 0

				       	? (long)size

				       	: -1L;

			}

			set

			{

				if (((ulong)value & 0xFFFFFFFF00000000L) != 0)

				{

					throw new ArgumentOutOfRangeException("size");

				}

				size = (ulong)value;

				known |= KnownSize;

			}

		}

		#endregion



		#region CompressedSize (Public)

		/// <summary>

		/// Gets/Sets the size of the compressed data.

		/// </summary>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// Size is not in the range 0..0xffffffff

		/// </exception>

		/// <returns>

		/// The size or -1 if unknown.

		/// </returns>

		public long CompressedSize

		{

			get

			{

				return (known & KnownCSize) != 0

				       	? (long)compressedSize

				       	: -1L;

			}

			set

			{

				if (((ulong)value & 0xffffffff00000000L) != 0)

				{

					throw new ArgumentOutOfRangeException();

				}

				compressedSize = (ulong)value;

				known |= KnownCSize;

			}

		}

		#endregion



		#region Crc (Public)

		/// <summary>

		/// Gets/Sets the crc of the uncompressed data.

		/// </summary>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// Crc is not in the range 0..0xffffffffL

		/// </exception>

		/// <returns>

		/// The crc value or -1 if unknown.

		/// </returns>

		public long Crc

		{

			get

			{

				return (known & KnownCrc) != 0

				       	? crc & 0xffffffffL

				       	: -1L;

			}

			set

			{

				if ((crc & 0xffffffff00000000L) != 0)

				{

					throw new ArgumentOutOfRangeException();

				}

				crc = (uint)value;

				known |= KnownCrc;

			}

		}

		#endregion



		#region CompressionMethod (Public)

		/// <summary>

		/// Gets/Sets the compression method. Only Deflated and Stored are

		/// supported.

		/// </summary>

		/// <returns>

		/// The compression method for this entry

		/// </returns>

		/// <see cref="Delta.Utilities.Compression.CompressionMethod.Deflated"/>

		/// <see cref="Delta.Utilities.Compression.CompressionMethod.Stored"/>

		public CompressionMethod CompressionMethod

		{

			get

			{

				return method;

			}

			set

			{

				method = value;

			}

		}

		#endregion



		#region Private



		#region known (Private)

		/// <summary>

		/// Bit flags made up of above bits

		/// </summary>

		private ushort known;

		#endregion



		#region externalFileAttributes (Private)

		/// <summary>

		/// contains external attributes (os dependant)

		/// </summary>

		private int externalFileAttributes;

		#endregion



		#region versionMadeBy (Private)

		/// <summary>

		/// Contains host system and version information

		/// only relevant for central header entries

		/// </summary>

		private ushort versionMadeBy;

		#endregion



		#region name (Private)

		/// <summary>

		/// Name

		/// </summary>

		private string name;

		#endregion



		#region size (Private)

		/// <summary>

		/// Size

		/// </summary>

		private ulong size;

		#endregion



		#region compressedSize (Private)

		/// <summary>

		/// Compressed size

		/// </summary>

		private ulong compressedSize;

		#endregion



		#region versionToExtract (Private)

		/// <summary>

		/// Version required to extract (library handles &lt;= 2.0)

		/// </summary>

		private ushort versionToExtract;

		#endregion



		#region crc (Private)

		/// <summary>

		/// Crc

		/// </summary>

		private uint crc;

		#endregion



		#region dosTime (Private)

		/// <summary>

		/// Dos time

		/// </summary>

		private uint dosTime;

		#endregion



		#region method (Private)

		/// <summary>

		/// Method

		/// </summary>

		private CompressionMethod method;

		#endregion



		#region extra (Private)

		/// <summary>

		/// Extra

		/// </summary>

		private byte[] extra;

		#endregion



		#region comment (Private)

		/// <summary>

		/// Comment

		/// </summary>

		private string comment;

		#endregion



		#region flags (Private)

		/// <summary>

		/// general purpose bit flags

		/// </summary>

		private int flags;

		#endregion



		#region zipFileIndex (Private)

		/// <summary>

		/// used by ZipFile

		/// </summary>

		private int zipFileIndex;

		#endregion



		#region offset (Private)

		/// <summary>

		/// used by ZipFile and ZipOutputStream

		/// </summary>

		private int offset;

		#endregion



		#endregion



		#region Constructors

		/// <summary>

		/// Creates a zip entry with the given name.

		/// </summary>

		/// <param name="name">

		/// The name for this entry. Can include directory components.

		/// The convention for names is 'unix'  style paths with no device names

		/// and path elements separated by '/' characters.  This is not enforced

		/// see <see cref="CleanName(string)">CleanName</see> on how to ensure

		/// names are valid if this is desired.

		/// </param>

		/// <exception cref="ArgumentNullException">The name passed is null

		/// </exception>

		public ZipEntry(string name)

			: this(name, 0, ZipConstants.VersionMadeBy)

		{

		}



		/// <summary>

		/// Creates a zip entry with the given name and version required to extract

		/// </summary>

		/// <param name="name">

		/// The name for this entry. Can include directory components.

		/// The convention for names is 'unix'  style paths with no device names

		/// and path elements separated by '/' characters.  This is not enforced

		/// see <see cref="CleanName(string)">CleanName</see> on how to ensure

		/// names are valid if this is desired.

		/// </param>

		/// <param name="versionRequiredToExtract">

		/// The minimum 'feature version' required this entry

		/// </param>

		/// <exception cref="ArgumentNullException">The name passed is null

		/// </exception>

		internal ZipEntry(string name, int versionRequiredToExtract)

			: this(name, versionRequiredToExtract, ZipConstants.VersionMadeBy)

		{

		}



		/// <summary>

		/// Initializes an entry with the given name and made by information

		/// </summary>

		/// <param name="setName">Name for this entry</param>

		/// <param name="setMadeByInfo">Version and HostSystem Information</param>

		/// <param name="setVersionRequiredToExtract">Minimum required zip feature

		/// version required to extract this entry</param>

		/// <exception cref="ArgumentNullException">

		/// The name passed is null

		/// </exception>

		/// <exception cref="ArgumentOutOfRangeException">

		/// versionRequiredToExtract should be 0 (auto-calculate) or > 10

		/// </exception>

		/// <remarks>

		/// This constructor is used by the ZipFile class when reading from the

		/// central header. It is not generally useful, use the constructor

		/// specifying the name only.

		/// </remarks>

		internal ZipEntry(string setName, int setVersionRequiredToExtract,

			int setMadeByInfo)

		{

			if (setName == null)

			{

				throw new ArgumentNullException("ZipEntry name");

			}



			if (setName.Length == 0)

			{

				throw new ArgumentException("ZipEntry name is empty");

			}



			if (setVersionRequiredToExtract != 0 &&

			    setVersionRequiredToExtract < 10)

			{

				throw new ArgumentOutOfRangeException(

					"versionRequiredToExtract");

			}



			DateTime = DateTime.Now;

			name = setName;

			versionMadeBy = (ushort)setMadeByInfo;

			versionToExtract = (ushort)setVersionRequiredToExtract;

			method = CompressionMethod.Deflated;

			zipFileIndex = MathHelper.InvalidIndex;

			externalFileAttributes = MathHelper.InvalidIndex;

		}



		/// <summary>

		/// Can be used for the "Load" method (after saving) or to create a clone.

		/// </summary>

		private ZipEntry()

		{

		}

		#endregion



		#region GetExtraData (Public)

		/// <summary>

		/// Get extra data

		/// </summary>

		public byte[] GetExtraData()

		{

			return extra;

		}

		#endregion



		#region SetExtraData (Public)

		/// <summary>

		/// Set extra data

		/// </summary>

		/// <param name="value">Value</param>

		public void SetExtraData(byte[] value)

		{

			if (value == null)

			{

				extra = null;

				return;

			}



			if (value.Length > 0xffff)

			{

				throw new ArgumentOutOfRangeException();

			}



			extra = new byte[value.Length];

			Array.Copy(value, 0, extra, 0, value.Length);



			try

			{

				int pos = 0;

				while (pos < extra.Length)

				{

					int sig = (extra[pos++] & 0xff) | (extra[pos++] & 0xff) << 8;

					int len = (extra[pos++] & 0xff) | (extra[pos++] & 0xff) << 8;



					if (len < 0 ||

					    pos + len > extra.Length)

					{

						// This is still lenient but the extra data is corrupt.

						// Note: Drops the extra data. Indicate to user there is a problem.

						Log.Warning(

							"Dropping extra data in zip entry '" + name + "': " + len);

						break;

					}



					if (sig == 0x5455)

					{

						// extended time stamp, unix format by Rainer Prem

						int extraFlags = extra[pos];

						// Can include other times but these are ignored.

						// Length of data should actually be 1 + 4 * no of bits in flags.

						if ((extraFlags & 1) != 0 &&

						    len >= 5)

						{

							int iTime =

								((extra[pos + 1] & 0xff) |

								 (extra[pos + 2] & 0xff) << 8 |

								 (extra[pos + 3] & 0xff) << 16 |

								 (extra[pos + 4] & 0xff) << 24);



							DateTime =

								(new DateTime(1970, 1, 1, 0, 0, 0) +

								 new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();

							known |= KnownTime;

						}

					}

					else if (sig == 0x0001)

					{

						// ZIP64 extended information extra field

						// Of variable size depending on which fields in header are too

						// small fields appear here if the corresponding local or central

						// directory record field is set to 0xFFFF or 0xFFFFFFFF and the

						// entry is in Zip64 format.

						//

						// Original Size          8 bytes

						// Compressed size        8 bytes

						// Relative header offset 8 bytes

						// Disk start number      4 bytes

					}

					pos += len;

				}

			}

			catch (Exception)

			{

				// be lenient

				return;

			}

		}

		#endregion



		#region Clone (Public)

		/// <summary>

		/// Creates a copy of this zip entry.

		/// </summary>

		public ZipEntry Clone()

		{

			return new ZipEntry

			{

				known = known,

				name = name,

				size = size,

				compressedSize = compressedSize,

				crc = crc,

				dosTime = dosTime,

				method = method,

				extra = extra,

				comment = comment,

				versionToExtract = versionToExtract,

				versionMadeBy = versionMadeBy,

				externalFileAttributes = externalFileAttributes,

				flags = flags,

				zipFileIndex = zipFileIndex,

				offset = offset,

			};

		}

		#endregion



		#region ToString (Public)

		/// <summary>

		/// Gets the string representation of this ZipEntry.

		/// </summary>

		public override string ToString()

		{

			return name;

		}

		#endregion

	}

}