private static void ParseRdm(ProtocolClass classParsed, StringBuilder writer)
{
var id = TypeMessageIdsParser.MessageIdsIndex.ContainsKey(classParsed.Name)
? TypeMessageIdsParser.MessageIdsIndex[classParsed.Name]
: classParsed.MessageId;
writer.AppendLine($"\t\tpublic const uint Id = {id};");
writer.AppendLine("\t\tpublic override uint MessageId => Id;");
writer.AppendLine("\t\tpublic byte[] Content { get; set; }");
writer.AppendLine();
writer.AppendLine($"\t\tpublic {classParsed.Name}() {{ }}");
writer.AppendLine();
writer.AppendLine($"\t\tpublic {classParsed.Name}(byte[] content)");
writer.AppendLine("\t\t{");
writer.AppendLine("\t\t\tContent = content;");
writer.AppendLine("\t\t}");
writer.AppendLine();
writer.AppendLine("\t\tpublic override void Serialize(IDataWriter writer)");
writer.AppendLine("\t\t{");
writer.AppendLine("\t\t\tvar contentLength = Content.Length;");
writer.AppendLine("\t\t\twriter.WriteVarInt(contentLength);");
writer.AppendLine("\t\t\tfor (var i = 0; i < contentLength; i++)");
writer.AppendLine("\t\t\twriter.WriteByte(Content[i]);");
writer.AppendLine("\t\t}");
writer.AppendLine("\t\tpublic override void Deserialize(IDataReader reader)");
writer.AppendLine("\t\t{");
writer.AppendLine("\t\t\tvar contentLength = reader.ReadVarInt();");
writer.AppendLine("\t\t\treader.ReadBytes(contentLength);");
writer.AppendLine("\t\t}");
}
private static void GenerateClass(StringBuilder writer, ProtocolClass classParsed, bool isType, string path)
{
WriteNamespace(isType, writer);
WriteUsingDirectives(classParsed, writer);
WriteClass(classParsed, writer);
if (classParsed.Name == "RawDataMessage")
{
ParseRdm(classParsed, writer);
}
else
{
WriteProperties(classParsed, writer, isType);
var hasParent = (classParsed.Parent != "NetworkType" && classParsed.Parent != "NetworkMessage" && string.IsNullOrEmpty(classParsed.Parent) == false);
if (classParsed.Variables.Length >= 1 || hasParent == true)
{
WriteConstructor(classParsed, writer);
}
writer.AppendLine();
writer.AppendLine($"\t\tpublic {classParsed.Name}() {{ }}");
WriteSerializeMethod(classParsed, writer);
WriteDeserializeMethod(classParsed, writer);
}
WriteEndClass(writer);
if (writer.Length == 0 || !File.Exists(path))
{
return;
}
File.WriteAllText(path, writer.ToString(), Encoding.UTF8);
}
public TypeClassWriter(ProtocolClass pClass, D2JsonProvider provider)
{
Class = pClass;
Provider = provider;
_writer = new StringBuilder();
}
public FileVersion(ProtocolClass protocolClass, int mjVer, int mnVer, int secMjVer, int secMnVer)
{
m_protocolClass = protocolClass;
majorVersion = mjVer;
minorVersion = mnVer;
secMajorVersion = secMjVer;
secMinorVersion = secMnVer;
}
private static void WriteProperties(ProtocolClass classParsed, StringBuilder writer, bool isType)
{
if (isType)
{
var id = TypeMessageIdsParser.TypeIdsIndex.ContainsKey(classParsed.Name)
? TypeMessageIdsParser.TypeIdsIndex[classParsed.Name]
: classParsed.MessageId;
if (classParsed.Parent == "NetworkType")
{
writer.AppendLine($"\t\tpublic const short Id = {id};");
writer.AppendLine("\t\tpublic virtual short TypeId => Id;");
}
else
{
writer.AppendLine($"\t\tpublic new const short Id = {id};");
writer.AppendLine("\t\tpublic override short TypeId => Id;");
}
}
else
{
var id = TypeMessageIdsParser.MessageIdsIndex.ContainsKey(classParsed.Name)
? TypeMessageIdsParser.MessageIdsIndex[classParsed.Name]
: classParsed.MessageId;
if (classParsed.Parent == "NetworkMessage")
{
writer.AppendLine($"\t\tpublic const uint Id = {id};");
writer.AppendLine("\t\tpublic override uint MessageId => Id;");
}
else
{
writer.AppendLine($"\t\tpublic new const uint Id = {id};");
writer.AppendLine("\t\tpublic override uint MessageId => Id;");
}
}
foreach (var field in classParsed.Variables)
{
switch (field.TypeOfVar)
{
case VarType.Primitive:
writer.AppendLine(
$"\t\tpublic {field.ObjectType} {field.Name}" + " { get; set; }");
break;
case VarType.Object:
writer.AppendLine(
$"\t\tpublic {field.ObjectType} {field.Name}" + " { get; set; }");
break;
case VarType.Vector:
writer.AppendLine(
$"\t\tpublic IEnumerable<{field.ObjectType}> {field.Name}" + " { get; set; }");
break;
}
}
}
public static void CreateRepositories(ProtocolClass classParsed)
{
var path = $"Output/{classParsed.Namespace.NamespaceToPath()}";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
}
public bool Predicat(ProtocolClass pr)
{
if (pr.Fields == null || !pr.Fields.Any())
{
return(false);
}
return(pr.Fields.Any(p => p.UseTypeManager));
}
// RL - Short Description for Sample Volume Dialog - 03/29/06
public SeparationProtocol(int id, ProtocolClass protocolClass,
string label, string description, int numQuadrants, double minVol, double maxVol, DateTime lastUsed)
: base(id, protocolClass, label, description, numQuadrants)
{
myId = id;
myLabel = label;
myQuadrantCount = numQuadrants;
myMinimumVolume = minVol;
myMaximumVolume = maxVol;
myLastUsedTime = lastUsed;
}
private string myStringClassification; /*CR*/
protected Protocol(int id, ProtocolClass classification,
string label, string description, int numQuadrants)
{
myId = id;
myClassification = classification;
myLabel = label;
myDescription = description;
myQuadrantCount = numQuadrants;
myInitialQuadrant = QuadrantId.NoQuadrant;
switch (myClassification) /*CR*/
{
case ProtocolClass.HumanNegative:
myStringClassification = "Human \nNegative";
break;
case ProtocolClass.HumanPositive:
myStringClassification = "Human \nPositive";
break;
case ProtocolClass.MousePositive:
myStringClassification = "Mouse \nPositive";
break;
case ProtocolClass.MouseNegative:
myStringClassification = "Mouse \nNegative";
break;
case ProtocolClass.Positive:
myStringClassification = "Positive";
break;
case ProtocolClass.Negative:
myStringClassification = "Negative";
break;
case ProtocolClass.WholeBloodPositive:
myStringClassification = "Whole Blood \nPositive";
break;
case ProtocolClass.WholeBloodNegative:
myStringClassification = "Whole Blood \nNegative";
break;
case ProtocolClass.Maintenance:
myStringClassification = "Maintenance";
break;
case ProtocolClass.Shutdown:
myStringClassification = "Shutdown";
break;
}
}
public void WriteFile(ProtocolClass protocolClass, bool isType = false)
{
ClassParsed = protocolClass;
Writer = new StringBuilder();
IsType = isType;
ClassPath =
$@"{Directory.GetCurrentDirectory()}\Output\{
ClassParsed.Namespace.NamespaceToPath()
}\{ClassParsed.Name}.cs";
CreateRepositories();
CreateFile();
GenerateClass();
}
public static string getLysisStringFromProtocolClass(ProtocolClass pc)
{
if (pc == ProtocolClass.WholeBloodPositive)
{
return(SeparatorResourceManager.GetSeparatorString(StringId.LysisBufferTube));
}
else if (pc == ProtocolClass.WholeBloodNegative)
{
return(SeparatorResourceManager.GetSeparatorString(StringId.LysisBufferNegativeFractionTube));
}
else
{
return(SeparatorResourceManager.GetSeparatorString(StringId.NegativeFractionTube));
}
}
private static void WriteClass(ProtocolClass classParsed, StringBuilder writer)
{
var parent = classParsed.Parent;
if (parent.Equals("NetworkMessage"))
{
parent = "Message";
}
if (parent.Equals("NetworkType"))
{
parent = "";
}
writer.AppendLine("\t[Serializable]");
writer.AppendLine(string.IsNullOrEmpty(parent)
? $"\tpublic class {classParsed.Name}"
: $"\tpublic class {classParsed.Name} : {parent}");
writer.AppendLine("\t{");
}
public static string getVialBStringFromProtocolClass(ProtocolClass pc)
{
// for positive protocols use positive vial name
if ((pc == ProtocolClass.Positive) || (pc == ProtocolClass.HumanPositive) ||
(pc == ProtocolClass.MousePositive) || (pc == ProtocolClass.WholeBloodPositive))
{
return(SeparatorResourceManager.GetSeparatorString(StringId.VialBpos));
}
// for negative protocols use negative vial name
else if ((pc == ProtocolClass.Negative) || (pc == ProtocolClass.HumanNegative) ||
(pc == ProtocolClass.MouseNegative) || (pc == ProtocolClass.WholeBloodNegative))
{
return(SeparatorResourceManager.GetSeparatorString(StringId.VialBneg));
}
// else use normal bead vial name
else
{
return(SeparatorResourceManager.GetSeparatorString(StringId.VialB));
}
}
public void RoundtripTest()
{
var expected = new ProtocolClass
{
Header = new HeaderClass
{
ITEM1 = 1, // 0b1
ITEM2 = 0x7f, // 0b1111111
ITEM3 = 1, // 0b1
ITEM4 = 0x7 // 0b111
}
};
var actual = Roundtrip(expected, new byte[] { 0xff, 0x0f });
Assert.AreEqual(expected.Header.ITEM1, actual.Header.ITEM1);
Assert.AreEqual(expected.Header.ITEM2, actual.Header.ITEM2);
Assert.AreEqual(expected.Header.ITEM3, actual.Header.ITEM3);
Assert.AreEqual(expected.Header.ITEM4, actual.Header.ITEM4);
Assert.AreEqual(expected.Body, actual.Body);
}
private static void WriteUsingDirectives(ProtocolClass classParsed, StringBuilder writer)
{
foreach (var import in classParsed.Imports.Where(imp => imp != ""))
{
if (import.StartsWith("Types."))
{
continue;
}
if (!import.StartsWith("Messages."))
{
writer.AppendLine($"\tusing {import};");
}
}
if (classParsed.Variables.Any(x => x.ObjectType == "Version"))
{
writer.AppendLine($"\tusing Version = {Program.TypesNamespace}.Version;");
}
writer.AppendLine("");
}
public static void GenerateFile(ProtocolClass protocolClass, bool isType = false)
{
foreach (var vars in protocolClass.Variables)
{
if (vars.ReadMethod != null && vars.ReadMethod.Contains("Uh"))
{
vars.ReadMethod = vars.ReadMethod.Replace("Uh", "U");
}
if (vars.WriteMethod != null && vars.WriteMethod.Contains("Uh"))
{
vars.WriteMethod = vars.WriteMethod.Replace("Uh", "U");
}
}
var writer = new StringBuilder();
var classPath =
$@"{Directory.GetCurrentDirectory()}/Output/{
protocolClass.Namespace.NamespaceToPath()
}/{protocolClass.Name}.cs";
CreateRepositories(protocolClass);
CreateFile(classPath);
GenerateClass(writer, protocolClass, isType, classPath);
}
public TypeMessageParser(string[] fileStr)
{
Class = new ProtocolClass();
CleanSource(fileStr);
Brackets = FindBracketsIndexesByLines(fileStr, '{', '}');
}
private static void WriteConstructor(ProtocolClass classParsed, StringBuilder writer)
{
writer.AppendLine();
var variables = classParsed.Variables;
var parentVariables = new List <ProtocolClassVariable>();
var fieldsToInit = new StringBuilder(); // fields in the void
var initFields = new StringBuilder(); // set fields
if (classParsed.Parent != "NetworkType" && classParsed.Parent != "NetworkMessage" && string.IsNullOrEmpty(classParsed.Parent) == false)
{
var parent = classParsed.Parent;
var parents = new List <string>();
while (true)
{
var tmp = Builders.ProtocolTypeMessageBuilder.ClassWriters.FirstOrDefault(x => x.Class.Name.Equals(parent));
if (tmp != null)
{
parents.Add(tmp.Class.Name);
parent = tmp.Class.Parent;
}
else
{
break;
}
}
for (var index = (parents.Count - 1); index != -1; index--)
{
var tmp2 = Builders.ProtocolTypeMessageBuilder.ClassWriters.FirstOrDefault(x => x.Class.Name.Equals(parents[index]));
if (tmp2 != null)
{
parentVariables.AddRange(tmp2.Class.Variables);
}
}
variables = parentVariables.Concat(classParsed.Variables).ToArray();
}
if (!variables.Any())
{
return;
}
foreach (var field in variables)
{
switch (field.TypeOfVar)
{
case VarType.Primitive:
fieldsToInit.Append($"{field.ObjectType} {field.Name.ToValidName()}, ");
initFields.AppendLine(
$"\t\t\tthis.{field.Name} = {field.Name.ToValidName()};");
break;
case VarType.Object:
fieldsToInit.Append($"{field.ObjectType} {field.Name.ToValidName()}, ");
initFields.AppendLine(
$"\t\t\tthis.{field.Name} = {field.Name.ToValidName()};");
break;
case VarType.Vector:
fieldsToInit.Append($"IEnumerable<{field.ObjectType}> {field.Name.ToValidName()}, ");
initFields.AppendLine(
$"\t\t\tthis.{field.Name} = {field.Name.ToValidName()};");
break;
}
}
if (fieldsToInit.Length > 0)
{
fieldsToInit.Length -= 2;
}
writer.AppendLine($"\t\tpublic {classParsed.Name}({fieldsToInit})");
writer.AppendLine("\t\t{");
writer.Append(initFields);
writer.AppendLine("\t\t}");
}
private static void WriteDeserializeMethod(ProtocolClass classParsed, StringBuilder writer)
{
var initFields = new StringBuilder();
if (classParsed.Parent != "NetworkType")
{
writer.AppendLine("\t\tpublic override void Deserialize(IDataReader reader)");
}
else
{
writer.AppendLine("\t\tpublic virtual void Deserialize(IDataReader reader)");
}
writer.AppendLine("\t\t{");
if (classParsed.Parent != "NetworkMessage" && classParsed.Parent != "NetworkType")
{
initFields.AppendLine("\t\t\tbase.Deserialize(reader);");
}
var flag = false;
foreach (var field in classParsed.Variables)
{
if (field.MethodType == ReadMethodType.BooleanByteWraper && !flag)
{
flag = true;
initFields.AppendLine("\t\t\tvar flag = reader.ReadByte();");
}
}
var flagCount = classParsed.Variables.Count(var => var.MethodType == ReadMethodType.BooleanByteWraper);
var newflagCount = flagCount;
foreach (var field in classParsed.Variables)
{
switch (field.TypeOfVar)
{
case VarType.Primitive:
switch (field.MethodType)
{
case ReadMethodType.Primitive:
initFields.AppendLine(
$"\t\t\t{field.Name} = reader.{field.ReadMethod}();");
break;
case ReadMethodType.BooleanByteWraper:
initFields.AppendLine(
$"\t\t\t{field.Name} = BooleanByteWrapper.GetFlag(flag, {Convert.ToInt32(field.ReadMethod)});");
break;
}
if (field.MethodType == ReadMethodType.BooleanByteWraper)
{
newflagCount -= 1;
if (flagCount == newflagCount + 8)
{
flagCount -= 8;
initFields.AppendLine("\t\t\tflag = reader.ReadByte();");
}
}
continue;
case VarType.Object:
switch (field.MethodType)
{
case ReadMethodType.ProtocolTypeManager:
initFields.AppendLine(
$"\t\t\t{field.Name} = ProtocolTypeManager.GetInstance<{field.ObjectType}>(reader.ReadShort());");
break;
case ReadMethodType.SerializeOrDeserialize:
initFields.AppendLine(
$"\t\t\t{field.Name} = new {field.ObjectType}();");
break;
}
initFields.AppendLine($"\t\t\t{field.Name}.Deserialize(reader);");
continue;
case VarType.Vector:
WriteDeserializeVector(field, initFields);
continue;
}
}
writer.Append(initFields);
writer.AppendLine("\t\t}");
writer.AppendLine();
}
public override void UpdateComboBoxes(ProtocolClass pc)
{
ComboBox[] boxes = { cmbSourceVial, cmbDestinationVial, cmbSourceVial2, cmbDestinationVial2 };
UpdateComboBoxes(boxes, pc);
}
