//---------------------------------------------------------------------------
bool TFileMasks::Matches(const UnicodeString & FileName, bool Directory,
const UnicodeString & Path, const TParams * Params,
bool & ImplicitMatch) const
{
bool ImplicitIncludeMatch = (FMasks[MASK_INDEX(Directory, true)].empty());
bool ExplicitIncludeMatch = MatchesMasks(FileName, Directory, Path, Params, FMasks[MASK_INDEX(Directory, true)], true);
bool Result =
(ImplicitIncludeMatch || ExplicitIncludeMatch) &&
!MatchesMasks(FileName, Directory, Path, Params, FMasks[MASK_INDEX(Directory, false)], false);
ImplicitMatch =
Result && ImplicitIncludeMatch && !ExplicitIncludeMatch &&
FMasks[MASK_INDEX(Directory, false)].empty();
return Result;
}
mask_t random_mask() {
mask_t mask = EMPTY_MASK;
int col, row;
for (col = 0; col < NUM_COLS; col++) {
for (row = 0; row < NUM_ROWS; row++) {
if (RAND_COLOR == RED) {
mask = ADD_TO_MASK(mask, MASK_INDEX(row, col));
}
}
}
return mask;
}
static json_object *json_shrink_random(mask_t mask) {
json_object *jdots = json_object_new_array();
int row, col;
for (row = 0; row < NUM_ROWS; row++) {
for (col = 0; col < NUM_ROWS; col++) {
int i = MASK_INDEX(row, col);
if (MASK_CONTAINS(mask, i)) {
json_object_array_add(jdots, json_coord(i));
}
}
}
return jdots;
}
/* Pretty print a mask with a foreground and background color. */
void pprint_mask(mask_t mask, color_t fg, color_t bg) {
grid_t grid = {0};
color_t color;
int col, row;
/* Convert the mask to a grid first, and print that. */
for (col = 0; col < NUM_COLS; col++) {
for (row = 0; row < NUM_ROWS; row++) {
color = MASK_CONTAINS(mask, MASK_INDEX(row, col)) ? fg : bg;
grid[col]= SET_COLUMN_COLOR(grid[col], row, color);
}
}
pprint_grid(grid);
}
/* Create a mask of all of the dots in a grid of a given color. */
mask_t get_color_mask(grid_t grid, color_t color) {
mask_t mask = EMPTY_MASK;
int col, row;
column_t column;
for (col = 0; col < NUM_COLS; col++) {
column = grid[col];
for (row = 0; row < NUM_ROWS; row++) {
if (GET_COLUMN_COLOR(column, row) == color) {
mask = ADD_TO_MASK(mask, MASK_INDEX(row, col));
}
}
}
return mask;
}
/* Destructively apply a move to a grid by repeatedly shrink the dots from
* top to bottom. Returns the number of dots that were shrunk.
*/
int apply_move(grid_t grid, mask_t move) {
int col, row, shrink, has_cycle = HAS_CYCLE(move), num_dots = 0;
mask_t encircled;
color_t cycle_color;
if (has_cycle) {
encircled = encircled_dots[GET_CYCLE_NUMBER(move)];
cycle_color = GET_CYCLE_COLOR(move);
}
for (col = 0; col < NUM_COLS; col++) {
for (row = 0; row < NUM_ROWS; row++) {
shrink = MASK_CONTAINS(move, MASK_INDEX(row, col));
if (has_cycle) {
shrink |= MASK_CONTAINS(encircled, MASK_INDEX(row, col));
shrink |= GET_COLUMN_COLOR(grid[col], row) == cycle_color;
}
if (shrink) {
grid[col] = SHRINK_COLUMN(grid[col], row);
num_dots++;
}
}
}
return num_dots;
}
/* Count the occupied neighbor dots, i.e. the degree of a node. Directions are in counter-clockwise order. */
void get_neighbors(mask_t mask, int i, int *num_neighbors, neighbors_t neighbors) {
int row = INDEX_ROW(i);
int col = INDEX_COL(i);
*num_neighbors = 0;
mask &= ALL_DOTS;
i = MASK_INDEX(row-1, col); /* Up */
if (row-1 >= 0 && MASK_CONTAINS(mask, i)) {
neighbors[(*num_neighbors)++] = i;
}
i = MASK_INDEX(row, col-1); /* Left */
if (col-1 >= 0 && MASK_CONTAINS(mask, i)) {
neighbors[(*num_neighbors)++] = i;
}
i = MASK_INDEX(row+1, col); /* DOWN */
if (row+1 < NUM_ROWS && MASK_CONTAINS(mask, i)) {
neighbors[(*num_neighbors)++] = i;
}
i = MASK_INDEX(row, col+1); /* Right */
if (col+ 1 < NUM_COLS && MASK_CONTAINS(mask, i)) {
neighbors[(*num_neighbors)++] = i;
}
}
//---------------------------------------------------------------------------
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);
}
