WString FilePath::ComponentsToPath(const collections::List<WString>& components)
{
WString result;
WString delimiter = Delimiter;
int i = 0;
#if defined VCZH_GCC
// For Unix-like OSes, if first component is "/" then take it as absolute path
if(components.Count() > 0 && components[0] == delimiter)
{
result += delimiter;
i++;
}
#elif defined VCZH_MSVC
// For Windows, if first component is "\\" then it is an UNC path
if(components.Count() > 0 && components[0] == L"\\")
{
result += delimiter;
i++;
}
#endif
for(; i < components.Count(); i++)
{
result += components[i];
if(i + 1 < components.Count())
result += delimiter;
}
return result;
}
void FillUnmapPageCandidates(collections::List<BufferPageTimeTuple>& pages, vint expectCount)override
{
vint mappedCount = mappedPages.Count();
if (mappedCount == 0) return;
Array<BufferPageTimeTuple> tuples(mappedCount);
vint usedCount = 0;
for (vint i = 0; i < mappedCount; i++)
{
auto key = mappedPages.Keys()[i];
auto value = mappedPages.Values()[i];
if (!value->locked)
{
BufferPage page{key};
tuples[usedCount++] = BufferPageTimeTuple(source, page, value->lastAccessTime);
}
}
if (tuples.Count() > 0)
{
SortLambda(&tuples[0], usedCount, [](const BufferPageTimeTuple& t1, const BufferPageTimeTuple& t2)
{
if (t1.f2 < t2.f2) return -1;
else if (t1.f2 > t2.f2) return 1;
else return 0;
});
vint copyCount = usedCount < expectCount ? usedCount : expectCount;
for (vint i = 0; i < copyCount; i++)
{
pages.Add(tuples[i]);
}
}
}
void FilePath::GetPathComponents(WString path, collections::List<WString>& components)
{
WString pathRemaining = path;
WString delimiter = Delimiter;
components.Clear();
while(true)
{
auto index = INVLOC.FindFirst(pathRemaining, delimiter, Locale::None);
if (index.key == -1)
break;
if(index.key != 0)
components.Add(pathRemaining.Left(index.key));
else
{
#if defined VCZH_GCC
// Unix absolute path starting with "/"
// components[0] will be L"/"
components.Add(delimiter);
#elif defined VCZH_MSVC
if(pathRemaining.Length() >= 2 && pathRemaining[1] == Delimiter)
{
// Windows UNC Path starting with "\\"
// components[0] will be L"\\"
components.Add(L"\\");
index.value++;
}
#endif
}
pathRemaining = pathRemaining.Right(pathRemaining.Length() - (index.key + index.value));
}
if(pathRemaining.Length() != 0)
{
components.Add(pathRemaining);
}
}
bool File::ReadAllLines(collections::List<WString>& lines)const
{
FileStream fileStream(filePath.GetFullPath(), FileStream::ReadOnly);
if (!fileStream.IsAvailable()) return false;
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
while (!reader.IsEnd())
{
lines.Add(reader.ReadLine());
}
return true;
}
Ptr<ShortcutBuilder> ParseInternal(const WString& text, collections::List<Ptr<ParsingError>>& errors)override
{
Ptr<RegexMatch> match=regexShortcut.MatchHead(text);
if (match && match->Result().Length() != text.Length())
{
errors.Add(new ParsingError(L"Failed to parse a shortcut \"" + text + L"\"."));
return 0;
}
Ptr<ShortcutBuilder> builder = new ShortcutBuilder;
builder->text = text;
builder->ctrl = match->Groups().Contains(L"ctrl");
builder->shift = match->Groups().Contains(L"shift");
builder->alt = match->Groups().Contains(L"alt");
WString name = match->Groups()[L"key"][0].Value();
builder->key = GetCurrentController()->InputService()->GetKey(name);
return builder->key == VKEY::_UNKNOWN ? nullptr : builder;
}
void GuiResourceFolder::LoadResourceFolderFromXml(DelayLoadingList& delayLoadings, const WString& containingFolder, Ptr<parsing::xml::XmlElement> folderXml, collections::List<WString>& errors)
{
ClearItems();
ClearFolders();
FOREACH(Ptr<XmlElement>, element, XmlGetElements(folderXml))
{
WString name;
if(Ptr<XmlAttribute> nameAtt=XmlGetAttribute(element, L"name"))
{
name=nameAtt->value.value;
}
if(element->name.value==L"Folder")
{
if (name == L"")
{
errors.Add(L"A resource folder should have a name.");
errors.Add(
L"Format: RESOURCE, Row: " + itow(element->codeRange.start.row + 1) +
L", Column: " + itow(element->codeRange.start.column + 1) +
L", Message: A resource folder should have a name.");
}
else
{
Ptr<GuiResourceFolder> folder=new GuiResourceFolder;
if(AddFolder(name, folder))
{
WString newContainingFolder=containingFolder;
Ptr<XmlElement> newFolderXml=element;
if(Ptr<XmlAttribute> contentAtt=XmlGetAttribute(element, L"content"))
{
if(contentAtt->value.value==L"Link")
{
folder->SetFileContentPath(XmlGetValue(element));
WString filePath = containingFolder + folder->GetFileContentPath();
WString text;
if(LoadTextFile(filePath, text))
{
if(auto parser=GetParserManager()->GetParser<XmlDocument>(L"XML"))
{
if(auto xml=parser->TypedParse(text, errors))
{
newContainingFolder=GetFolderPath(filePath);
newFolderXml=xml->rootElement;
}
}
}
else
{
errors.Add(L"Failed to load file \"" + filePath + L"\".");
}
}
}
folder->LoadResourceFolderFromXml(delayLoadings, newContainingFolder, newFolderXml, errors);
}
else
{
errors.Add(L"Duplicated resource folder name \"" + name + L"\".");
}
}
}
else if(element->name.value.Length() <= 3 || element->name.value.Sub(0, 4) != L"ref.")
{
WString relativeFilePath;
WString filePath;
if(Ptr<XmlAttribute> contentAtt=XmlGetAttribute(element, L"content"))
{
if(contentAtt->value.value==L"File")
{
relativeFilePath = XmlGetValue(element);
filePath = containingFolder + relativeFilePath;
if(name==L"")
{
name=GetFileName(filePath);
}
}
}
Ptr<GuiResourceItem> item = new GuiResourceItem;
if(AddItem(name, item))
{
WString type = element->name.value;
IGuiResourceTypeResolver* typeResolver = GetResourceResolverManager()->GetTypeResolver(type);
IGuiResourceTypeResolver* preloadResolver = typeResolver;
if(typeResolver)
{
if (!typeResolver->DirectLoadXml())
{
WString preloadType = typeResolver->IndirectLoad()->GetPreloadType();
if (preloadType != L"")
{
preloadResolver = GetResourceResolverManager()->GetTypeResolver(preloadType);
if (!preloadResolver)
{
errors.Add(L"Unknown resource resolver \"" + preloadType + L"\" of resource type \"" + type + L"\".");
}
}
}
}
else
{
errors.Add(L"Unknown resource type \"" + type + L"\".");
}
if(typeResolver && preloadResolver)
{
if (auto directLoad = preloadResolver->DirectLoadXml())
{
Ptr<DescriptableObject> resource;
WString itemType = preloadResolver->GetType();
if (filePath == L"")
{
resource = directLoad->ResolveResource(element, errors);
}
else
{
item->SetFileContentPath(relativeFilePath);
resource = directLoad->ResolveResource(filePath, errors);
}
if (typeResolver != preloadResolver)
{
if (auto indirectLoad = typeResolver->IndirectLoad())
{
if(indirectLoad->IsDelayLoad())
{
DelayLoading delayLoading;
delayLoading.type = type;
delayLoading.workingDirectory = containingFolder;
delayLoading.preloadResource = item;
delayLoadings.Add(delayLoading);
}
else if(resource)
{
resource = indirectLoad->ResolveResource(resource, 0, errors);
itemType = typeResolver->GetType();
}
}
else
{
resource = 0;
errors.Add(L"Resource type \"" + typeResolver->GetType() + L"\" is not a indirect load resource type.");
}
}
item->SetContent(itemType, resource);
}
else
{
errors.Add(L"Resource type \"" + preloadResolver->GetType() + L"\" is not a direct load resource type.");
}
}
if(!item->GetContent())
{
RemoveItem(name);
}
}
else
{
errors.Add(L"Duplicated resource item name \"" + name + L"\".");
}
}
}
