/// <summary>A constructor to initialize a <c>new PairOfFiles</c>.</summary>
/// <param name="SourceDrive"></param>
/// <param name="DestinationDrive"></param>
/// <param name="sRelativePath">The relative 'end' path is identical for both files, even though they are stored in different directories.</param>
/// <param name="eComparison">Type of synchronization that needs to be performed within this <c>PairOfFiles</c>.</param>
/// <param name="isDirectory">True if this is a pair of directories. Technically, a directory is a special case of a file.</param>
public PairOfFiles(PairOfFiles ParentDirectory, string sRelativePath, nComparison eComparison, bool isDirectory, TextConverter TextConverter) : this()
{
_ParentDirectory = ParentDirectory;
_SourceDrive = _ParentDirectory.SourceDrive;
_DestinationDrive = _ParentDirectory.DestinationDrive;
_eComparison = eComparison;
_isDirectory = isDirectory;
_TextConverter = TextConverter;
if (string.IsNullOrEmpty(sRelativePath))
{
throw new ArgumentException("Relative path must not be empty.");
}
else if ((sRelativePath[0] == '\\') || (sRelativePath[0] == '/'))
{
throw new ArgumentException("Relative path '" + sRelativePath + "' must not start with a slash.");
}
else
{
_sRelativePath = sRelativePath;
}
foreach (string sDirectory in casSkipDirectories)
{
if ((_sRelativePath.Length >= sDirectory.Length) && (_sRelativePath.Substring(0, sDirectory.Length) == sDirectory))
{
_eComparison = nComparison.Error;
_sErrorMessage = "This directory is excluded by default.";
}
}
}
/// <summary>A constructor to initialize a <c>new PairOfFiles</c>.</summary>
protected PairOfFiles()
{
_isDirectory = _isEncryptedDestination = _isEncryptedSource = false;
_uAttributesDestination = _uAttributesSource = _uFirstBlockDestination = _uFirstBlockSource = _uLastWriteTimeDestination = _uLastWriteTimeSource = 0;
_kDestinationSize = _kSourceSize = -1;
_sErrorMessage = _sLastWriteTimeDestination = _sLastWriteTimeSource = _sRelativePath = _sDestinationSize = _sSourceSize = string.Empty;
_eComparison = nComparison.Error;
_TextConverter = null;
_eSynchronizationMode = nSynchronizationMode.WithDelete;
_SourceDrive = _DestinationDrive = null;
_ParentDirectory = null;
_CreationTimeDestination = _CreationTimeSource = _LastAccessTimeDestination = _LastAccessTimeSource = _LastWriteTimeDestination = _LastWriteTimeSource = DateTime.MinValue;
}
/// <summary></summary>
private void ReadFileProperties()
{
if (isWithSource)
{
if (_SourceDrive.eEncryptionType == Drive.nEncryptionType.DirectoryUnencrypted)
{
FileInfo FileInfoSource = new FileInfo(sSourcePath);
if (FileInfoSource.Exists)
{
try
{
_uAttributesSource = (uint)FileInfoSource.Attributes;
_kSourceSize = FileInfoSource.Length;
_sSourceSize = FileSizeToString(_kSourceSize);
_CreationTimeSource = FileInfoSource.CreationTime;
_LastAccessTimeSource = FileInfoSource.LastAccessTime;
_LastWriteTimeSource = FileInfoSource.LastWriteTime;
_uLastWriteTimeSource = DateTimeToUint(_LastWriteTimeSource);
_sLastWriteTimeSource = DateTimeToString(_LastWriteTimeSource);
if (_isDirectory != (_uAttributesSource & (uint)FileAttributes.Directory) > 0)
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Contradictory informaton on whether this is a directory or a file.";
}
}
catch
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Could not read properties of source file.";
}
}
else
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Source file not found.";
}
}
}
else if (_eComparison != nComparison.Error)
{
eComparison = nComparison.DestinationOnly;
}
if (isWithDestination)
{
if (_DestinationDrive.eEncryptionType == Drive.nEncryptionType.DirectoryUnencrypted)
{
FileInfo FileInfoDestination = new FileInfo(sDestinationPath);
if (FileInfoDestination.Exists)
{
try
{
_uAttributesDestination = (uint)FileInfoDestination.Attributes;
_kDestinationSize = FileInfoDestination.Length;
_sDestinationSize = FileSizeToString(_kDestinationSize);
_CreationTimeDestination = FileInfoDestination.CreationTime;
_LastAccessTimeDestination = FileInfoDestination.LastAccessTime;
_LastWriteTimeDestination = FileInfoDestination.LastWriteTime;
_uLastWriteTimeDestination = DateTimeToUint(_LastWriteTimeDestination);
_sLastWriteTimeDestination = DateTimeToString(_LastWriteTimeDestination);
if (_isDirectory != (_uAttributesDestination & (uint)FileAttributes.Directory) > 0)
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Contradictory informaton on whether this is a directory or a file.";
}
}
catch
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Could not read properties of destination file.";
}
}
else
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Destination file not found.";
}
}
}
else if (_eComparison != nComparison.Error)
{
eComparison = nComparison.SourceOnly;
}
if (isWithSourceAndDestination)
{
CompareLastWriteTimes();
if ((eComparison == nComparison.Identical) && (_kSourceSize != _kDestinationSize))
{
eComparison = nComparison.Error;
_sErrorMessage = "Different file sizes on identical file dates should not happen.";
}
}
}
/// <summary>A constructor to initialize a <c>new PairOfFiles</c>.</summary>
/// <param name="FromStream"></param>
/// <param name="SourceOrDestinationDrive"></param>
/// <param name="TextEncoder"></param>
public PairOfFiles(Stream FromStream, PairOfFiles ParentDirectory, bool isSource, TextConverter TextConverter) : this()
{
byte[] abBuffer, abTextBytes;
ushort tTextLength;
uint uAttributes, uFirstBlock = 0;
long kCreationTimeTicks, kLastAccessTimeTicks, kLastWriteTimeTicks, kSize = -1;
_ParentDirectory = ParentDirectory;
_SourceDrive = _ParentDirectory.SourceDrive;
_DestinationDrive = _ParentDirectory.DestinationDrive;
_TextConverter = TextConverter;
abBuffer = new byte[8];
FromStream.Read(abBuffer, 0, 2);
tTextLength = BitConverter.ToUInt16(abBuffer, 0);
abTextBytes = new byte[tTextLength];
FromStream.Read(abTextBytes, 0, tTextLength);
_sRelativePath = _TextConverter.BytesToString(abTextBytes);
FromStream.Read(abBuffer, 0, 4);
uAttributes = BitConverter.ToUInt32(abBuffer, 0);
_isDirectory = ((uAttributes & (uint)FileAttributes.Directory) > 0);
FromStream.Read(abBuffer, 0, 8);
kCreationTimeTicks = BitConverter.ToInt64(abBuffer, 0);
FromStream.Read(abBuffer, 0, 8);
kLastAccessTimeTicks = BitConverter.ToInt64(abBuffer, 0);
FromStream.Read(abBuffer, 0, 8);
kLastWriteTimeTicks = BitConverter.ToInt64(abBuffer, 0);
if (!_isDirectory)
{
FromStream.Read(abBuffer, 0, 8);
kSize = BitConverter.ToInt64(abBuffer, 0);
if ((isSource && (_SourceDrive.eEncryptionType == Drive.nEncryptionType.DirectorySymmetric)) || (!isSource && (_DestinationDrive.eEncryptionType == Drive.nEncryptionType.DirectorySymmetric)))
{
FromStream.Read(abBuffer, 0, 4);
uFirstBlock = BitConverter.ToUInt32(abBuffer, 0);
}
}
if (isSource)
{
_uAttributesSource = uAttributes;
_CreationTimeSource = new DateTime(kCreationTimeTicks);
_LastAccessTimeSource = new DateTime(kLastAccessTimeTicks);
LastWriteTimeSource = new DateTime(kLastWriteTimeTicks);
_kSourceSize = kSize;
_sSourceSize = FileSizeToString(kSize);
_uFirstBlockSource = uFirstBlock;
_eComparison = nComparison.UnknownDestination;
}
else
{
_uAttributesDestination = uAttributes;
_CreationTimeDestination = new DateTime(kCreationTimeTicks);
_LastAccessTimeDestination = new DateTime(kLastAccessTimeTicks);
LastWriteTimeDestination = new DateTime(kLastWriteTimeTicks);
_kDestinationSize = kSize;
_sDestinationSize = FileSizeToString(kSize);
_uFirstBlockDestination = uFirstBlock;
_eComparison = nComparison.UnknownSource;
}
}
/// <summary></summary>
private void ReadDirectoryProperties()
{
if (isWithSource)
{
if (_SourceDrive.eEncryptionType == Drive.nEncryptionType.DirectoryUnencrypted)
{
DirectoryInfo DirectoryInfoSource = new DirectoryInfo(sSourcePath);
if (DirectoryInfoSource.Exists)
{
try
{
_uAttributesSource = (uint)DirectoryInfoSource.Attributes;
_CreationTimeSource = DirectoryInfoSource.CreationTime;
_LastAccessTimeSource = DirectoryInfoSource.LastAccessTime;
_LastWriteTimeSource = DirectoryInfoSource.LastWriteTime;
_uLastWriteTimeSource = DateTimeToUint(_LastWriteTimeSource);
_sLastWriteTimeSource = DateTimeToString(_LastWriteTimeSource);
if (_isDirectory != (_uAttributesSource & (uint)FileAttributes.Directory) > 0)
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Contradictory informaton on whether this is a directory or a file.";
}
}
catch
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Could not read properties of source directory.";
}
}
else
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Source directory not found.";
}
}
}
else if (_eComparison != nComparison.Error)
{
eComparison = nComparison.DestinationOnly;
}
if (isWithDestination)
{
if (_DestinationDrive.eEncryptionType == Drive.nEncryptionType.DirectoryUnencrypted)
{
DirectoryInfo DirectoryInfoDestination = new DirectoryInfo(sDestinationPath);
if (DirectoryInfoDestination.Exists)
{
try
{
_uAttributesDestination = (uint)DirectoryInfoDestination.Attributes;
_CreationTimeDestination = DirectoryInfoDestination.CreationTime;
_LastAccessTimeDestination = DirectoryInfoDestination.LastAccessTime;
_LastWriteTimeDestination = DirectoryInfoDestination.LastWriteTime;
_uLastWriteTimeDestination = DateTimeToUint(_LastWriteTimeDestination);
_sLastWriteTimeDestination = DateTimeToString(_LastWriteTimeDestination);
if (_isDirectory != (_uAttributesDestination & (uint)FileAttributes.Directory) > 0)
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Contradictory informaton on whether this is a directory or a file.";
}
}
catch
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Could not read properties of destination directory.";
}
}
else
{
_eComparison = PairOfFiles.nComparison.Error;
_sErrorMessage = "Destination directory not found.";
}
}
}
else if (_eComparison != nComparison.Error)
{
eComparison = nComparison.SourceOnly;
}
CompareLastWriteTimes();
}
