static string DumpHeaders(HGame game, bool isDumpingOutgoing)
{
IReadOnlyDictionary <ushort, ASClass> messageClasses =
(isDumpingOutgoing ? game.OutgoingMessages : game.IncomingMessages);
IOrderedEnumerable <KeyValuePair <string, List <ushort> > > organizedHeaders =
GetOrganizedHeadersByHashCount(game, messageClasses);
string headersDump = string.Empty;
string unusedHeadersDump = string.Empty;
string messageType = (isDumpingOutgoing ? "Outgoing" : "Incoming");
var unusedHeaders = new List <KeyValuePair <string, List <ushort> > >();
foreach (KeyValuePair <string, List <ushort> > organizedHeader in organizedHeaders)
{
if (organizedHeader.Value.Count == 1)
{
if (isDumpingOutgoing)
{
UniqueOutMessageHashCount++;
}
else
{
UniqueInMessageHashCount++;
}
}
string messageHash = organizedHeader.Key;
foreach (ushort header in organizedHeader.Value)
{
ASClass messageClass = messageClasses[header];
string messageName = messageClass.Instance.QualifiedName.Name;
ASMethod messageCtor = messageClass.Instance.Constructor;
string dump = $"{messageType}[{header}, {messageHash}] = {messageName}{messageCtor}";
if (!isDumpingOutgoing)
{
ASClass inMsgParser = game.GetIncomingMessageParser(messageClass);
dump += ($", Parser: {inMsgParser.Instance.QualifiedName.Name}");
}
dump += "\r\n";
if (!game.IsMessageReferenced(messageClass))
{
unusedHeadersDump += ("[Dead]" + dump);
}
else
{
headersDump += dump;
}
}
}
if (!string.IsNullOrWhiteSpace(unusedHeadersDump))
{
headersDump += unusedHeadersDump;
}
return(headersDump.Trim());
}
static string UpdateHeaders(string headersPath, HGame current, HGame previous, bool isUpdatingOutgoing)
{
IReadOnlyDictionary <ushort, ASClass> curMsgClasses =
(isUpdatingOutgoing ? current.OutgoingMessages : current.IncomingMessages);
IReadOnlyDictionary <ushort, ASClass> preMsgClasses =
(isUpdatingOutgoing ? previous.OutgoingMessages : previous.IncomingMessages);
string value = File.ReadAllText(headersPath);
MatchEvaluator replacer =
delegate(Match match)
{
bool isOut = isUpdatingOutgoing;
string endValue = match.Groups["end"].Value;
string headerValue = match.Groups["header"].Value;
ushort preHeader = 0;
if (!ushort.TryParse(headerValue, out preHeader) ||
!preMsgClasses.ContainsKey(preHeader))
{
if (headerValue != "0000")
{
return($"-1{endValue} //Invalid Header '{headerValue}'");
}
else
{
return("-1" + endValue);
}
}
ASClass msgClass = preMsgClasses[preHeader];
string hash = previous.GetMessageHash(msgClass);
bool isDead = false;
string result = string.Empty;
IReadOnlyList <ASClass> curSimilars = current.GetMessages(hash);
if (curSimilars == null)
{
return($"-1{endValue} //No Matches {msgClass.Instance.QualifiedName.Name}[{headerValue}]");
}
else
{
ASClass curMsgClass = curSimilars[0];
isDead = !current.IsMessageReferenced(curMsgClass);
if (curSimilars.Count == 1)
{
ushort curHeader = current.GetMessageHeader(curMsgClass);
result = $"{curHeader}{endValue} //{headerValue}";
}
else
{
result = $"-1{endValue} //Duplicate Matches {msgClass.Instance.QualifiedName.Name}[{headerValue}] | {hash}";
}
}
if (isDead)
{
result +=
" | Dead Message(0 References)";
}
return(result);
};
value = Regex.Replace(value,
"( |)//(.*?)\r\n", "\r\n", RegexOptions.Singleline).Trim();
if (value.Contains("-1"))
{
value = Regex.Replace(value,
@"-\b1\b", "0000", RegexOptions.Multiline);
}
value = Regex.Replace(value,
@"(\b(?<header>\d{1,4})\b)(?<end>[^\r|$]*)", replacer, RegexOptions.Multiline);
return(value);
}
