bool StringPropertySet::Parse(const StringRef& str)
{
RETURN_TRUE_IF_EMPTY(str);
//Key=Value,...
List<StringRef> outPairs;
StringParser::Split(str, ",", outPairs);
List<StringRef> keyValuePair;
for (auto& optionPair : outPairs)
{
keyValuePair.Clear();
StringParser::Split(optionPair, "=", keyValuePair);
if (keyValuePair.Count() == 2)
{
Add(keyValuePair[0], keyValuePair[1]);
}
else if (keyValuePair.Count() == 1)
{
Add(keyValuePair[0], HeapString::Empty);
}
else
{
Log::FormatError("Invalid attribute str:{} in {}", optionPair.c_str(), str.c_str());
return false;
}
}
return true;
}
void TestList() {
List<int> a;
a.Add(3);
a.Add(5);
assert(a.Count() == 2);
assert(a.Contains(3));
assert(a.Contains(5));
assert(a[0] == 3);
List<int> b(a);
b.Add(a);
assert(b.Count() == 4);
a.Remove(3);
assert(a.Count() == 1);
assert(a.Contains(3) == false);
assert(a[0] = 5);
a.Insert(4, 0);
a.Insert(6, 1);
a.Insert(7, a.Count() - 1);
assert(a[0] == 4);
assert(a[1] == 6);
assert(a[2] == 7);
a.Remove(6);
assert(a[2] == 5);
}
//
// Serialization.
//
virtual void Serialize(Stream &stream) const {
// Only the actions are saved.
stream.Write(actions_.Count());
for(size_t i = 0; i < actions_.Count(); i++) {
stream.Write((int)actions_[i]->Type());
stream.Write(*actions_[i]);
}
}
void SearchDescendantClasses(ParsingSymbol* parent, ParsingSymbolManager* manager, List<ParsingSymbol*>& children)
{
vint start = children.Count();
SearchChildClasses(parent, manager->GetGlobal(), manager, children);
vint end = children.Count();
for (vint i = start; i < end; i++)
{
SearchDescendantClasses(children[i], manager, children);
}
}
void WriteErrors(GuiResourceError::List& errors, const WString& resourceName)
{
auto outputPath = FilePath(GetTestOutputPath()) / (resourceName + L".txt");
auto baselinePath = FilePath(GetTestResourcePath()) / (resourceName + L".txt");
List<WString> output;
GuiResourceError::SortAndLog(errors, output, GetTestResourcePath());
File(outputPath).WriteAllLines(output, false, BomEncoder::Utf8);
List<WString> baseline;
File(baselinePath).ReadAllLinesByBom(baseline);
if (baseline.Count() > 0 && baseline[baseline.Count() - 1] == L"")
{
baseline.RemoveAt(baseline.Count() - 1);
}
vint count = output.Count();
if (count < baseline.Count())
{
count = baseline.Count();
}
for (vint i = 0; i < count; i++)
{
TEST_ASSERT(output.Count() > i);
TEST_ASSERT(baseline.Count() > i);
TEST_ASSERT(output[i] == baseline[i]);
}
}
void SkylineBinPack::Insert(List<Size2U> &sizes, List<Rect2U> &outRects, LevelChoiceHeuristic method)
{
while (sizes.Count() > 0)
{
Rect2U bestRect;
Size2U bestSize(Math::IntMaxValue, Math::IntMaxValue);
int bestSkylineIndex = -1;
int bestRectIndex = -1;
for (size_t i = 0; i < sizes.Count(); ++i)
{
Rect2U newRect;
Size2U outBestSize;
int outBestIndex = 0;
switch (method)
{
case LevelChoiceHeuristic::LevelBottomLeft:
newRect = FindPositionForNewNodeBottomLeft(sizes[i], outBestSize, outBestIndex);
break;
case LevelChoiceHeuristic::LevelMinWasteFit:
newRect = FindPositionForNewNodeMinWaste(sizes[i], outBestSize.Height, outBestSize.Width, outBestIndex);
break;
default:
assert(false);
break;
}
if (newRect.Size.Height != 0)
{
if (outBestSize.Width < bestSize.Width || (outBestSize.Width == bestSize.Width && outBestSize.Height < bestSize.Height))
{
bestRect = newRect;
bestSize = outBestSize;
bestSkylineIndex = outBestIndex;
bestRectIndex = (int)i;
}
}
}
if (bestRectIndex == -1)
return;
// Perform the actual packing.
AddSkylineLevel(bestSkylineIndex, bestRect);
mUsedSurfaceArea += (sizes[bestRectIndex]).Area();
sizes.RemoveAt(bestRectIndex);
outRects.Add(bestRect);
}
}
bool GuiSaveFileDialog::ShowDialog()
{
List<WString> fileNames;
auto service = GetCurrentController()->DialogService();
if (!service->ShowFileDialog(
GetHostWindow()->GetNativeWindow(),
fileNames,
filterIndex,
(enabledPreview ? INativeDialogService::FileDialogSavePreview : INativeDialogService::FileDialogSave),
title,
fileName,
directory,
defaultExtension,
filter,
options))
{
return false;
}
if (fileNames.Count() > 0)
{
fileName = fileNames[0];
FileNameChanged.Execute(GuiEventArgs());
FilterIndexChanged.Execute(GuiEventArgs());
}
return true;
}
// Override of the List interface
List* Append( VALUE elem ) {
#ifdef USE_CONS_OPTIMIZATIONS
List* tail = this;
while (!tail->Rest().IsEmpty() ) {
tail = tail->Rest().GetList();
}
if (tail->RefCount < 2 && tail->Rest().IsEmpty()) {
// We can optimize things as we can reuse this materalization.
// Nobody is referencing it.
if (tail->AttemptDirtyAdd(elem)) {
return this;
};
}
#endif
int originalCount = Count();
int last = Count()-1;
List* c = VALUE(QParenthesis,elem).GetList();
while (last >= 0) {
c = c->Prepend( GetAt(last) );
last--;
}
int newCount = c->Count();
assert( newCount == originalCount + 1 );
// std::cout << "\nBefore:" << LIST(this).Print();
// std::cout << "\nAdded:" << elem.Print();
// std::cout << "\nAfter:" << LIST(c).Print() << "\n";
return c;
}
void Application::Dispose()
{
{
List<BaseForm *> forms;
for (auto & c : *components)
{
if (c.Value)
{
BaseForm * ctrl = dynamic_cast<BaseForm*>(c.Value);
if (ctrl)
{
forms.Add(ctrl);
}
c.Value = 0;
}
}
for (int i=0; i<forms.Count(); i++)
delete forms[i];
delete components;
delete cmdLine;
delete objMap;
delete onMainLoop;
}
GdiplusShutdown(gdiToken);
_CrtDumpMemoryLeaks();
}
const FileEntry* FileStorage::FindFile(const StringRef& path, const DirectoryEntry* parent/* = nullptr*/) const
{
if (parent == nullptr)
{
parent = &mRootDir;
}
if (Path::IsPath(path))
{
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
const DirectoryEntry* dir = parent;
for (uint i = 0; i < paths.Count() - 1; ++i)
{
dir = dir->FindDirectory(paths[i]);
RETURN_NULL_IF_NULL(dir);
}
return dir->FindFile(paths.Last());
}
else
{
return parent->FindFile(path);
}
}
void SymbolTable::EvalFunctionReferenceClosure()
{
for (auto & func : Functions)
{
List<String> funcList;
EnumerableHashSet<String> funcSet;
for (auto & ref : func.Value->ReferencedFunctions)
{
funcList.Add(ref);
funcSet.Add(ref);
}
for (int i = 0; i < funcList.Count(); i++)
{
RefPtr<FunctionSymbol> funcSym;
if (Functions.TryGetValue(funcList[i], funcSym))
{
for (auto rfunc : funcSym->ReferencedFunctions)
{
if (funcSet.Add(rfunc))
funcList.Add(rfunc);
}
}
}
func.Value->ReferencedFunctions = _Move(funcSet);
}
}
FileEntry* FileStorage::FindOrCreateFileEntry(const StringRef& path, DirectoryEntry* parent /*= nullptr*/)
{
if (parent == nullptr)
{
parent = &mRootDir;
}
FileEntry* fileEntry = nullptr;
if (Path::IsPath(path))
{
List<HeapString> paths;
RETURN_NULL_IF_FALSE(Path::Split(path, paths));
DirectoryEntry* dir = parent;
for (uint i = 0; i < paths.Count() - 1; ++i)
{
dir = dir->FindOrCreateDirectoryEntry(paths[i]);
RETURN_NULL_IF_NULL(dir);
}
fileEntry = dir->FindOrCreateFileEntry(paths.Last());
}
else
{
fileEntry = parent->FindOrCreateFileEntry(path);
}
return fileEntry;
}
void ClearActions() {
for(size_t i = 0; i < actions_.Count(); i++) {
delete actions_[i];
}
actions_.Clear();
}
bool Version::TryParse(const StringRef& versionString, Version& outVersion)
{
outVersion = Version::Zero;
List<HeapString> parts;
StringParser::Split(versionString, StringRef("."), parts);
uint length = (uint)parts.Count();
RETURN_FALSE_IF(length < 2 || length>4);
long outMajor;
if (parts[0].TryParseInt(outMajor))
{
outVersion.SetMajor((uint)outMajor);
}
else
{
return false;
}
long outMinor;
if (parts[1].TryParseInt(outMinor))
{
outVersion.SetMinor((uint)outMinor);
}
else
{
return false;
}
length -= 2;
if (length > 0)
{
long outBuild;
if (parts[2].TryParseInt(outBuild))
{
outVersion.SetBuild((uint)outBuild);
}
else
{
return false;
}
--length;
if (length > 0)
{
long outRevision;
if (parts[3].TryParseInt(outRevision))
{
outVersion.SetRevision((uint)outRevision);
}
else
{
return false;
}
}
}
return true;
}
List<Vec4> ChoiceForm::ReadFrameData(GL::Texture2D tex)
{
List<Vec4> rs;
int w, h;
tex.GetSize(w, h);
rs.SetSize(w*h);
tex.GetData(0, DataType::Float4, rs.Buffer(), rs.Count()*sizeof(Vec4));
return rs;
}
int TotalSteps() {
int sum = 0;
for(size_t i = 0; i < actions_.Count(); i++) {
sum += actions_[i]->Steps();
}
return sum;
}
void Play() {
if(actions_.Count() == 0) return;
currentAction_ = actions_[0];
currentPosition_ = 0;
currentStep_ = 0;
List<Point> *firstPoints = new List<Point>(shape_->Points());
points_.Add(firstPoints);
// Initialize the start action and the ones connected to it.
currentAction_->Initialize(*firstPoints);
for(size_t i = 1; i < actions_.Count(); i++) {
if(actions_[i]->WithPrevious() == false) return;
actions_[i]->Initialize(*firstPoints);
}
}
WString GetBirthdayText()override
{
List<WString> formats;
Locale::UserDefault().GetShortDateFormats(formats);
if (formats.Count() > 0)
{
return Locale::UserDefault().FormatDate(formats[0], birthday);
}
return L"";
}
static Point Centroid(const List<Point> &points) {
double sumX = 0;
double sumY = 0;
double sumZ = 0;
if(points.Count() == 0) {
return Point();
}
size_t count = points.Count();
for(size_t i = 0; i < count; i++) {
Point &point = points[i];
sumX += point.X;
sumY += point.Y;
sumZ += point.Z;
}
return Point(sumX / count, sumY / count, sumZ / count);
}
bool Config::tryGetValue(const List<String>& input, const String& name, int& value)
{
for (int i = 0; i < input.Count(); i++)
{
auto parts = input[i].Split(':');
if (parts.Count() == 2 && parts[0].Trim() == name)
{
if (parts[1].Trim().TryParseInt(value)) return true;
}
}
return false;
}
void Reset() {
currentAction_ = NULL;
currentPosition_ = 0;
currentStep_ = 0;
// Remove all computed points in the current step.
for(size_t i = 0; i < points_.Count(); i++) {
delete points_[i];
}
points_.Clear();
}
BOOL IsExclusiveWindow(wchar_t *className)
{
List *ExclusiveList = settingIsAutoFix ? &ExclusiveList_NoFix : &ExclusiveList_ToFix;
for (int x = 0; x < ExclusiveList->Count(); x++)
{
wchar_t *excludedWindowClass = (wchar_t*)ExclusiveList->Get(x);
if (MaskedStringCompare((wchar_t*)className, excludedWindowClass) == TRUE)
return TRUE;
}
return FALSE;
};
// tries moving checker from one cell to another (maybe with beats)
// returns: NULL if failed, otherwise byte array to be sent to another player
byte* Field::TryComplexMove(Cell from, Cell to, byte* prevBuffer)
{
// correctness checking
if (!from.IsGood() || !to.IsGood()) return false;
if (!from.IsBlack() || !to.IsBlack()) return false;
if (!IsMyChecker(from) || !IsEmptyCell(to)) return false;
// once preserve space enought to store info about all possible beats
if (!prevBuffer)
{
if (!(prevBuffer = new byte[packetSize])) return NULL;
for (int i = 0; i < packetSize; prevBuffer[i++] = 0);
}
byte* subResult;
// if no beats before checker can simply move
if (prevBuffer[0] == 0 && (subResult = TryMove(from, to)))
return subResult;
// try to beat enemy and land on "to" cell
if (subResult = TryBeat(from, to, prevBuffer)) return subResult;
// recursively beat enemy checkers
List jumps = GetAvailableBeatJumps(from);
int before; // for backup
for (int i = 0; i < jumps.Count(); i++)
{
before = strlen(prevBuffer);
if (TryBeat(from, *jumps[i], prevBuffer))
{
// if we can beat, check for the next beat
if (TryComplexMove(*jumps[i], to, prevBuffer)) return prevBuffer;
else
{
// if recursive beats fails, restore backup info
Cell beaten((max(from.row, jumps[i]->row) + min(from.row, jumps[i]->row)) / 2,
(max(from.column, jumps[i]->column) + min(from.column, jumps[i]->column)) / 2);
enemyCheckers.Add(beaten);
myCheckers[*jumps[i]]->MoveChecker(from);
for (int i = before, len = strlen(prevBuffer); i < len; prevBuffer[i++] = 0);
}
}
}
jumps.Clear();
if (!strlen(prevBuffer))
{
delete [] prevBuffer;
prevBuffer = NULL;
}
return NULL;
}
WString WriteNamespace(List<WString>& currentNamespaces, List<WString>& namespaces, StreamWriter& writer)
{
vint common = 0;
for (vint i = 0; i < currentNamespaces.Count() && i < namespaces.Count(); i++)
{
if (currentNamespaces[i] == namespaces[i])
{
common++;
}
else
{
break;
}
}
for (vint i = 0; i < currentNamespaces.Count() - common; i++)
{
WString prefix;
for (vint j = 0; j < currentNamespaces.Count() - i - 1; j++)
{
prefix += L"\t";
}
writer.WriteLine(prefix + L"}");
}
WString prefix;
FOREACH_INDEXER(WString, ns, i, namespaces)
{
if (i >= common)
{
writer.WriteLine(prefix + L"namespace " + ns);
writer.WriteLine(prefix + L"{");
}
prefix += L"\t";
}
CopyFrom(currentNamespaces, namespaces);
return prefix;
}
AutoPointerArray<String> DirectoryContent(const String& Path)
{
AutoPointerArray<String> result;
List<String> list;
WIN32_FIND_DATA findFileData;
HANDLE hFind;
String winPath=Path+"\\*";// search for everything
hFind=FindFirstFile(winPath.c_str(),&findFileData);
if (hFind!=INVALID_HANDLE_VALUE)
{
do
{
if (strcmp(findFileData.cFileName,".")!=0 && strcmp(findFileData.cFileName,"..")!=0)
list.AddLast(String(findFileData.cFileName, MAX_PATH));
}while(FindNextFile(hFind,&findFileData)!=0);
FindClose(hFind);
result = AutoPointerArray<String>(new String[list.Count()], list.Count());
for (UInt32 i=0;i<result.Count();++i)
result[i].Swap(list[i]);
}
return result;
}
void MergeStates(Ptr<Automaton> automaton, Ptr<RuleInfo> ruleInfo, List<State*>& newStates)
{
SortedList<State*> stateContentSorted;
while(true)
{
for(vint i=0;i<newStates.Count();i++)
{
State* state1=newStates[i];
if(IsMergableCandidate(state1, ruleInfo))
{
for(vint j=i+1;j<newStates.Count();j++)
{
State* state2=newStates[j];
if(state1!=state2 && IsMergableCandidate(state2, ruleInfo))
{
RearrangeState(state1, stateContentSorted);
RearrangeState(state2, stateContentSorted);
if(IsMergableBecauseTransitions(state1, state2))
{
MergeState2ToState1BecauseTransitions(automaton, state1, state2);
newStates.RemoveAt(j);
goto MERGED_STATES_PAIR;
}
else if(IsMergableBecauseInputs(state1, state2))
{
MergeState2ToState1BecauseInputs(automaton, state1, state2);
newStates.RemoveAt(j);
goto MERGED_STATES_PAIR;
}
}
}
}
}
break;
MERGED_STATES_PAIR:
continue;
}
}
Token & ReadToken(TokenType type)
{
if (pos >= tokens.Count())
{
errors.Add(CompileError(TokenTypeToString(type) + String(L" expected but end of file encountered."), 0, CodePosition(0, 0, fileName)));
throw 0;
}
else if (tokens[pos].Type != type)
{
errors.Add(CompileError(TokenTypeToString(type) + String(L" expected"), 20001, tokens[pos].Position));
throw 20001;
}
return tokens[pos++];
}
Token & ReadToken(const wchar_t * string)
{
if (pos >= tokens.Count())
{
errors.Add(CompileError(String(L"\"") + string + String(L"\" expected but end of file encountered."), 0, CodePosition(0, 0, fileName)));
throw 0;
}
else if (tokens[pos].Content != string)
{
errors.Add(CompileError(String(L"\"") + string + String(L"\" expected"), 0, tokens[pos].Position));
throw 20001;
}
return tokens[pos++];
}
static void IO(Reader& reader, IMethodInfo*& value)
{
ITypeDescriptor* type = 0;
WString name;
List<WString> parameters;
reader << type << name << parameters;
auto group =
name == L"#ctor" ? type->GetConstructorGroup() :
type->GetMethodGroupByName(name, false);
CHECK_ERROR(group, L"Failed to load method.");
value = 0;
vint count = group->GetMethodCount();
for (vint i = 0; i < count; i++)
{
auto method = group->GetMethod(i);
if (method->GetParameterCount() == parameters.Count())
{
bool found = true;
for (vint j = 0; j < parameters.Count(); j++)
{
if (method->GetParameter(j)->GetName() != parameters[j])
{
found = false;
break;
}
}
if (found)
{
CHECK_ERROR(!value, L"Failed to load method.");
value = method;
}
}
}
CHECK_ERROR(value, L"Failed to load method.");
}
void printLabel(IdentifierString& command, int labelPosition, List<int>& labels)
{
int index = getLabelIndex(labelPosition, labels);
if (index == -1) {
index = labels.Count();
labels.add(labelPosition);
}
command.append("Lab");
if (index < 10) {
command.append('0');
}
command.appendInt(index);
}
