/// <summary>
/// Binary saves the diagram
/// </summary>
/// <param name="fileName">the file-path</param>
/// <param name="control">The control.</param>
/// <returns></returns>
public static bool SaveAs(string fileName, DiagramControlBase control) {
FileStream fs = new FileStream(fileName, FileMode.Create);
GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>();
try {
Document document = control.Document;
//Warning!: cleaning up, you need to unhook all events since
// unserializable classes hooked to events will give problems.
f.Serialize<Document>(fs, document);
return true;
}
catch (Exception exc) {
//site.OutputInfo("The graph was not saved, because some graph events were attached to non-serializable classes.\r\n This is a known issue and will be resolved in a later stadium.",OutputInfoLevels.Exception);
Trace.WriteLine(exc.Message, "BinarySerializer.SaveAs");
//DumpInfo();
}
finally {
fs.Close();
}
return false;
}
static PrettyPrintMinimod()
{
var settings = new Settings();
// integration with PrettyTypeSignatures
settings.RegisterFormatterFor <Type>(PrettyTypeSignaturesMinimod.GetPrettyName);
settings.RegisterFormatterFor <MethodBase>(PrettyTypeSignaturesMinimod.GetPrettyName);
settings.RegisterFormatterFor <StackFrame>(PrettyTypeSignaturesMinimod.GetPrettyName);
// integration with PrettyDateAndTime
settings.RegisterFormatterFor <DateTime>(PrettyDateAndTimeMinimod.GetPrettyString);
settings.RegisterFormatterFor <DateTimeOffset>(PrettyDateAndTimeMinimod.GetPrettyString);
settings.RegisterFormatterFor <TimeSpan>(PrettyDateAndTimeMinimod.GetPrettyString);
settings.RegisterFormatterFor <Guid>(formatter);
// decimal is not a simple type?
settings.RegisterFormatterFor <decimal>(d => d + "m");
GenericFormatter.Register(settings);
FileSystemInfoFormatter.Register(settings);
settings.OmitNullMembers(true);
DefaultSettings = settings;
}
/// <summary>
/// Called when the tool is activated.
/// </summary>
protected override void OnActivateTool() {
try {
// Used to get a collection of entities from the
// NetronClipboard.
Type entitiesType = typeof(CollectionBase<IDiagramEntity>);
// First calculate the insertion point based on the
// current location of the cursor.
InsertionPoint = Point.Round(
Controller.View.ViewToWorld(
Controller.View.DeviceToView(
Controller.ParentControl.PointToClient(Cursor.Position))));
IDataObject data = Clipboard.GetDataObject();
string format = typeof(CopyTool).FullName;
if (data.GetDataPresent(format)) {
MemoryStream stream = data.GetData(format) as MemoryStream;
CollectionBase<IDiagramEntity> collection = null;
GenericFormatter<BinaryFormatter> f =
new GenericFormatter<BinaryFormatter>();
//Anchors collection is a helper collection to re-connect connectors to their parent
Anchors.Clear();
//but is it actually a stream coming this application?
collection = f.Deserialize<CollectionBase<IDiagramEntity>>(stream);
UnwrapBundle(collection);
} else if (NetronClipboard.ContainsData(entitiesType)) {
CollectionBase<IDiagramEntity> collection =
(CollectionBase<IDiagramEntity>)NetronClipboard.Get(
entitiesType);
UnwrapBundle(collection.DeepCopy());
} else if (data.GetDataPresent(DataFormats.Bitmap)) {
Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap;
if (bmp != null) {
#region Unwrap into an image shape
//TODO: Insert the image shape here
ImageShape shape = new ImageShape();
shape.Image = bmp;
shape.Location = InsertionPoint;
Controller.Model.AddShape(shape);
#endregion
}
} else if (data.GetDataPresent(DataFormats.Text)) {
string text = (string)data.GetData(typeof(string));
TextOnly textShape = new TextOnly(Controller.Model);
textShape.Text = text;
textShape.Location = InsertionPoint;
Controller.Model.AddShape(textShape);
}
}
catch (Exception exc) {
throw new InconsistencyException("The Paste operation failed.", exc);
}
finally {
DeactivateTool();
}
}
public void Format()
{
IFormatter formatter = new GenericFormatter();
Assert.AreEqual("1", formatter.Format(1, ""));
Assert.AreEqual("(null)", formatter.Format(null, ""));
Assert.AreEqual("Formatter", formatter.Format("Formatter", ""));
}
protected void gvClientPagePermissions_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
var d = (ClientPagePermissions)e.Row.DataItem;
((CheckBox)e.Row.FindControl("chk")).Checked = false;
((Label)e.Row.FindControl("LblPageName")).Text = GenericFormatter.GetEnumDescription(d);
((HiddenField)e.Row.FindControl("hfpid")).Value = ((int)d).ToString();
}
}
private static string PrettyPrint(this object anyObject, Type declaredType, Settings settings, Stack parents)
{
parents = parents ?? new Stack();
if (anyObject == null)
{
return("<null" + (declaredType != typeof(object) ? ", " + declaredType.GetPrettyName() : "") + ">");
}
if (parents.Contains(anyObject))
{
return("<loop" + (declaredType != typeof(object) ? ", " + declaredType.GetPrettyName() : "") + ">");
}
parents.Push(anyObject);
try
{
var formatter = settings.GetCustomFormatter(anyObject);
if (formatter != null)
{
return(formatter(anyObject));
}
var actualType = anyObject.GetType();
if (anyObject is string)
{
var s = (string)anyObject;
return(s == String.Empty
? "<String.Empty>"
: s);
}
if (actualType.IsPrimitive)
{
return(anyObject.ToString());
}
if (anyObject is IEnumerable)
{
return(enumerable(anyObject as IEnumerable, declaredType, settings));
}
if (declaredType.IsEnum && Enum.IsDefined(declaredType, anyObject))
{
return(String.Format("<{0}.{1} = {2}>", declaredType.Name, Enum.GetName(declaredType, anyObject), (int)anyObject));
}
return(GenericFormatter.Format(actualType, anyObject, settings, parents));
}
finally
{
parents.Pop();
}
}
internal void FillEnum(DropDownList cmb, Type type, bool addSelectValue = true)
{
AddSelectItemForCombo(cmb);
foreach (Enum item in Enum.GetValues(type))
{
string description = GenericFormatter.GetEnumDescription(item);
cmb.Items.Add(new System.Web.UI.WebControls.ListItem {
Text = description, Value = Convert.ToInt32(item).ToString()
});
}
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
Page.PreRender += new EventHandler(PagePreRender);
if (!LoginProvider && CurrentUser == null)
{
SynNavigation.Goto(Pages.Login);
}
if (!IsPostBack)
{
if (RequiredPermissions.NotEmpty())
{
Title = GenericFormatter.GetEnumDescription(RequiredPermissions[0]);
}
else
{
Title = "מסך הבית";
}
if (!LoginProvider)
{
BuildSiteMapLinks();
bool navSelected = false;
if (RequiredPermissions.NotEmpty())
{
var requiredPermis = RequiredPermissions.FirstOrDefault();
PageLinkAttribute HasNavLink = GetPageLink(requiredPermis);
if (HasNavLink != null)
{
((HtmlAnchor)Master.FindControl(HasNavLink.NavLink)).Attributes.Add("class", "active");
navSelected = true;
}
}
if (!navSelected)
{
((HtmlAnchor)Master.FindControl(DefaultNavItem)).Attributes.Add("class", "active");
}
(Master as WebSimplify.WebSimplify).CurrentUserName = CurrentUser.DisplayName ?? CurrentUser.UserName;
(Master as WebSimplify.WebSimplify).IsAdmin = CurrentUser.IsAdmin;
}
foreach (ClientPagePermissions en in RequiredPermissions)
{
if (!CurrentUser.Allowed(en))
{
SynNavigation.Goto(Pages.Main);
}
}
}
}
/// <summary>
/// Opens the binary-saved diagram
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="control">The control.</param>
public static bool Open(string fileName, DiagramControlBase control) {
FileStream fs = null;
try {
fs = File.OpenRead(fileName);
}
catch (System.IO.DirectoryNotFoundException exc) {
System.Windows.Forms.MessageBox.Show(exc.Message);
}
catch (System.IO.FileLoadException exc) {
System.Windows.Forms.MessageBox.Show(exc.Message);
}
catch (System.IO.FileNotFoundException exc) {
System.Windows.Forms.MessageBox.Show(exc.Message);
}
catch (Exception exc) {
throw new Exception("Non-CLS exception caught.", exc);
}
//donnot open anything if filestream is not there
if (fs == null) {
return false;
}
try {
GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>();
//one-line deserialization, no bits 'nd bytes necessary....C# is amazing...
Document document = f.Deserialize<Document>(fs);
if (document == null)
throw new InconsistencyException("The deserialization return 'null'.");
//call the standard method at the control level to attach a new document
//In principle you could create a document programmatically and attach it this way as well.
control.AttachToDocument(document);
return true;
}
catch (SerializationException exc) {
MessageBox.Show(exc.Message);
}
catch (System.Reflection.TargetInvocationException exc) {
MessageBox.Show(exc.Message, "BinarySerializer.Open");
}
catch (Exception exc) {
MessageBox.Show(exc.Message, "BinarySerializer.Open");
}
finally {
if (fs != null) {
fs.Close();
}
}
return false;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("[{0}] ", FieldName);
sb.AppendFormat("[{0}] ", GenericFormatter.GetEnumDescription(FieldType));
if (FieldLLenght != 0)
{
sb.AppendFormat(" ({0}) ", FieldLLenght);
}
sb.Append(IsNullAble ? "NULL" : "NOT NULL");
return(sb.ToString());
}
protected void gvAdd_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
var cmbShifts = ((DropDownList)e.Row.FindControl("cmbShifts"));
((TextBox)e.Row.FindControl("txDate")).Text = string.Empty;
foreach (Enum se in Enum.GetValues(typeof(ShiftTime)))
{
ListItem item = new ListItem(GenericFormatter.GetEnumDescription(se), (se).ToString());
cmbShifts.Items.Add(item);
}
}
}
/// <summary>
/// Called when the tool is activated.
/// </summary>
protected override void OnActivateTool()
{
try
{
IDataObject data = Clipboard.GetDataObject();
string format = typeof(CopyTool).FullName;
if (data.GetDataPresent(format))
{
MemoryStream stream = data.GetData(format) as MemoryStream;
CollectionBase<IDiagramEntity> collection = null;
GenericFormatter<BinaryFormatter> f = new GenericFormatter<BinaryFormatter>();
//Anchors collection is a helper collection to re-connect connectors to their parent
Anchors.Clear();
//but is it actually a stream coming this application?
collection = f.Deserialize<CollectionBase<IDiagramEntity>>(stream);
if (collection != null)
{
#region Unwrap the bundle
this.Controller.Model.Unwrap(collection);
Rectangle rec = Utils.BoundingRectangle(collection);
rec.Inflate(30, 30);
this.Controller.View.Invalidate(rec);
#endregion
}
}
else if (data.GetDataPresent(DataFormats.Bitmap))
{
Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap;
if (bmp != null)
{
#region Unwrap into an image shape
//TODO: Insert the image shape here
#endregion
}
}
}
catch (Exception exc)
{
throw new InconsistencyException("The Copy operation failed.", exc);
}
finally
{
DeactivateTool();
}
}
public static IFormatter <T> Create <T>()
{
Debug.Assert(typeof(T).IsArray);
var elementType = typeof(T).GetElementType();
if (!GenericFormatter.IsSerializableType(elementType))
{
return(null);
}
if (typeof(T).GetArrayRank() == 1 && typeof(T) == elementType.MakeArrayType())
{
return(CreateSZArrayFormatter <T>(elementType));
}
return(CreateMultidimensionalArrayFormatter <T>(elementType));
}
public ActionResult Format([FromBody] FormatRequest request)
{
if (request == null)
{
return(Content("Invalid Input parameters."));
}
if (string.IsNullOrWhiteSpace(request.InputText))
{
return(Content("Input your text."));
}
var splittedSentences = _formatter.Format(request.InputText);
var genericFormatter = new GenericFormatter();
var formatter = genericFormatter.Create((FormatType)request.FormatType);
return(Content(formatter.Format(splittedSentences)));
}
private static bool IsSerializableSubType <T>(Type type)
{
if (type == null)
{
return(false);
}
if (type == typeof(T))
{
return(false);
}
if (!typeof(T).IsAssignableFrom(type))
{
return(false);
}
return(GenericFormatter.IsSerializableType(type));
}
protected override IList <Request> GetRequestsForTask(Guid taskId)
{
var requests = new List <Request>();
var items = queueRepository.ListByTask(taskId, TotalItems);
var formatter = new GenericFormatter();
foreach (var item in items)
{
var content = formatter.GetJsonContent(item.Id, Properties);
if (!String.IsNullOrEmpty(content))
{
var request = new Request(item.Id, (int)item.Key, content, true);
requests.Add(request);
}
}
return(requests);
}
public static string FormatSignature(string declStr, int genQty)
{
var func = new GenericFormatter();
var parameters = new List <GenericFormatter>();
var split = declStr.Split('(');
var pars = split.Last().Split(')').First().Split(',');
var split2 = split.First().Split('<');
func.preText = split2.First();
func.postText = "";
func.generics = split2.Last().Split('>').First().Split(',').ToList();
foreach (string par in pars)
{
if (par.Contains('<'))
{
var nam = par.Split('<').First();
var pgens = par.Split('<').Last().Split('>').First().Split(',').ToList();
var e = par.Split('<').Last().Split('>').Last();
parameters.Add(new GenericFormatter(nam, e, pgens));
}
else
{
parameters.Add(new GenericFormatter(par, "", null));
//if parameter is a generic (todo get generic parameters) repeat for qty
if (par.Split(' ').Any(x => x == "T0"))
{
for (int i = 1; i < genQty; i++)
{
parameters.Add(new GenericFormatter(Utils.IncrementGeneric(par, i), "", null));
}
}
}
}
return($"{func.Format(genQty)}({string.Join(", ",parameters.Select(x=>x.Format(genQty)))})");
}
private static (Dictionary <string, FieldInfo> initOnlyFields, FieldInfo[] fields) GetFields(Type type)
{
var initOnlyFields = new Dictionary <string, FieldInfo>(StringComparer.OrdinalIgnoreCase);
var fields = new List <FieldInfo>();
var currentType = type;
do
{
foreach (var field in currentType.GetFields(BindingFlagsEx.DeclaredInstance))
{
if (field.IsNotSerialized)
{
continue;
}
if (!GenericFormatter.IsSerializableType(field.FieldType))
{
continue;
}
if (field.IsInitOnly)
{
var fieldOrPropertyName = GetFieldOrPropertyName(field);
if (!initOnlyFields.ContainsKey(fieldOrPropertyName))
{
initOnlyFields.Add(fieldOrPropertyName, field);
}
}
else
{
fields.Add(field);
}
}
} while ((currentType = currentType.BaseType) != null);
return(initOnlyFields, fields.ToArray());
}
private static void SerializeField <T>(ILGenerator il, FieldInfo field)
{
var type = PrimitiveTypes.GetPrimitiveType(field.FieldType);
if (type == PrimitiveType.NotPrimitive)
{
GenericFormatter.EmitLoadCachedInstance(il, field.FieldType);
}
LoadFieldValue <T>(il, field);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadArgument(3);
switch (type)
{
case PrimitiveType.NotPrimitive:
il.EmitLoadArgument(4);
il.EmitLoadArgument(5);
GenericFormatter.EmitSerialize(il, field.FieldType);
break;
case PrimitiveType.SByte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteSByte), BindingFlagsEx.Static));
break;
case PrimitiveType.Byte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteByte), BindingFlagsEx.Static));
break;
case PrimitiveType.Int16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteInt16), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteUInt16), BindingFlagsEx.Static));
break;
case PrimitiveType.Int32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedInt32), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static));
break;
case PrimitiveType.Int64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedInt64), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt64), BindingFlagsEx.Static));
break;
case PrimitiveType.Boolean:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteBoolean), BindingFlagsEx.Static));
break;
case PrimitiveType.Char:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteChar), BindingFlagsEx.Static));
break;
case PrimitiveType.Single:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteSingle), BindingFlagsEx.Static));
break;
case PrimitiveType.Double:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWriteDouble), BindingFlagsEx.Static));
break;
default:
Debug.Assert(false);
break;
}
}
public TableCellParser(string input, GenericFormatter formatter)
{
_lineFragment = input;
_formatter = formatter;
}
public static string GetDescription(this Enum e)
{
return GenericFormatter.GetEnumDescription(e);
}
private static void GetFieldSize <T>(ILGenerator il, FieldInfo field)
{
var type = PrimitiveTypes.GetPrimitiveType(field.FieldType);
if (type == PrimitiveType.NotPrimitive)
{
GenericFormatter.EmitLoadCachedInstance(il, field.FieldType);
}
LoadFieldValue <T>(il, field);
switch (type)
{
case PrimitiveType.NotPrimitive:
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
GenericFormatter.EmitGetSize(il, field.FieldType);
break;
case PrimitiveType.SByte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetSByteSize), BindingFlagsEx.Static));
break;
case PrimitiveType.Byte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetByteSize), BindingFlagsEx.Static));
break;
case PrimitiveType.Int16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetInt16Size), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetUInt16Size), BindingFlagsEx.Static));
break;
case PrimitiveType.Int32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedInt32Size), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedUInt32Size), BindingFlagsEx.Static));
break;
case PrimitiveType.Int64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedInt64Size), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGet7BitEncodedUInt64Size), BindingFlagsEx.Static));
break;
case PrimitiveType.Boolean:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetBooleanSize), BindingFlagsEx.Static));
break;
case PrimitiveType.Char:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetCharSize), BindingFlagsEx.Static));
break;
case PrimitiveType.Single:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetSingleSize), BindingFlagsEx.Static));
break;
case PrimitiveType.Double:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalGetDoubleSize), BindingFlagsEx.Static));
break;
default:
Debug.Assert(false);
break;
}
}
private static SerializationFunc <T> CreateUnionSerializationFunc <T>(Type[] types)
{
var serialzationFunc = new DynamicMethod(string.Empty, typeof(int), new[] { typeof(T), typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int) }, true);
var il = serialzationFunc.GetILGenerator();
var indexBytesWritten = il.DeclareLocal(typeof(int));
{
var valueNotNull = il.DefineLabel();
il.EmitLoadArgument(0);
il.Emit(OpCodes.Brtrue_S, valueNotNull);
il.EmitLoadDeclaredConstant(0);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadArgument(3);
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static));
il.Emit(OpCodes.Ret);
il.MarkLabel(valueNotNull);
}
for (var i = 0; i < types.Length; i++)
{
var type = types[i];
var skipLabel = il.DefineLabel();
il.EmitLoadArgument(0);
il.Emit(OpCodes.Isinst, type);
il.Emit(OpCodes.Brfalse_S, skipLabel);
il.EmitLoadDeclaredConstant(i + 1);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadArgument(3);
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalWrite7BitEncodedUInt32), BindingFlagsEx.Static));
il.EmitStoreLocal(indexBytesWritten.LocalIndex);
GenericFormatter.EmitLoadCachedInstance(il, type);
il.EmitLoadArgument(0);
if (type.IsClass)
{
il.Emit(OpCodes.Castclass, type);
}
else
{
Debug.Assert(type.IsValueType);
il.Emit(OpCodes.Unbox_Any, type);
}
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadLocal(indexBytesWritten.LocalIndex);
il.Emit(OpCodes.Add);
il.EmitLoadArgument(3);
il.EmitLoadLocal(indexBytesWritten.LocalIndex);
il.Emit(OpCodes.Sub);
il.EmitLoadArgument(4);
il.EmitLoadArgument(5);
GenericFormatter.EmitSerialize(il, type);
il.EmitLoadLocal(indexBytesWritten.LocalIndex);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ret);
il.MarkLabel(skipLabel);
}
il.Emit(OpCodes.Ldstr, "Failed to serialize the object, because no implementation was found.");
il.Emit(OpCodes.Ldstr, "value");
il.Emit(OpCodes.Newobj, typeof(ArgumentException).GetConstructor(new[] { typeof(string), typeof(string) }));
il.Emit(OpCodes.Throw);
return((SerializationFunc <T>)serialzationFunc.CreateDelegate(typeof(SerializationFunc <T>)));
}
private static void DeserializeField(ILGenerator il, FieldInfo field, LocalBuilder size)
{
var type = PrimitiveTypes.GetPrimitiveType(field.FieldType);
if (type == PrimitiveType.NotPrimitive)
{
GenericFormatter.EmitLoadCachedInstance(il, field.FieldType);
}
il.EmitLoadArgument(0);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadLocalAddress(size.LocalIndex);
switch (type)
{
case PrimitiveType.NotPrimitive:
il.EmitLoadArgument(4);
il.EmitLoadArgument(5);
GenericFormatter.EmitDeserialize(il, field.FieldType);
break;
case PrimitiveType.SByte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadSByte), BindingFlagsEx.Static));
break;
case PrimitiveType.Byte:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadByte), BindingFlagsEx.Static));
break;
case PrimitiveType.Int16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadInt16), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt16:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadUInt16), BindingFlagsEx.Static));
break;
case PrimitiveType.Int32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt32), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt32:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedUInt32), BindingFlagsEx.Static));
break;
case PrimitiveType.Int64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt64), BindingFlagsEx.Static));
break;
case PrimitiveType.UInt64:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedUInt64), BindingFlagsEx.Static));
break;
case PrimitiveType.Boolean:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadBoolean), BindingFlagsEx.Static));
break;
case PrimitiveType.Char:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadChar), BindingFlagsEx.Static));
break;
case PrimitiveType.Single:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadSingle), BindingFlagsEx.Static));
break;
case PrimitiveType.Double:
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalReadDouble), BindingFlagsEx.Static));
break;
default:
Debug.Assert(false);
break;
}
}
private static DeserializationFunc <T> CreateUnionDeserializationFunc <T>(Type[] types)
{
var deserialzationFunc = new DynamicMethod(string.Empty, typeof(T), new[] { typeof(byte[]), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int).MakeByRefType() }, true);
var il = deserialzationFunc.GetILGenerator();
var index = il.DeclareLocal(typeof(int));
var indexSize = il.DeclareLocal(typeof(int));
var objectSize = il.DeclareLocal(typeof(int));
var result = il.DeclareLocal(typeof(T));
il.EmitLoadArgument(0);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadLocalAddress(indexSize.LocalIndex);
il.Emit(OpCodes.Call, typeof(Binary).GetMethod(nameof(Binary.InternalRead7BitEncodedInt32), BindingFlagsEx.Static));
il.EmitStoreLocal(index.LocalIndex);
{
var validIndex = il.DefineLabel();
il.EmitLoadLocal(index.LocalIndex);
il.EmitLoadDeclaredConstant(types.Length);
il.Emit(OpCodes.Ble_S, validIndex);
il.Emit(OpCodes.Ldstr, "Failed to deserialize the object, because its union index was out of bounds.");
il.Emit(OpCodes.Newobj, typeof(SerializationException).GetConstructor(new[] { typeof(string) }));
il.Emit(OpCodes.Throw);
il.MarkLabel(validIndex);
}
{
var valueNotNull = il.DefineLabel();
il.EmitLoadLocal(result.LocalIndex);
il.Emit(OpCodes.Brtrue_S, valueNotNull);
il.EmitLoadArgument(5);
il.EmitLoadLocal(indexSize.LocalIndex);
il.Emit(OpCodes.Stind_I4);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ret);
il.MarkLabel(valueNotNull);
}
il.EmitLoadArgument(1);
il.EmitLoadLocal(indexSize.LocalIndex);
il.Emit(OpCodes.Add);
il.EmitStoreArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadLocal(indexSize.LocalIndex);
il.Emit(OpCodes.Sub);
il.EmitStoreArgument(2);
il.EmitLoadLocal(index.LocalIndex);
il.EmitLoadDeclaredConstant(1);
il.Emit(OpCodes.Sub);
il.EmitStoreLocal(index.LocalIndex);
var jumpTable = new Label[types.Length];
var endOfSwitch = il.DefineLabel();
for (var i = 0; i < types.Length; i++)
{
jumpTable[i] = il.DefineLabel();
}
il.EmitLoadLocal(index.LocalIndex);
il.Emit(OpCodes.Switch, jumpTable);
for (var i = 0; i < types.Length; i++)
{
var type = types[i];
il.MarkLabel(jumpTable[i]);
GenericFormatter.EmitLoadCachedInstance(il, type);
il.EmitLoadArgument(0);
il.EmitLoadArgument(1);
il.EmitLoadArgument(2);
il.EmitLoadArgument(3);
il.EmitLoadArgument(4);
il.EmitLoadLocalAddress(objectSize.LocalIndex);
GenericFormatter.EmitDeserialize(il, type);
if (type.IsValueType)
{
il.Emit(OpCodes.Box, type);
}
il.EmitStoreLocal(result.LocalIndex);
il.Emit(OpCodes.Br, endOfSwitch);
}
il.MarkLabel(endOfSwitch);
il.EmitLoadArgument(5);
il.EmitLoadLocal(indexSize.LocalIndex);
il.EmitLoadLocal(objectSize.LocalIndex);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stind_I4);
il.EmitLoadLocal(result.LocalIndex);
il.Emit(OpCodes.Ret);
return((DeserializationFunc <T>)deserialzationFunc.CreateDelegate(typeof(DeserializationFunc <T>)));
}
