private SerializationStatus DeserializeObject(SerializationInstance instance, Type t, SerializationInfo s_info, StreamingContext context)
{
object obj = t.GetConstructor(Type.EmptyTypes)?.Invoke(Array.Empty <object>());
if (obj == null)
{
return(SerializationStatus.Failure);
}
Dictionary <string, MemberInfo> map = t.GetMembers().Where(mi => CheckGetAndSet(mi, false, true, true)).ToDictionary(mi => mi.Name);
foreach (SerializationEntry entry in s_info)
{
if (!map.TryGetValue(entry.Name, out MemberInfo mi))
{
continue;
}
object value = s_info.GetValue(entry.Name, GetMemberType(mi));
SetValue(obj, mi, value);
}
return(SerializationStatus.Deserialized(obj));
}
private SerializationStatus DeserializeSerializable(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
object obj = FormatterServices.GetUninitializedObject(t);
InvokeOnSerialize(obj, context, false, false);
if (typeof(ISerializable).IsAssignableFrom(t) && TryDeserializeISerializable(obj, info, context))
{
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
Dictionary <string, MemberInfo> map = FormatterServices.GetSerializableMembers(t, context).ToDictionary(m => m.Name);
List <MemberInfo> found = new List <MemberInfo>();
List <object> values = new List <object>();
foreach (SerializationEntry entry in info)
{
if (!map.TryGetValue(entry.Name, out MemberInfo mi))
{
continue;
}
found.Add(mi);
values.Add(info.GetValue(entry.Name, GetMemberType(mi)));
}
obj = FormatterServices.PopulateObjectMembers(obj, found.ToArray(), values.ToArray());
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
private SerializationStatus DeserializeContract(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
HashSet <string> items = new HashSet <string>();
foreach (SerializationEntry entry in info)
{
items.Add(entry.Name);
}
IEnumerable <Tuple <MemberInfo, DataMemberAttribute> > members = t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Where(mi => CheckGetAndSet(mi, false, true, false)).Select(mi => Tuple.Create(mi, mi.GetCustomAttribute <DataMemberAttribute>()))
.Where(tup => tup.Item2 != null).OrderBy(tup => tup.Item2.Order);
object obj = FormatterServices.GetUninitializedObject(t);
foreach (Tuple <MemberInfo, DataMemberAttribute> tup in members)
{
MemberInfo mi = tup.Item1;
DataMemberAttribute dma = tup.Item2;
string name = dma.IsNameSetExplicitly ? dma.Name : mi.Name;
if (dma.IsRequired && !items.Contains(name))
{
return(SerializationStatus.Failure);
}
object value = info.GetValue(name, GetMemberType(mi));
SetValue(obj, mi, value);
}
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
private ResponsePacket BuildSerializationErrorPacket(SerializationStatus status, Guid clientId)
{
return(status switch
{
SerializationStatus.Error => BuildPacket(Status.InternalError, "There was an issue deserializing", clientId),
SerializationStatus.NotApplicable => BuildPacket(Status.InvalidType, "No handle for that type", clientId),
_ => throw new Exception($"Missing arm of switch {status}")
});
public SerializationStatus Deserialize(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
if (Deserializer == null || !Deserializer(Deep ? instance.CreateLoopbackInfo(info) : info, context, out object value))
{
return(SerializationStatus.Failure);
}
return(SerializationStatus.Deserialized(value));
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">A serialization manager interface that is used during the deserialization process.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>A CodeDOM object representing the object that has been serialized.</returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// Set serialization flag
bool oldSerializationFlag = false;
SerializationStatus oldSerializationStatus = SerializationStatus.None;
Chart chart = value as Chart;
if (chart != null)
{
oldSerializationFlag = chart.serializing;
oldSerializationStatus = chart.serializationStatus;
chart.serializing = true;
chart.serializationStatus = SerializationStatus.Saving;
}
// Serialize object using the base class serializer
object result = null;
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Chart).BaseType, typeof(CodeDomSerializer));
if (baseSerializer != null)
{
result = baseSerializer.Serialize(manager, value);
System.CodeDom.CodeStatementCollection statements = result as System.CodeDom.CodeStatementCollection;
// Sustom serialization of the DataSource property
if (statements != null && chart != null)
{
// Check if DataSource property is set
if (chart.DataSource != null && chart.DataSource is String && ((String)chart.DataSource) != "(none)")
{
// Add assignment statement for the DataSource property
System.CodeDom.CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
System.CodeDom.CodeAssignStatement assignStatement = new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodePropertyReferenceExpression(targetObject, "DataSource"),
new System.CodeDom.CodePropertyReferenceExpression(new System.CodeDom.CodeThisReferenceExpression(), (String)chart.DataSource));
statements.Add(assignStatement);
}
}
}
}
// Clear serialization flag
if (chart != null)
{
chart.serializing = oldSerializationFlag;
chart.serializationStatus = oldSerializationStatus;
}
return(result);
}
private SerializationStatus DeserializeSerializable(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
object obj = FormatterServices.GetUninitializedObject(t);
InvokeOnSerialize(obj, context, false, false);
if (typeof(ISerializable).IsAssignableFrom(t) && TryDeserializeISerializable(obj, info, context))
{
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
Dictionary <string, MemberInfo> map = FormatterServices.GetSerializableMembers(t, context).ToDictionary(m => m.Name);
List <MemberInfo> found = new List <MemberInfo>();
List <object> values = new List <object>();
List <MemberInfo> missing = new List <MemberInfo>();
List <ulong> missing_ids = new List <ulong>();
foreach (SerializationEntry entry in info)
{
if (!map.TryGetValue(entry.Name, out MemberInfo mi))
{
continue;
}
SerializedObject so = (SerializedObject)info.GetValue(entry.Name, typeof(SerializedObject));
if (instance.TryGetOrDeserialize(GetMemberType(mi), so, out object val))
{
found.Add(mi);
values.Add(val);
}
else
{
missing.Add(mi);
missing_ids.Add(so.Id);
}
}
obj = FormatterServices.PopulateObjectMembers(obj, found.ToArray(), values.ToArray());
if (missing_ids.Count == 0)
{
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
return(SerializationStatus.FixupLater(obj, CreateSerializableFixup(missing.ToArray(), context), missing_ids.ToArray()));
}
private SerializationStatus DeserializeContract(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
HashSet <string> items = new HashSet <string>();
foreach (SerializationEntry entry in info)
{
items.Add(entry.Name);
}
IEnumerable <Tuple <MemberInfo, DataMemberAttribute> > members = t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Where(mi => CheckGetAndSet(mi, false, true, false)).Select(mi => Tuple.Create(mi, mi.GetCustomAttribute <DataMemberAttribute>()))
.Where(tup => tup.Item2 != null).OrderBy(tup => tup.Item2.Order);
object obj = FormatterServices.GetUninitializedObject(t);
List <MemberInfo> unassigned_members = new List <MemberInfo>();
List <ulong> unassigned_ids = new List <ulong>();
foreach (Tuple <MemberInfo, DataMemberAttribute> tup in members)
{
MemberInfo mi = tup.Item1;
DataMemberAttribute dma = tup.Item2;
string name = dma.IsNameSetExplicitly ? dma.Name : mi.Name;
if (dma.IsRequired && !items.Contains(name))
{
return(SerializationStatus.Failure);
}
SerializedObject so = (SerializedObject)info.GetValue(name, typeof(SerializedObject));
if (!instance.TryGetOrDeserialize(GetMemberType(mi), so, out object value) || unassigned_members.Count > 0)
{
unassigned_members.Add(mi);
unassigned_ids.Add(so.Id);
continue;
}
SetValue(obj, mi, value);
}
if (unassigned_members.Count > 0)
{
return(SerializationStatus.FixupLater(obj, CreateObjectFixup(unassigned_members.ToArray(), context), unassigned_ids.ToArray()));
}
InvokeOnSerialize(obj, context, false, true);
return(SerializationStatus.Deserialized(obj));
}
public SerializationStatus Deserialize(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
Type[] args = t.GetGenericArguments();
Type key_array_type = args[0].MakeArrayType();
Type value_array_type = args[1].MakeArrayType();
object o = Activator.CreateInstance(t);
SerializedObject serialized_keys = (SerializedObject)info.GetValue("keys", typeof(SerializedObject));
SerializedObject serialized_values = (SerializedObject)info.GetValue("values", typeof(SerializedObject));
//bitwise & operator used to make sure both run
if (instance.TryGetOrDeserializeFully(key_array_type, serialized_keys, out object keys) & instance.TryGetOrDeserializeFully(value_array_type, serialized_values, out object values))
{
AddAllValues(o, keys, values, args[0], args[1]);
return(SerializationStatus.Deserialized(o));
}
return(SerializationStatus.FixupLater(o, CreateFixup(args[0], args[1]), new ulong[] { serialized_keys.Id, serialized_values.Id }));
}
public SerializationStatus Deserialize(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
{
if (!t.IsArray)
{
return(SerializationStatus.Failure);
}
if (t == typeof(Array))
{
return(SerializationStatus.Failure);
}
SerializedObject[] serialized_array = (SerializedObject[])info.GetValue("array", typeof(SerializedObject[]));
Type e_type = t.GetElementType();
Array array = Array.CreateInstance(e_type, serialized_array.Length);
List <int> missing_indexes = new List <int>();
List <ulong> missing_ids = new List <ulong>();
for (int i = 0; i < serialized_array.Length; i++)
{
if (!instance.TryGetOrDeserialize(e_type, serialized_array[i], out object value))
{
missing_ids.Add(serialized_array[i].Id);
missing_indexes.Add(i);
continue;
}
array.SetValue(value, i);
}
if (missing_indexes.Count > 0)
{
return(SerializationStatus.FixupLater(array, CreateArrayFixup(missing_indexes.ToArray()), missing_ids.ToArray()));
}
return(SerializationStatus.Deserialized(array));
}
private SerializationStatus DeserializeObject(SerializationInstance instance, Type t, SerializationInfo s_info, StreamingContext context)
{
object obj = t.GetConstructor(Type.EmptyTypes)?.Invoke(Array.Empty <object>());
if (obj == null)
{
return(SerializationStatus.Failure);
}
Dictionary <string, MemberInfo> map = t.GetMembers().Where(mi => CheckGetAndSet(mi, false, true, true)).ToDictionary(mi => mi.Name);
List <ulong> missing_ids = new List <ulong>();
List <MemberInfo> missing_members = new List <MemberInfo>();
foreach (SerializationEntry entry in s_info)
{
if (!map.TryGetValue(entry.Name, out MemberInfo mi))
{
continue;
}
SerializedObject so = (SerializedObject)s_info.GetValue(entry.Name, typeof(SerializedObject));
if (!instance.TryGetOrDeserialize(GetMemberType(mi), so, out object value))
{
missing_members.Add(mi);
missing_ids.Add(so.Id);
continue;
}
SetValue(obj, mi, value);
}
if (missing_members.Count > 0)
{
return(SerializationStatus.FixupLater(obj, CreateObjectFixup(missing_members.ToArray(), context), missing_ids.ToArray()));
}
return(SerializationStatus.Deserialized(obj));
}
public SerializationStatus Deserialize(SerializationInstance instance, Type t, SerializationInfo info, StreamingContext context)
=> SerializationStatus.Deserialized(Guid.Parse(info.GetString("value")));
public SerializationStatus Serialize(SerializationInstance instance, object obj, SerializationInfo info, StreamingContext context) => SerializationStatus.UseAlternativeType(RedirectTo);
/// <summary>
/// DO NOT CALL FROM UI-LAYER. Call between managed adapter and manages layers.
/// </summary>
public void EndSerializationTarget()
{
if (this.m_SerializationStatus == SerializationStatus.Stopped)
{
//
// Avoid re-entry.
//
throw new System.ApplicationException(
"Trying to stop a serialization target that is already stopped.");
}
//
// Set to ended state.
//
this.m_SerializationStatus = SerializationStatus.Stopped;
//
// Precondition: Check that childs have been closed.
//
foreach (Serializer childSerializer in this.m_childSerializers)
{
if (childSerializer.m_SerializationStatus != SerializationStatus.Stopped)
{
throw new System.ApplicationException(
"Parent SerializationTarget node is being ended while Child SerializationTarget node has ended yet.");
}
}
//
// Write sub results index reference in parent of this child.
//
if (this.m_parentSerializer != null)
{
DvtkData.Results.SubResultsLink subResultsLink = new DvtkData.Results.SubResultsLink();
int index = this.m_parentSerializer.m_childSerializers.IndexOf(this);
switch (this.m_serializerNodeType)
{
case Wrappers.WrappedSerializerNodeType.DirectoryRecord:
case Wrappers.WrappedSerializerNodeType.Thread:
{
subResultsLink.SubResultsIndex = (uint)index;
subResultsLink.NrOfErrors = this.m_endCounters.NrOfErrors;
subResultsLink.NrOfWarnings = this.m_endCounters.NrOfWarnings;
//
// Write sub results link to parent document.
//
if (this.m_serializerNodeType == Wrappers.WrappedSerializerNodeType.Thread)
{
subResultsLink.DvtDetailToXml(
this.m_parentSerializer.m_serializationWriter.DetailStreamWriter, 0);
subResultsLink.DvtSummaryToXml(
this.m_parentSerializer.m_serializationWriter.SummaryStreamWriter, 0);
}
}
break;
case Wrappers.WrappedSerializerNodeType.TopParent:
default:
throw new System.ApplicationException(
System.String.Format(
"child serializer can not be of type:{0}",
this.m_serializerNodeType.ToString()));
}
}
//
// Add counters at the end of the output file of each parent.
//
this.SerializeCounts();
this.m_serializationWriter.WriteEndElement();
this.m_serializationWriter.WriteEndDocument();
m_serializationWriter = null;
}
private void Init(
int indexOfChildInParentCollection,
Wrappers.WrappedSerializerNodeType reason)
{
//
// Use same settings for detailed and summary validation as in the parent serializer.
//
bool detailedValidationResultsEnabled = this.m_parentSession.DetailedValidationResults;
bool detailedSummaryValidationResultsEnabled = this.m_parentSession.SummaryValidationResults;
//
// Create a output writer based on the same targetname as the parent serializer.
//
this.m_serializationWriter =
new SerializationWriter(
this.m_targetFileName,
this.m_bIsTopSerializer,
(uint)indexOfChildInParentCollection,
detailedValidationResultsEnabled,
detailedSummaryValidationResultsEnabled);
//
// TODO: Determine specific processing tasks for Thread and DirectoryRecord child-nodes.
//
switch (reason)
{
case Wrappers.WrappedSerializerNodeType.Thread:
break;
case Wrappers.WrappedSerializerNodeType.DirectoryRecord:
break;
case Wrappers.WrappedSerializerNodeType.TopParent:
break;
default:
// Unknown WrappedSerializerNodeType
throw new System.NotImplementedException();
}
//
// Start the serializer
//
this.m_serializationWriter.WriteStartDocument();
this.m_serializationWriter.WriteStartElement();
this.m_SerializationStatus = SerializationStatus.Running;
}
