/// <summary>
/// Die Daten eines Elements analysieren und daraus ein Objekt erstellen.
/// </summary>
/// <param name="id">Die ID des Element, zum Beispiel GR_389F860B088563B1.</param>
/// <returns>Ein Objekt, das die Daten des Elements in Enable Now enthält</returns>
internal async Task <Element> CrawlElementAsync(string id)
{
Element element = new(id);
FillInitialFields(element);
MetaDataCollection metaData = await MetaAnalyzer.LoadMetaFilesAsync(element);
FillFields(element, metaData);
AddAssets(element, metaData);
string autostartId = GetAutostartId(metaData);
StatisticService statisticService = StatisticService.GetService(_jobConfig.Id);
if (autostartId != null)
{
try
{
Element autostartElement = await CrawlElementAsync(autostartId);
OverwriteValuesByAutostartElement(element, autostartElement);
statisticService.IncreaseAutostartElementsCount();
}
catch
{
_log.Warn(LocalizationService.FormatResourceString("ElementCrawlerMessage01"));
}
}
element.Hash = element.GenerateHashCode();
SetDateValue(element);
statisticService.IncreaseFoundDocumentsCount();
return(element);
}
/// <summary>
///
/// </summary>
/// <param name="temporaryValue"></param>
/// <param name="expressionEvaluator"></param>
/// <param name="metaData"></param>
/// <returns>Eine Liste mit den Werten oder null, wenn der Ausdruck kein Ergebnis liefert.</returns>
private string[] EvaluateField(string temporaryValue, ExpressionEvaluator expressionEvaluator, MetaDataCollection metaData)
{
if (!ExpressionEvaluator.IsExpression(temporaryValue, out string expression))
{
_log.Debug(LocalizationService.FormatResourceString("ElementCrawlerMessage02", temporaryValue));
return(string.IsNullOrWhiteSpace(temporaryValue) ? null : new string[] { temporaryValue });
}
if (ExpressionEvaluator.IsVariableExpression(expression, out string variableName))
{
string value = Util.RemoveMarkup(MetaAnalyzer.ExtractValue(metaData, variableName));
_log.Debug(LocalizationService.FormatResourceString("ElementCrawlerMessage03", expression, value));
return(string.IsNullOrWhiteSpace(value) ? null : new string[] { value });
}
if (ExpressionEvaluator.IsConverterExpression(expression, out string converterClassName, out string[] converterParameterNames))
{
int parameterCount = converterParameterNames.Length;
string[] converterParameterValues = new string[parameterCount];
for (int i = 0; i < parameterCount; i++)
{
string converterParameter = converterParameterNames[i];
bool isVariable = ExpressionEvaluator.IsVariableExpression(converterParameter, out string converterVariableName);
converterParameterValues[i] = isVariable ?
Util.RemoveMarkup(MetaAnalyzer.ExtractValue(metaData, converterVariableName)) :
converterParameterNames[i];
}
_log.Debug(LocalizationService.FormatResourceString("ElementCrawlerMessage04", expression, converterClassName, ""));
return(ExpressionEvaluator.EvaluateAsConverter(converterClassName, converterParameterValues));
}
return(null);
}
private void GenerateSubMaps(Queue <MetaMap> maps, MetaAnalyzer analyzer, IReader reader, ICacheFile cacheFile)
{
var generatedMaps = new Dictionary <uint, MetaMap>();
while (maps.Count > 0)
{
MetaMap map = maps.Dequeue();
foreach (MetaValueGuess guess in map.Guesses.Where(guess => guess.Type == MetaValueType.Reflexive))
{
MetaMap subMap;
if (!generatedMaps.TryGetValue(guess.Pointer, out subMap))
{
subMap = new MetaMap();
reader.SeekTo(cacheFile.MetaArea.PointerToOffset(guess.Pointer));
analyzer.AnalyzeArea(reader, guess.Pointer, subMap);
maps.Enqueue(subMap);
generatedMaps[guess.Pointer] = subMap;
}
map.AssociateSubMap(guess.Offset, subMap);
}
}
}
private void worker_DoWork(object sender, DoWorkEventArgs e, IList <MapEntry> generatorMaps, string outputPath,
BackgroundWorker worker)
{
var globalMaps = new Dictionary <string, MetaMap>();
DateTime startTime = DateTime.Now;
string gameIdentifier = "";
worker.ReportProgress(0);
for (int i = 0; i < generatorMaps.Count; i++)
{
var tagMaps = new Dictionary <ITag, MetaMap>();
IReader reader;
KeyValuePair <ICacheFile, EngineDescription> cacheData = LoadMap(generatorMaps[i].LocalMapPath, out reader);
ICacheFile cacheFile = cacheData.Key;
var analyzer = new MetaAnalyzer(cacheFile);
if (gameIdentifier == "")
{
gameIdentifier = cacheData.Value.Settings.GetSetting <string>("shortName");
}
var mapsToProcess = new Queue <MetaMap>();
foreach (ITag tag in cacheFile.Tags)
{
if (tag.MetaLocation == null)
{
continue;
}
var map = new MetaMap();
tagMaps[tag] = map;
mapsToProcess.Enqueue(map);
reader.SeekTo(tag.MetaLocation.AsOffset());
analyzer.AnalyzeArea(reader, tag.MetaLocation.AsPointer(), map);
}
GenerateSubMaps(mapsToProcess, analyzer, reader, cacheFile);
var classMaps = new Dictionary <string, MetaMap>();
foreach (ITag tag in cacheFile.Tags)
{
if (tag.MetaLocation == null)
{
continue;
}
MetaMap map = tagMaps[tag];
EstimateMapSize(map, tag.MetaLocation.AsPointer(), analyzer.GeneratedMemoryMap, 1);
string magicStr = CharConstant.ToString(tag.Class.Magic);
MetaMap oldClassMap;
if (classMaps.TryGetValue(magicStr, out oldClassMap))
{
oldClassMap.MergeWith(map);
}
else
{
classMaps[magicStr] = map;
}
}
foreach (var map in classMaps)
{
MetaMap globalMap;
if (globalMaps.TryGetValue(map.Key, out globalMap))
{
globalMap.MergeWith(map.Value);
}
else
{
globalMaps[map.Key] = map.Value;
}
}
reader.Close();
worker.ReportProgress(100 * (i + 1) / (generatorMaps.Count));
}
string badChars = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
foreach (var map in globalMaps)
{
string filename = badChars.Aggregate(map.Key, (current, badChar) => current.Replace(badChar, '_'));
filename += ".xml";
string path = Path.Combine(outputPath, filename);
var settings = new XmlWriterSettings
{
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(path, settings))
{
var pluginWriter = new AssemblyPluginWriter(writer, gameIdentifier);
int size = map.Value.GetBestSizeEstimate();
FoldSubMaps(map.Value);
pluginWriter.EnterPlugin(size);
pluginWriter.EnterRevisions();
pluginWriter.VisitRevision(new PluginRevision("Assembly", 1, "Generated plugin from scratch."));
pluginWriter.LeaveRevisions();
WritePlugin(map.Value, size, pluginWriter);
pluginWriter.LeavePlugin();
}
}
DateTime endTime = DateTime.Now;
e.Result = endTime.Subtract(startTime);
}
internal ElementCrawler()
{
_jobConfig = JobManager.GetJobManager().SelectedJobConfig;
_metaAnalyzer = new MetaAnalyzer();
InitializeMappingFields();
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <param name="metaData"></param>
private void AddAssets(Element element, MetaDataCollection metaData)
{
MetaAnalyzer.ExtractAssets(metaData, out string[] childrenIds, out string[] attachementIds);
element.ChildrenIds = childrenIds;
element.AttachementNames = attachementIds;
}
