private static void WriteEnums(TextWriter w, ObjectData obj)
{
foreach (FieldData f in obj.Fields)
{
if (!f.IsEnum) continue;
WL(w, " public enum {0} {{ {1} }};", GetEnumName(obj, f, false), GetEnumItems(f));
WL(w);
}
}
// __ Code generators _____________________________________________
private static void WriteHeader(TextWriter w, ObjectData obj)
{
WL(w, "using System;");
WL(w, "using System.IO;");
WL(w, "using UavTalk;");
WL(w);
WL(w, "namespace {0}", Namespace);
WL(w, "{");
WL(w);
}
private static void WriteProperties(TextWriter w, ObjectData obj)
{
foreach (FieldData f in obj.Fields)
{
WL(w, " public {0}{1} {2} {{", GetCSharpType(obj, f), GetArrayModifier(f, false), f.Name);
WL(w, " get {{ return {0}; }}", GetPrivateFieldName(f));
WL(w, " set {{ {0} = value; NotifyUpdated(); }}", GetPrivateFieldName(f));
WL(w, " }");
WL(w);
}
}
public static void Write(TextWriter w, ObjectData obj)
{
WriteHeader(w, obj);
WriteEnums(w, obj);
WriteClassHeader(w, obj);
WriteProperties(w, obj);
WriteConstructor(w, obj);
WriteSerialize(w, obj);
WriteDeserialize(w, obj);
WriteToString(w, obj);
WritePrivateFields(w, obj);
WriteFooter(w, obj);
}
//
//void UAVObjectParser::calculateID(ObjectInfo* info)
//{
// // Hash object name
// quint32 hash = updateHash(info->name, 0);
// // Hash object attributes
// hash = updateHash(info->isSettings, hash);
// hash = updateHash(info->isSingleInst, hash);
// // Hash field information
// for (int n = 0; n < info->fields.length(); ++n) {
// hash = updateHash(info->fields[n]->name, hash);
// hash = updateHash(info->fields[n]->numElements, hash);
// hash = updateHash(info->fields[n]->type, hash);
// if(info->fields[n]->type == FIELDTYPE_ENUM) {
// QStringList options = info->fields[n]->options;
// for (int m = 0; m < options.length(); m++)
// hash = updateHash(options[m], hash);
// }
// }
// // Done
// info->id = hash & 0xFFFFFFFE;
//}
public static UInt32 CalculateId(ObjectData obj)
{
UInt32 hash = UpdateHash(obj.Name, 0);
hash = UpdateHash((UInt32)obj.IsSettingsInt, hash);
hash = UpdateHash((UInt32)obj.IsSingleInstInt, hash);
foreach (FieldData f in obj.Fields)
{
hash = UpdateHash(f.Name, hash);
hash = UpdateHash((UInt32)f.NumElements, hash);
hash = UpdateHash((UInt32)f.Type, hash);
if (f.IsEnum)
{
foreach (string op in f.Options)
{
hash = UpdateHash(op, hash);
}
}
}
return hash & 0xFFFFFFFE;
}
private static void WritePrivateFields(TextWriter w, ObjectData obj)
{
foreach (FieldData f in obj.Fields)
{
WL(w, " private {0}{1} {2}{3};",
GetCSharpType(obj, f), GetArrayModifier(f, false),
GetPrivateFieldName(f), GetDefaultValue(obj, f));
}
}
private static string GetEnumName(ObjectData obj, FieldData f, bool includeDot)
{
if (!f.IsEnum) return "";
return string.Format("{0}_{1}{2}", obj.Name, f.Name, (includeDot ? "." : "") );
}
private static string GetEnumTypeCast(ObjectData obj, FieldData f)
{
if (!f.IsEnum)
return "";
return String.Format("({0})", GetEnumName(obj, f, false));
}
private static string GetSerializeTypeCast(ObjectData obj, FieldData f)
{
if (!f.IsEnum)
return "";
return "(byte)";
}
private static string GetCSharpType(ObjectData obj, FieldData f)
{
switch (f.TypeString)
{
case "float": return "float";
case "int8": return "SByte";
case "uint8": return "byte";
case "int16": return "Int16";
case "uint16": return "UInt16";
case "enum": return GetEnumName(obj, f, false);
case "int32": return "Int32";
case "uint32": return "UInt32";
default:
Console.WriteLine("ERROR: Unknown uavType: " + f.TypeString);
return "!!!!";
}
}
private static string GetDefaultValuesList(ObjectData obj, FieldData f)
{
// Case 0: No default values: just return empty.
if (f.DefaultValues.Count == 0) return "";
// Case 1: there is a default value for every item
if (f.DefaultValues.Count == f.NumElements)
{
if (f.IsEnum)
return GetBracketedString(GetEnumCommaSeparatedValues(GetEnumName(obj, f, false), f.DefaultValues));
else
return GetBracketedString(GetCommaSeparatedValues(f.DefaultValues, GetFieldTypeSuffix(f)));
}
return "";
}
private static string GetFormattedDefaultValue(ObjectData obj, FieldData f, int index)
{
if (f.IsEnum)
{
return string.Format("{0}.{1}", GetEnumName(obj, f, false), FieldData.GetEscapedItemName(f.DefaultValues[index]));
}
else
{
return string.Format("{0}{1}", f.DefaultValues[index], GetFieldTypeSuffix(f));
}
}
private static void ExpandDefaultValues(ObjectData obj)
{
foreach (FieldData f in obj.Fields)
{
f.ExpandDefaultValue();
}
}
private static void SortFields(ObjectData obj)
{
// Sort by field size first, then by the order the fields already have.
/*
"int8" << "int16" << "int32" << "uint8" << "uint16" << "uint32" << "float" << "enum";
int(1) << int(2) << int(4) << int(1) << int(2) << int(4) << int(4) << int(1);
*/
var L4 = new List<FieldData>();
var L2 = new List<FieldData>();
var L1 = new List<FieldData>();
foreach (FieldData f in obj.Fields)
{
switch (f.Type)
{
case FieldDataType.ENUM:
case FieldDataType.INT8:
case FieldDataType.UINT8:
L1.Add(f);
break;
case FieldDataType.INT16:
case FieldDataType.UINT16:
L2.Add(f);
break;
default:
L4.Add(f);
break;
}
}
var result = new List<FieldData>();
result.AddRange(L4);
result.AddRange(L2);
result.AddRange(L1);
obj.Fields = result;
}
private static void WriteClassHeader(TextWriter w, ObjectData obj)
{
WL(w, " public class {0}: UavDataObject", obj.Name);
WL(w, " {");
}
private static void WriteToString(TextWriter w, ObjectData obj)
{
WL(w, " public override string ToString()");
WL(w, " {");
WL(w, " System.Text.StringBuilder sb = new System.Text.StringBuilder();");
WL(w);
WL(w, " sb.Append(\"{0} \\n\");", obj.Name);
foreach (FieldData f in obj.Fields)
{
if (f.NumElements == 1)
{
WL(w, " sb.AppendFormat(\" {0}: {{0}} {1}\\n\", {0});", f.Name, f.Units);
}
else
{
WL(w, " sb.Append(\" {0}\\n\");", f.Name);
for (int i = 0; i < f.NumElements; ++i)
{
string elemName = (f.ElementNames.Count == f.NumElements) ? f.ElementNames[i] : "";
WL(w, " sb.AppendFormat(\" {1}: {{0}} {3}\\n\", {0}[{2}]);", f.Name, elemName, i, f.Units);
}
}
}
WL(w);
WL(w, " return sb.ToString();");
WL(w, " }");
WL(w);
}
private static void WriteDeserialize(TextWriter w, ObjectData obj)
{
WL(w, " internal override void DeserializeBody(BinaryReader stream)", obj.Name);
WL(w, " {");
foreach (FieldData f in obj.Fields)
{
int numElements = f.NumElements;
if (numElements <= 1)
{
WL(w, " this.{0} = {1}stream.{2}();",
GetPrivateFieldName(f), GetEnumTypeCast(obj, f), GetReadOperation(f));
}
else
{
for (int i = 0; i < numElements; ++i)
{
WL(w, " this.{0}[{1}] = {2}stream.{3}(); // {4}",
GetPrivateFieldName(f), i, GetEnumTypeCast(obj, f), GetReadOperation(f), GetElementNameAt(f, i));
}
}
}
WL(w, " }\n");
WL(w);
}
private static void WriteSerialize(TextWriter w, ObjectData obj)
{
WL(w, " internal override void SerializeBody(BinaryWriter s)");
WL(w, " {");
foreach (FieldData f in obj.Fields)
{
int numElements = f.NumElements;
if (numElements <= 1)
{
WL(w, " s.Write({0}{1});", GetSerializeTypeCast(obj, f), GetPrivateFieldName(f));
}
else
{
for (int i = 0; i < numElements; ++i)
{
WL(w, " s.Write({0}{1}[{2}]); // {3}",
GetSerializeTypeCast(obj, f), GetPrivateFieldName(f), i, GetElementNameAt(f, i));
}
}
}
WL(w, " }\n");
WL(w);
}
// __ Impl _______________________________________________________
private static ObjectData GetObjectFromXml(XDocument xmlDocument)
{
ObjectData currentObject = null;
FieldData currentField = null;
if (xmlDocument.DescendantNodes().Any())
{
currentObject = new ObjectData();
IEnumerable<XNode> nodes = xmlDocument.DescendantNodes();
foreach (dynamic node in nodes)
{
if (node is XElement)
{
string name = node.Name.LocalName;
var xnode = node as XElement;
switch (name)
{
case "object":
var nameElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "name");
if (nameElement != null)
currentObject.Name = nameElement.Value;
var settigsElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "settings");
if (settigsElement != null)
currentObject.IsSettingsInt = GetIntFromBoolString(settigsElement.Value);
currentObject.IsSingleInstInt =
GetIntFromBoolString(
xnode.Attributes()
.FirstOrDefault(a => a.Name.LocalName == "singleinstance")
.Value);
break;
case "description":
currentObject.Description = node.Value;
break;
case "field":
currentField = new FieldData();
currentField.Name =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "name").Value;
currentObject.FieldsIndexedByName.Add(currentField.Name, currentField);
if (IsClone(node))
{
currentField.CloneFrom(
currentObject.FieldsIndexedByName[
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "cloneof").Value]);
}
else
{
XAttribute typeElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "type");
if (typeElement != null)
{
string typeString = typeElement.Value;
currentField.TypeString = typeString;
currentField.Type = GetFieldTypeFromString(currentField.TypeString);
XAttribute elementsAttribute =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "elements");
if (elementsAttribute !=
null)
currentField.Elements = elementsAttribute.Value;
XAttribute unitsElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "units");
if (unitsElement != null)
currentField.Units = unitsElement.Value;
XAttribute elementNamesElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "elementnames");
if (
elementNamesElement !=
null)
currentField.ParseElementNamesFromAttribute(elementNamesElement.Value);
XAttribute optionsElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "options");
if (optionsElement !=
null)
currentField.ParseOptionsFromAttribute(optionsElement.Value);
XAttribute defaultValueElement =
xnode.Attributes().FirstOrDefault(a => a.Name.LocalName == "defaultvalue");
if (
defaultValueElement !=
null)
currentField.ParseDefaultValuesFromAttribute(defaultValueElement.Value);
}
}
currentObject.Fields.Add(currentField);
break;
case "option":
currentField.Options.Add(node.Value);
break;
case "elementname":
currentField.ElementNames.Add(node.Value);
break;
}
}
}
ExpandDefaultValues(currentObject);
SortFields(currentObject);
SummaryGenerator.RegisterObjectId(
Hasher.CalculateId(currentObject),
string.Format("{0}.{1}", CSharpGenerator.Namespace, currentObject.Name));
}
return currentObject;
}
private static void WriteFooter(TextWriter w, ObjectData obj)
{
WL(w, " }");
WL(w, "}");
}
private static string GetDefaultValue(ObjectData obj, FieldData f)
{
// Cases:
// - Single value
// - float n = 0.0f
// - MyEnum n = MyEnum.Value
// - Array value
// - float[] n = new float[3]; // Roll, Pitch, Yaw
// - float[] n = new float[3] { 0.1f, 2f, 0.3f }; // Roll, Pitch, Yaw
// - MyEnum[] n = new MyEnum[3] { MyEnum.Value, MyEnum.Value }; // RollMode, PitchMode
if (f.NumElements <= 1)
{
// Single value
if (f.DefaultValues.Count == 1)
{
return " = " + GetFormattedDefaultValue(obj, f, 0);
}
}
else
{
// Array value
return string.Format(" = new {0}[{1}] {2}",
GetCSharpType(obj, f), f.NumElements, GetDefaultValuesList(obj, f));
}
return "";
}
private static void WriteConstructor(TextWriter w, ObjectData obj)
{
WL(w, " public {0}()", obj.Name);
WL(w, " {");
WL(w, " IsSingleInstance = {0};", (obj.IsSingleInstInt == 1) ? "true" : "false");
WL(w, " ObjectId = 0x{0:x8};", Hasher.CalculateId(obj));
WL(w, " }");
WL(w);
}
private static ObjectData GetObjectFromXml(XmlTextReader reader)
{
ObjectData currentObject = null;
FieldData currentField = null;
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "object":
currentObject = new ObjectData();
currentObject.Name = reader.GetAttribute("name");
currentObject.IsSettingsInt = GetIntFromBoolString(reader.GetAttribute("settings"));
currentObject.IsSingleInstInt = GetIntFromBoolString(reader.GetAttribute("singleinstance"));
break;
case "description":
currentObject.Description = reader.ReadString();
break;
case "field":
currentField = new FieldData();
currentField.Name = reader.GetAttribute("name");
currentObject.FieldsIndexedByName.Add(currentField.Name, currentField);
if (IsClone(reader))
{
currentField.CloneFrom(currentObject.FieldsIndexedByName[reader.GetAttribute("cloneof")]);
}
else
{
currentField.TypeString = reader.GetAttribute("type");
currentField.Type = GetFieldTypeFromString(currentField.TypeString);
currentField.Elements = reader.GetAttribute("elements");
currentField.Units = reader.GetAttribute("units");
currentField.ParseElementNamesFromAttribute(reader.GetAttribute("elementnames"));
currentField.ParseOptionsFromAttribute(reader.GetAttribute("options"));
currentField.ParseDefaultValuesFromAttribute(reader.GetAttribute("defaultvalue"));
}
currentObject.Fields.Add(currentField);
break;
case "option":
currentField.Options.Add(reader.ReadString());
break;
case "elementname":
currentField.ElementNames.Add(reader.ReadString());
break;
}
}
}
ExpandDefaultValues(currentObject);
SortFields(currentObject);
SummaryGenerator.RegisterObjectId(
Hasher.CalculateId(currentObject),
string.Format("{0}.{1}", CSharpGenerator.Namespace, currentObject.Name));
return currentObject;
}
