public void AddPaths()
{
SINT mtype = SINT.Type;
PresetDB db = new PresetDB("Preset", new IntegerLiteral(7));
STRUCT type = new STRUCT();
ARRAY subtype = new ARRAY()
{
MemberType = new STRING()
{
Capacity = new IntegerLiteral(6)
}
};
subtype.Limits.Add(new ArrayLimits(new IntegerLiteral(-4), new IntegerLiteral(7)));
type.Members.Add(new StructMember()
{
Name = "Int", MemberType = UINT.Type
});
type.Members.Add(new StructMember()
{
Name = "Array", MemberType = subtype
});
PathComponent path = new MemberComponent("Foo", type);
db.AddPath(path, new MultilingualText("en-US", "Comment"), "89");
}
public GFF(Stream s)
{
using (BinaryReader br = new BinaryReader(s))
{
FileType = new string(br.ReadChars(4));
Version = new string(br.ReadChars(4));
Top_Level = new STRUCT(br, 0);
}
}
private void RegisterDataStruct(Type type, STRUCT id)
{
foreach (FieldInfo field in type.GetFields())
{
var dataField = field.GetCustomAttribute <SimVarAttribute>();
if (dataField == null)
{
throw new NullReferenceException($"No SimVarAttribute for {type}.{field.Name}");
}
AddToDataDefinition(id, dataField.Variable, dataField.Units,
dataField.Type, dataField.Epsilon, SIMCONNECT_UNUSED);
System.Console.Error.WriteLine($"Registered field {type}.{field.Name} {GetLastSentPacketID()}");
}
GetType().GetMethod("RegisterDataDefineStruct") !.MakeGenericMethod(type)
.Invoke(this, new object[] { id });
System.Console.Error.WriteLine($"Registered struct {type} {GetLastSentPacketID()}");
}
private void RegisterDataStructs()
{
foreach (var type2Struct in typeToStruct !)
{
Type type = type2Struct.Key;
STRUCT id = type2Struct.Value;
string?clientDataName = null;
if (typeToClientDataName?.TryGetValue(type, out clientDataName) == true)
{
RegisterClientDataStruct(clientDataName !, type, id);
}
else
{
RegisterDataStruct(type, id);
}
}
}
private static FIELD CreateNewField(BinaryReader br, int index, int fieldOffset, int dataOrDataOffset, GffFieldType fieldType)
{
FIELD data;
switch (fieldType)
{
case GffFieldType.BYTE:
data = new BYTE(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CHAR:
data = new CHAR(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.WORD:
data = new WORD(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.SHORT:
data = new SHORT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DWORD:
data = new DWORD(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.INT:
data = new INT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DWORD64:
data = new DWORD64(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.INT64:
data = new INT64(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.FLOAT:
data = new FLOAT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DOUBLE:
data = new DOUBLE(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CExoString:
data = new CExoString(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.ResRef:
data = new ResRef(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CExoLocString:
data = new CExoLocString(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.VOID:
data = new VOID(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Struct:
int lbl_index = br.ReadInt32();
data = new STRUCT(br, br.ReadInt32(), lbl_index);
break;
case GffFieldType.List:
data = new LIST(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Orientation:
data = new Orientation(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Vector:
data = new Vector(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.StrRef:
data = new StrRef(br, fieldOffset + dataOrDataOffset * 12);
break;
default:
throw new Exception(string.Format("UNEXPECTED FIELD TYPE \"{0}\", IN STRUCT INDEX \"{1}\"", fieldType, index));
}
return(data);
}
public void SendDataOnSimObject <StructType>(StructType data)
where StructType : struct
{
STRUCT id = typeToStruct ![typeof(StructType)];
//Write Methods
internal override void Write(Stream s)
{
//List out all the fields in the file, followed by their DataOrDataOffset, and then their HasCode.
List <Tuple <FIELD, int, int> > Field_Array = new List <Tuple <FIELD, int, int> >();
//Contains all teh unique labels used by the file
List <string> Label_Array = new List <string>();
//Raw Arrays that will store the bytes to be written to the File
List <byte> Raw_Struct_Array = new List <byte>();
List <byte> Raw_Field_Array = new List <byte>();
List <byte> Raw_Label_Array = new List <byte>();
List <byte> Raw_Field_Data_Block = new List <byte>();
List <byte> Raw_Field_Indices_Array = new List <byte>();
List <byte> Raw_List_Indices_Array = new List <byte>();
//Indexers/Counters
int Struct_Indexer = 0;
int List_Indices_Counter = 0;
//Recursive field collection call
Top_Level.collect_fields(ref Field_Array, ref Raw_Field_Data_Block, ref Label_Array, ref Struct_Indexer, ref List_Indices_Counter);
//Preparing raw struct data
for (int i = 0; i < Struct_Indexer; i++)
{
STRUCT S = Field_Array.Where(x => x.Item1.Type == GffFieldType.Struct && x.Item2 == i).Select(x => x.Item1 as STRUCT).FirstOrDefault();
Raw_Struct_Array.AddRange(BitConverter.GetBytes(S.Struct_Type));
int f_count = S.Fields.Count;
if (f_count == 1)
{
int f_hash = S.Fields[0].GetHashCode();
int f_index = Field_Array.FindIndex(x => x.Item3 == f_hash);
Raw_Struct_Array.AddRange(BitConverter.GetBytes(f_index));
}
else if (f_count > 1)
{
Raw_Struct_Array.AddRange(BitConverter.GetBytes(Raw_Field_Indices_Array.Count));
foreach (FIELD F in S.Fields)
{
int f_hash = F.GetHashCode();
int f_index = Field_Array.FindIndex(x => x.Item3 == f_hash);
if (f_index == -1)
{
throw new Exception("Bad field index, was their a hashing issue?");
}
Raw_Field_Indices_Array.AddRange(BitConverter.GetBytes(f_index));
}
//Depricated code for when I was using a counter and handling Field Indices separately
//Raw_Struct_Array.AddRange(BitConverter.GetBytes(Field_Indices_Counter));
//Field_Indices_Counter += 4 * S.Fields.Count;
}
else
{
//Empty Struct case (this is rare)
Raw_Struct_Array.AddRange(BitConverter.GetBytes(-1));
}
Raw_Struct_Array.AddRange(BitConverter.GetBytes(f_count));
}
//Preparing raw Field data
foreach (Tuple <FIELD, int, int> T in Field_Array)
{
Raw_Field_Array.AddRange(BitConverter.GetBytes((int)T.Item1.Type)); //Field Type
int lbl_index = Label_Array.IndexOf(T.Item1.Label); //Find Label index
Raw_Field_Array.AddRange(BitConverter.GetBytes(lbl_index)); //Label index
Raw_Field_Array.AddRange(BitConverter.GetBytes(T.Item2)); //DataOrDataOffset
}
//Preparing raw Label data
foreach (string l in Label_Array)
{
Raw_Label_Array.AddRange(l.PadRight(16, '\0').ToCharArray().Select(x => (byte)x));
}
//Field Data block should've been prapared during collect_fields call
//Field Indice block should've been prapared while generating struct data
//Preparing raw List indices data
for (int i = 0; i < List_Indices_Counter;)
{
LIST L = Field_Array.Where(x => x.Item1.Type == GffFieldType.List && x.Item2 == Raw_List_Indices_Array.Count).Select(x => x.Item1 as LIST).FirstOrDefault();
Raw_List_Indices_Array.AddRange(BitConverter.GetBytes(L.Structs.Count));
foreach (STRUCT S in L.Structs)
{
int s_hash = S.GetHashCode();
int s_index = Field_Array.Where(x => x.Item3 == s_hash).FirstOrDefault().Item2;
Raw_List_Indices_Array.AddRange(BitConverter.GetBytes(s_index));
}
i = Raw_List_Indices_Array.Count;
}
//Header Calculations
int StructOffset = 56;
int StructCount = Raw_Struct_Array.Count / 12;
int FieldOffset = StructOffset + StructCount * 12;
int FieldCount = Field_Array.Count;
int LabelOffset = FieldOffset + FieldCount * 12;
int LabelCount = Label_Array.Count;
int FieldDataOffset = LabelOffset + LabelCount * 16;
int FieldDataCount = Raw_Field_Data_Block.Count;
int FieldIndicesOffset = FieldDataOffset + FieldDataCount;
int FieldIndicesCount = Raw_Field_Indices_Array.Count;
int ListIndicesOffset = FieldIndicesOffset + FieldIndicesCount;
int ListIndicesCount = Raw_List_Indices_Array.Count;
//Writing
using (BinaryWriter bw = new BinaryWriter(s))
{
//header
bw.Write(FileType.ToCharArray());
bw.Write(Version.ToCharArray());
bw.Write(StructOffset);
bw.Write(StructCount);
bw.Write(FieldOffset);
bw.Write(FieldCount);
bw.Write(LabelOffset);
bw.Write(LabelCount);
bw.Write(FieldDataOffset);
bw.Write(FieldDataCount);
bw.Write(FieldIndicesOffset);
bw.Write(FieldIndicesCount);
bw.Write(ListIndicesOffset);
bw.Write(ListIndicesCount);
//structs
bw.Write(Raw_Struct_Array.ToArray());
//fields
bw.Write(Raw_Field_Array.ToArray());
//labels
bw.Write(Raw_Label_Array.ToArray());
//field data
bw.Write(Raw_Field_Data_Block.ToArray());
//fields indices
bw.Write(Raw_Field_Indices_Array.ToArray());
//list indices
bw.Write(Raw_List_Indices_Array.ToArray());
}
}
public GFF(string FileType, string Version, STRUCT Top_Level)
{
this.FileType = FileType;
this.Version = Version;
this.Top_Level = Top_Level;
}
//Construction
public GFF()
{
Top_Level = new STRUCT();
}
protected MemberComponent readMember(XmlElement member_elem, PathComponent parent)
{
string name = member_elem.GetAttribute("Name");
string type_str = member_elem.GetAttribute("Datatype");
string left;
DataType type = DataTypeParser.Parse(type_str, out left);
MemberComponent member = new MemberComponent(name, type, parent);
PathComponent child_path = member;
if (type is ARRAY)
{
ARRAY array = (ARRAY)type;
child_path = new IndexComponent(new int[array.Limits.Count], array.MemberType, member);
if ((options & Options.NoSubelement) != 0)
{
if (member != child_path)
{
handle_tag(new HandleTagEventArgs()
{
Path = SubstituteIndicesLow(child_path),
Comment = null
});
}
}
}
XmlElement comment_elem = member_elem.SelectSingleNode("if:Comment", XMLUtil.nameSpaces) as XmlElement;
MultilingualText comment = null;
if (comment_elem != null)
{
comment = readComment(comment_elem);
}
if (((options & Options.AllowNoComment) != 0) || comment != null)
{
handle_tag(new HandleTagEventArgs()
{
Path = SubstituteIndicesLow(member),
Comment = comment
});
}
XmlNodeList member_elems = member_elem.SelectNodes("if:Member", XMLUtil.nameSpaces);
foreach (XmlNode m in member_elems)
{
MemberComponent submember = readMember((XmlElement)m, child_path);
if (child_path.Type is STRUCT)
{
STRUCT struct_type = (STRUCT)child_path.Type;
struct_type.Members.Add(new StructMember()
{
Name = submember.Name, MemberType = submember.Type
});
}
}
if ((options & Options.NoSubelement) == 0)
{
XmlNodeList sub_elems = member_elem.SelectNodes("if:Subelement", XMLUtil.nameSpaces);
foreach (XmlNode s in sub_elems)
{
readSubelement(s as XmlElement, child_path);
}
}
return(member);
}