private void tree_FormatRow(object sender, BrightIdeasSoftware.FormatRowEventArgs e)
{
if (e.Model is SbeField)
{
SbeField field = (SbeField)e.Model;
if (field.Presence.ToLower().Equals("constant"))
{
e.Item.BackColor = Color.LightGray;
}
}
}
private void CreateHeader()
{
SbeMessage mh = new SbeMessage();
mh.Name = "Message Header";
SbeField f = new SbeField();
f.Name = "blockLength";
f.Length = 2;
f.Type = "uint16";
f.PrimitiveType = "uint16";
f.Offset = 0;
f.Presence = "";
mh.Fields.Insert(0, f);
SbeField f2 = new SbeField();
f2.Name = "TemplateId";
f2.Length = 2;
f2.Type = "uint16";
f2.PrimitiveType = "uint16";
f2.Offset = 2;
f2.Presence = "";
f2.Value = _Message[0].Id;
mh.Fields.Insert(1, f2);
SbeField f3 = new SbeField();
f3.Name = "SchemaId";
f3.Length = 2;
f3.Type = "uint16";
f3.PrimitiveType = "uint16";
f3.Offset = 4;
f3.Presence = "";
mh.Fields.Insert(2, f3);
SbeField f4 = new SbeField();
f4.Name = "Version";
f4.Length = 2;
f4.Type = "uint16";
f4.PrimitiveType = "uint16";
f4.Offset = 6;
f4.Presence = "";
mh.Fields.Insert(3, f4);
_Message.Insert(0, mh);
}
public static void SetEnumerationField(Assembly assembly, SbeField field, object MessageBody, string MessageName)
{
if (field.Presence.Contains("constant") || String.IsNullOrEmpty(field.Value))
{
return;
}
Type _enumType = ReflectionHelper.GetType(assembly, field.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == field.Type);
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Value == field.Value);
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
pi.SetValue(MessageBody, Enum.Parse(_enumType, valid.Name));
}
}
public static void GetEnumerationField(Assembly assembly, SbeField field, object MessageBody, string MessageName)
{
if (field.Presence.Contains("constant"))
{
return;
}
Type _enumType = ReflectionHelper.GetType(assembly, field.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == field.Type);
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
field.ValueRef = Convert.ChangeType(pi.GetValue(MessageBody), pi.PropertyType).ToString();
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Name == field.ValueRef);
if (valid != null)
{
field.Value = valid.Value;
}
}
}
public static SbeField GetField(Assembly assembly, SbeField field, String MessageName, object MessageBody)
{
if (SbeLoader._Enums.Find(x => x.Name == field.Type) != null)
{
#region Enumeration
GetEnumerationField(assembly, field, MessageBody, MessageName);
#endregion
}
else if (SbeLoader._SimpleTypes.Find(x => x.Name == field.Type) != null)
{
#region Simple Type
if (field.Presence.Contains("constant"))
{
return(field);
}
//SimpleType
SbeType simple = SbeLoader._SimpleTypes.Find(x => x.Name == field.Type);
if (simple.PrimitiveType.ToLower().Equals("char"))
{
FieldInfo l = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "Length");
int length = (int)l.GetValue(MessageBody);
var fieldByte = new byte[length];
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Get" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0 }).ToString();
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
string enc = fi.GetValue(MessageBody).ToString();
field.Value = Encoding.GetEncoding(enc).GetString(fieldByte, 0, length);
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
field.Value = Convert.ChangeType(pi.GetValue(MessageBody), pi.PropertyType).ToString();
}
#endregion
}
else if (SbeLoader._CompositeTypes.Find(x => x.Name == field.Type) != null)
{
#region Composite
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
#region groupsizeencoding
//var fuelFiguresGroup = car.FuelFigures;
//while (fuelFiguresGroup.HasNext)
//{
//var fuelFigures = fuelFiguresGroup.Next();
//sb.Append("\ncar.fuelFigures.speed=").Append(fuelFigures.Speed);
//sb.Append("\ncar.fuelFigures.mpg=").Append(fuelFigures.Mpg);
//}
PropertyInfo no = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
var repeat = no.GetValue(MessageBody);
PropertyInfo hasNext = ReflectionHelper.GetPropertyByName(assembly, field.Name, "HasNext");
bool nextValue = (bool)hasNext.GetValue(repeat);
SbeMessage _Original = SbeLoader.LoadMessageByName(MessageName);
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
field.Fields.Clear();
MethodInfo next = ReflectionHelper.GetNestedMethodByName(assembly, MessageName, field.Name + "Group", "next");
int size = 0;
while (nextValue)
{
size++;
next.Invoke(repeat, null);
foreach (SbeField child in _OriginalField.Fields)
{
if (!child.Presence.Contains("constant"))
{
if (SbeLoader._Enums.Find(x => x.Name == child.Type) != null)
{
Type _enumType = ReflectionHelper.GetType(assembly, child.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == child.Type);
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, field.Name + "Group", child.Name);
child.ValueRef = Convert.ChangeType(pi.GetValue(repeat), pi.PropertyType).ToString();
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Name == child.ValueRef);
if (valid != null)
{
child.Value = valid.Value;
}
}
}
else
{
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
child.Value = pi.GetValue(repeat).ToString();
}
}
field.Fields.Add(child.Clone());
}
nextValue = (bool)hasNext.GetValue(repeat);
}
field.Value = size.ToString();
#endregion
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Type);
if (pi != null)
{
object parent = pi.GetValue(MessageBody);
foreach (SbeField child in field.Fields)
{
if (child.Presence.Contains("constant"))
{
continue;
}
PropertyInfo pi2 = ReflectionHelper.GetPropertyByName(assembly, field.Type, child.Name);
child.Value = pi2.GetValue(parent).ToString();
}
}
else
{
// length = car.GetManufacturer(buffer, 0, buffer.Length);
//sb.Append("\ncar.manufacturer=").Append(Encoding.GetEncoding(Car.ManufacturerCharacterEncoding).GetString(buffer, 0, length));
// length = car.GetModel(buffer, 0, buffer.Length);
//sb.Append("\ncar.model=").Append(Encoding.GetEncoding(Car.ModelCharacterEncoding).GetString(buffer, 0, length));
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
var buffer = new byte[128];
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Get" + field.Name, "byte[]");
int len = (int)(mi.Invoke(MessageBody, new object[] { buffer, 0, buffer.Length }));
field.Value = Encoding.GetEncoding(fi.GetValue(MessageBody).ToString()).GetString(buffer, 0, len);
}
}
#endregion
}
return(field);
}
public static void SetField(Assembly assembly, SbeField field, String MessageName, object MessageBody)
{
if (SbeLoader._Enums.Find(x => x.Name == field.Type) != null)
{
#region Enumeration
SetEnumerationField(assembly, field, MessageBody, MessageName);
#endregion
}
else if (SbeLoader._SimpleTypes.Find(x => x.Name == field.Type) != null)
{
#region Simple Type
if (field.Presence.Contains("constant") || String.IsNullOrEmpty(field.Value))
{
return;
}
//SimpleType
SbeType simple = SbeLoader._SimpleTypes.Find(x => x.Name == field.Type);
if (simple.PrimitiveType.ToLower().Equals("char"))
{
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
byte[] fieldByte = System.Text.Encoding.GetEncoding(fi.GetValue(MessageBody).ToString()).GetBytes(field.Value);
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Set" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0 });
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Name);
pi.SetValue(MessageBody, Convert.ChangeType(field.Value, pi.PropertyType));
}
#endregion
}
else if (SbeLoader._CompositeTypes.Find(x => x.Name == field.Type) != null)
{
#region Composite
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
#region groupsizeencoding
//var sides = cross.NoSidesCount(2);
//sides.Next();
//sides.Side = Side.BUY;
//sides.Account = 111;
//sides.ClOrdID = 12345;
//sides.Next();
//sides.Side = Side.SELL;
//sides.Account = 222;
//sides.ClOrdID = 67890;
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, field.Name + "Count");
var repeatGroup = mi.Invoke(MessageBody, new object[] { int.Parse(field.Value) });
MethodInfo next = ReflectionHelper.GetNestedMethodByName(assembly, MessageName, field.Name + "Group", "next");
SbeMessage _Original = SbeLoader.LoadMessageByName(MessageName);
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
foreach (SbeField child in field.Fields)
{
if (child.Name == _OriginalField.Fields[0].Name)
{
next.Invoke(repeatGroup, null);
}
if (!String.IsNullOrEmpty(child.Value))
{
if (SbeLoader._Enums.Find(x => x.Name == child.Type) != null)
{
if (child.Presence.Contains("constant") || String.IsNullOrEmpty(child.Value))
{
continue;
}
Type _enumType = ReflectionHelper.GetType(assembly, child.Type);
if (_enumType.IsEnum)
{
SbeEnum _enum = SbeLoader._Enums.Find(x => x.Name == child.Type);
SbeEnumValidValue valid = _enum.ValidValues.Find(x => x.Value == child.Value);
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
pi.SetValue(repeatGroup, Enum.Parse(_enumType, valid.Name));
}
}
else
{
PropertyInfo pi = ReflectionHelper.GetNestedPropertyByName(assembly, MessageName, field.Name + "Group", child.Name);
pi.SetValue(repeatGroup, Convert.ChangeType(child.Value, pi.PropertyType));
}
}
}
#endregion
}
else
{
PropertyInfo pi = ReflectionHelper.GetPropertyByName(assembly, MessageName, field.Type);
if (pi != null)
{
object parent = pi.GetValue(MessageBody);
foreach (SbeField child in field.Fields)
{
if (child.Presence.Contains("constant") || String.IsNullOrEmpty(child.Value))
{
continue;
}
PropertyInfo pi2 = ReflectionHelper.GetPropertyByName(assembly, field.Type, child.Name);
pi2.SetValue(parent, Convert.ChangeType(child.Value, pi2.PropertyType));
}
}
else
{
// Manufacturer = Encoding.GetEncoding(Car.ManufacturerCharacterEncoding).GetBytes("Honda");
// car.SetManufacturer(Manufacturer, srcOffset, Manufacturer.Length);
FieldInfo fi = ReflectionHelper.GetFieldByName(assembly, MessageName, field.Name + "CharacterEncoding");
byte[] fieldByte = System.Text.Encoding.GetEncoding(fi.GetValue(MessageBody).ToString())
.GetBytes(field.Value);
MethodInfo mi = ReflectionHelper.GetMethodByName(assembly, MessageName, "Set" + field.Name, "byte[]");
mi.Invoke(MessageBody, new object[] { fieldByte, 0, fieldByte.Length });
//mi.Invoke(MessageBody, new object[] { fieldByte, 0 });
}
}
#endregion
}
}
private void tree_CellEditFinishing(object sender, BrightIdeasSoftware.CellEditEventArgs e)
{
if (e.Cancel)
{
return;
}
SbeField field = (SbeField)e.RowObject;
if (e.Control is ComboBox)
{
if (e.Column.Text == "PrimitiveType")
{
field.PrimitiveType = e.Control.Text.Trim();
switch (field.PrimitiveType)
{
case "uint8":
case "int8":
field.Length = 1;
break;
case "uint16":
case "int16":
field.Length = 2;
break;
case "uint32":
case "int32":
field.Length = 4;
break;
case "uint64":
case "int64":
field.Length = 8;
break;
case "char":
field.Length = 10;
break;
}
}
else if (e.Column.Text == "Value")
{
if (e.Control.Text.Contains("|"))
{
field.Value = e.Control.Text.Split('|')[0].Trim();
}
else
{
field.Value = e.Control.Text.Trim();
}
}
}
else if (e.Control is TextBox)
{
if (e.Column.Text == "Value")
{
field.Value = e.Control.Text.Trim();
}
else if (e.Column.Text == "Length")
{
field.Length = int.Parse(e.Control.Text.Trim());
}
}
if (field.Type.ToLower().Equals("groupsizeencoding"))
{
try
{
int repeating = int.Parse(field.Value);
int repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
SbeMessage _Original = null;
if (checkBox1.Checked)
{
_Original = SbeLoader.LoadMessageByName(_Message[1].Name);
}
else
{
_Original = SbeLoader.LoadMessageByName(_Message[0].Name);
}
SbeField _OriginalField = _Original.Fields.Find(x => x.Name == field.Name).Clone();
if (repeating > repeatingGroupAtual)
{
while (repeating > repeatingGroupAtual)
{
SbeField _FieldOriginal = _OriginalField.Clone();
field.Fields.AddRange(_FieldOriginal.Fields);
repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
}
}
else if (repeating < repeatingGroupAtual)
{
while (repeating < repeatingGroupAtual)
{
foreach (SbeField _ChildField in _OriginalField.Fields)
{
SbeField toRemove = field.Fields.FindLast(x => x.Name == _ChildField.Name);
field.Fields.Remove(toRemove);
}
repeatingGroupAtual = field.Fields.FindAll(x => x.Name == field.Fields[0].Name).Count;
}
}
tree.Roots = _Message;
tree.ExpandAll();
}
catch
{
}
}
tree.RefreshItem(e.ListViewItem);
e.Cancel = true;
}
private void tree_CellEditStarting(object sender, BrightIdeasSoftware.CellEditEventArgs e)
{
if (e.RowObject is SbeField)
{
SbeField f = (SbeField)e.RowObject;
if ((f.Presence.Equals("constant") && !checkBox1.Checked) || (f.Fields != null && f.Fields.Count > 0 && !f.Type.ToLower().Equals("groupsizeencoding")))
{
e.Cancel = true;
return;
}
else
{
if (e.Column.Text == "Value")
{
if (SbeLoader._Enums.Find(x => x.Name == f.Type) != null)
{
ComboBox cb = new ComboBox();
cb.Bounds = e.CellBounds;
cb.Items.Add("");
SbeEnum enu = SbeLoader._Enums.Find(x => x.Name == f.Type);
enu.ValidValues.ForEach(x => cb.Items.Add(x.Value + " | " + x.Name));
cb.Text = f.Value;
e.Control = cb;
}
else
{
TextBox tb = new TextBox();
tb.Bounds = e.CellBounds;
tb.Text = f.Value;
e.Control = tb;
}
}
else if (e.Column.Text == "PrimitiveType")
{
ComboBox cb = new ComboBox();
cb.Bounds = e.CellBounds;
cb.Items.Add("");
foreach (SbeLoader.PrimitiveType p in Enum.GetValues(typeof(SbeLoader.PrimitiveType)))
{
cb.Items.Add(p.ToString().ToLower());
}
cb.Text = f.PrimitiveType;
e.Control = cb;
}
else if (e.Column.Text == "Length")
{
if (e.RowObject is SbeField)
{
if (((SbeField)e.RowObject).PrimitiveType == "char")
{
TextBox tb = new TextBox();
tb.Bounds = e.CellBounds;
tb.Text = f.Length.ToString();
e.Control = tb;
}
}
}
}
}
else
{
e.Cancel = true;
return;
}
}
private void FillValue(DirectBuffer buffer, SbeField field2, ref int offset)
{
if (field2.Presence.ToLower().Contains("constant"))
{
return;
}
SbeField field = field2.Clone();
if (field.PrimitiveType == null)
{
field.PrimitiveType = field.Type;
}
if (field.PrimitiveType.ToLower().Equals("uint8"))
{
field2.Value = buffer.Uint8Get(offset).ToString();
offset += 1;
}
else if (field.PrimitiveType.ToLower().Equals("uint16"))
{
field2.Value = buffer.Uint16GetLittleEndian(offset).ToString();
offset += 2;
}
else if (field.PrimitiveType.ToLower().Equals("uint32"))
{
field2.Value = buffer.Uint32GetLittleEndian(offset).ToString();
offset += 4;
}
else if (field.PrimitiveType.ToLower().Equals("uint64"))
{
field2.Value = buffer.Uint64GetLittleEndian(offset).ToString();
offset += 8;
}
else if (field.PrimitiveType.ToLower().Equals("int8"))
{
field2.Value = buffer.Int8Get(offset).ToString();
offset += 1;
}
else if (field.PrimitiveType.ToLower().Equals("int16"))
{
field2.Value = buffer.Int16GetLittleEndian(offset).ToString();
offset += 2;
}
else if (field.PrimitiveType.ToLower().Equals("int32"))
{
field2.Value = buffer.Int32GetLittleEndian(offset).ToString();
offset += 4;
}
else if (field.PrimitiveType.ToLower().Equals("int64"))
{
field2.Value = buffer.Int64GetLittleEndian(offset).ToString();
offset += 8;
}
else if (field.PrimitiveType.ToLower().Equals("char"))
{
if (!String.IsNullOrEmpty(field.CharacterEncoding))
{
List <byte> charString = new List <byte>();
for (int i = 0; i < field.Length; i++)
{
charString.Add(buffer.CharGet(offset + i));
}
field2.Value = Encoding.GetEncoding(field.CharacterEncoding).GetString(charString.ToArray());
}
else
{
byte[] charString = Encoding.GetEncoding("UTF-8").GetBytes(field.Value);
buffer.CharPut(offset, charString[0]);
}
offset += field.Length.Value;
}
if (field2.Fields != null && field2.Fields.Count > 0)
{
if (!field2.Type.ToLower().EndsWith("encoding"))
{
foreach (SbeField child in field2.Fields)
{
FillValue(buffer, child, ref offset);
}
}
else
{
FillValue(buffer, field2.Fields[0], ref offset);
List <byte> charString = new List <byte>();
int len = int.Parse(field2.Fields[0].Value);
for (int i = 0; i < len; i++)
{
charString.Add(buffer.CharGet(offset + i));
}
field2.Fields[1].Value = Encoding.GetEncoding(field2.Fields[1].CharacterEncoding).GetString(charString.ToArray());
offset += len;
}
}
}
private void SetField(DirectBuffer buffer, SbeField field2, ref int offset)
{
SbeField field = field2.Clone();
if (field.PrimitiveType == null)
{
field.PrimitiveType = field.Type;
}
if (field.PrimitiveType.ToLower().Equals("uint8"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Uint8Put(offset, (byte)int.Parse(field.Value));
}
offset += 1;
}
else if (field.PrimitiveType.ToLower().Equals("uint16"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Uint16PutLittleEndian(offset, ushort.Parse(field.Value));
}
offset += 2;
}
else if (field.PrimitiveType.ToLower().Equals("uint32"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Uint32PutLittleEndian(offset, uint.Parse(field.Value));
}
offset += 4;
}
else if (field.PrimitiveType.ToLower().Equals("uint64"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Uint64PutLittleEndian(offset, ulong.Parse(field.Value));
}
offset += 8;
}
else if (field.PrimitiveType.ToLower().Equals("int8"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Int8Put(offset, (sbyte)int.Parse(field.Value));
}
offset += 1;
}
else if (field.PrimitiveType.ToLower().Equals("int16"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Int16PutLittleEndian(offset, short.Parse(field.Value));
}
offset += 2;
}
else if (field.PrimitiveType.ToLower().Equals("int32"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Int32PutLittleEndian(offset, int.Parse(field.Value));
}
offset += 4;
}
else if (field.PrimitiveType.ToLower().Equals("int64"))
{
if (!string.IsNullOrEmpty(field.Value))
{
buffer.Int64PutLittleEndian(offset, long.Parse(field.Value));
}
offset += 8;
}
else if (field.PrimitiveType.ToLower().Equals("char"))
{
if (!string.IsNullOrEmpty(field.Value))
{
if (!String.IsNullOrEmpty(field.CharacterEncoding))
{
byte[] charString = Encoding.GetEncoding(field.CharacterEncoding).GetBytes(field.Value);
int temp = offset;
foreach (byte m in charString)
{
buffer.CharPut(temp, m);
temp++;
}
}
else
{
byte[] charString = Encoding.GetEncoding("UTF-8").GetBytes(field.Value);
buffer.CharPut(offset, charString[0]);
}
}
offset += field.Length.Value;
}
}
