//---------------------------------------------------------------------------
bool TFileMasks::Matches(const UnicodeString & FileName, bool Local,
bool Directory, const TParams * Params, bool & ImplicitMatch) const
{
bool Result;
if (Local)
{
UnicodeString Path = ExtractFilePath(FileName);
if (!Path.IsEmpty())
{
Path = ToUnixPath(ExcludeTrailingBackslash(Path));
}
Result = Matches(ExtractFileName(FileName, false), Directory, Path, Params,
ImplicitMatch);
}
else
{
Result = Matches(UnixExtractFileName(FileName), Directory,
UnixExcludeTrailingBackslash(::UnixExtractFilePath(FileName)), Params,
ImplicitMatch);
}
return Result;
}
//---------------------------------------------------------------------------
void TFileMasks::CreateMask(
const UnicodeString & MaskStr, intptr_t MaskStart, intptr_t /*MaskEnd*/, bool Include)
{
bool Directory = false; // shut up
TMask Mask;
Mask.MaskStr = MaskStr;
Mask.UserStr = MaskStr;
Mask.FileNameMask.Kind = TMaskMask::Any;
Mask.FileNameMask.Mask = nullptr;
Mask.DirectoryMask.Kind = TMaskMask::Any;
Mask.DirectoryMask.Mask = nullptr;
Mask.HighSizeMask = TMask::None;
Mask.LowSizeMask = TMask::None;
Mask.HighModificationMask = TMask::None;
Mask.LowModificationMask = TMask::None;
wchar_t NextPartDelimiter = L'\0';
intptr_t NextPartFrom = 1;
while (NextPartFrom <= MaskStr.Length())
{
wchar_t PartDelimiter = NextPartDelimiter;
intptr_t PartFrom = NextPartFrom;
UnicodeString PartStr = CopyToChars(MaskStr, NextPartFrom, L"<>", false, &NextPartDelimiter, true);
intptr_t PartStart = MaskStart + PartFrom - 1;
intptr_t PartEnd = MaskStart + NextPartFrom - 1 - 2;
TrimEx(PartStr, PartStart, PartEnd);
if (PartDelimiter != L'\0')
{
bool Low = (PartDelimiter == L'>');
TMask::TMaskBoundary Boundary;
if ((PartStr.Length() >= 1) && (PartStr[1] == L'='))
{
Boundary = TMask::Close;
PartStr.Delete(1, 1);
}
else
{
Boundary = TMask::Open;
}
TFormatSettings FormatSettings = TFormatSettings::Create(GetDefaultLCID());
FormatSettings.DateSeparator = L'-';
FormatSettings.TimeSeparator = L':';
FormatSettings.ShortDateFormat = L"yyyy/mm/dd";
FormatSettings.ShortTimeFormat = L"hh:nn:ss";
TDateTime Modification;
if (TryStrToDateTime(PartStr, Modification, FormatSettings) ||
TryRelativeStrToDateTime(PartStr, Modification))
{
TMask::TMaskBoundary & ModificationMask =
(Low ? Mask.LowModificationMask : Mask.HighModificationMask);
if ((ModificationMask != TMask::None) || Directory)
{
// include delimiter into size part
ThrowError(PartStart - 1, PartEnd);
}
ModificationMask = Boundary;
(Low ? Mask.LowModification : Mask.HighModification) = Modification;
}
else
{
TMask::TMaskBoundary & SizeMask = (Low ? Mask.LowSizeMask : Mask.HighSizeMask);
__int64 & Size = (Low ? Mask.LowSize : Mask.HighSize);
if ((SizeMask != TMask::None) || Directory)
{
// include delimiter into size part
ThrowError(PartStart - 1, PartEnd);
}
SizeMask = Boundary;
Size = ParseSize(PartStr);
}
}
else if (!PartStr.IsEmpty())
{
intptr_t D = PartStr.LastDelimiter(DirectoryMaskDelimiters);
Directory = (D > 0) && (D == PartStr.Length());
if (Directory)
{
do
{
PartStr.SetLength(PartStr.Length() - 1);
Mask.UserStr.Delete(PartStart - MaskStart + D, 1);
D--;
}
while (PartStr.IsDelimiter(DirectoryMaskDelimiters, PartStr.Length()));
D = PartStr.LastDelimiter(DirectoryMaskDelimiters);
if (FForceDirectoryMasks == 0)
{
Directory = false;
Mask.MaskStr = Mask.UserStr;
}
}
else if (FForceDirectoryMasks > 0)
{
Directory = true;
Mask.MaskStr.Insert(DirectoryMaskDelimiters[1], PartStart - MaskStart + PartStr.Length());
}
if (D > 0)
{
// make sure sole "/" (root dir) is preserved as is
CreateMaskMask(
UnixExcludeTrailingBackslash(ToUnixPath(PartStr.SubString(1, D))),
PartStart, PartStart + D - 1, false,
Mask.DirectoryMask);
CreateMaskMask(
PartStr.SubString(D + 1, PartStr.Length() - D),
PartStart + D, PartEnd, true,
Mask.FileNameMask);
}
else
{
CreateMaskMask(PartStr, PartStart, PartEnd, true, Mask.FileNameMask);
}
}
}
FMasks[MASK_INDEX(Directory, Include)].push_back(Mask);
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::SynchronizeChange(
TObject * /*Sender*/, const UnicodeString Directory, bool & SubdirsChanged)
{
try
{
UnicodeString RemoteDirectory;
UnicodeString RootLocalDirectory;
RootLocalDirectory = IncludeTrailingBackslash(FSynchronizeParams.LocalDirectory);
RemoteDirectory = UnixIncludeTrailingBackslash(FSynchronizeParams.RemoteDirectory);
UnicodeString LocalDirectory = IncludeTrailingBackslash(Directory);
assert(LocalDirectory.SubString(1, RootLocalDirectory.Length()) ==
RootLocalDirectory);
RemoteDirectory = RemoteDirectory +
ToUnixPath(LocalDirectory.SubString(RootLocalDirectory.Length() + 1,
LocalDirectory.Length() - RootLocalDirectory.Length()));
SynchronizeLog(slChange, FMTLOAD(SYNCHRONIZE_CHANGE,
(ExcludeTrailingBackslash(LocalDirectory))));
if (FOnSynchronize != NULL)
{
// this is completelly wrong as the options structure
// can contain non-root specific options in future
TSynchronizeOptions * Options =
((LocalDirectory == RootLocalDirectory) ? FOptions : NULL);
TSynchronizeChecklist * Checklist = NULL;
FOnSynchronize(this, LocalDirectory, RemoteDirectory, FCopyParam,
FSynchronizeParams, &Checklist, Options, false);
if (Checklist != NULL)
{
try
{
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SubdirsChanged = false;
assert(Checklist != NULL);
for (int Index = 0; Index < Checklist->Count; Index++)
{
const TSynchronizeChecklist::TItem * Item = Checklist->Item[Index];
// note that there may be action saDeleteRemote even if nothing has changed
// so this is sub-optimal
if (Item->IsDirectory)
{
if ((Item->Action == TSynchronizeChecklist::saUploadNew) ||
(Item->Action == TSynchronizeChecklist::saDeleteRemote))
{
SubdirsChanged = true;
break;
}
else
{
assert(false);
}
}
}
}
else
{
SubdirsChanged = false;
}
}
__finally
{
delete Checklist;
}
}
}
}
catch(Exception & E)
{
SynchronizeAbort(dynamic_cast<EFatal*>(&E) != NULL);
}
}
