public static object Unstage(StageItem item, Type targetType)
{
if (item is StageNull)
{
return(null);
}
IStager stager = SerializationMaster.GetStager(targetType);
if (stager != null)
{
return(stager.UnstageValue(item, targetType));
}
StageValue stageValue = item as StageValue;
if (stageValue == null)
{
StageElement stageElement = item as StageElement;
if (stageElement == null)
{
throw new SerializationException(string.Concat("Unable to unstage, the element is not supported: ", targetType.Name));
}
return(SerializationMaster.ReflectIn(stageElement));
}
IValueConverter converter = SerializationMaster.GetConverter(targetType);
if (converter == null)
{
throw new SerializationException(string.Concat("Unable to unstage, no converter or stager was found for type: ", targetType.Name));
}
return(converter.FromString(stageValue.@value, targetType));
}
public static StageItem Stage(string name, object value)
{
if (value == null)
{
return(new StageNull(name));
}
Type type = value.GetType();
IPrepareForSerialization prepareForSerialization = value as IPrepareForSerialization;
if (prepareForSerialization != null)
{
prepareForSerialization.Prepare();
}
IStager stager = SerializationMaster.GetStager(type);
if (stager != null)
{
return(stager.StageValue(name, value));
}
IValueConverter converter = SerializationMaster.GetConverter(type);
if (converter == null)
{
return(SerializationMaster.ReflectOut(name, value));
}
return(new StageValue(name, converter.ToString(value), type == SerializationMaster._stringType));
}
public App(IDBAccess dbAccess, IStager stager, IScriptRunner scriptRunner, IMessageBroker messageBroker, IDataValidation dataValidation, ILogger <App> log)
{
Stager = stager;
ScriptRunner = scriptRunner;
DBAccess = dbAccess;
MessageBroker = messageBroker;
DataValidation = dataValidation;
_log = log;
}
private static void PopulateKnownSerializers()
{
object obj;
Type[] typeArray;
int i;
foreach (Type type in ApexReflection.GetRelevantTypes().Where <Type>((Type t) => {
if (!typeof(IValueConverter).IsAssignableFrom(t) && !typeof(IStager).IsAssignableFrom(t) && !typeof(ISerializer).IsAssignableFrom(t) || t.IsAbstract)
{
return(false);
}
return(t.GetConstructor(Type.EmptyTypes) != null);
}))
{
FieldInfo field = type.GetField("instance", BindingFlags.Static | BindingFlags.Public);
obj = (field == null ? Activator.CreateInstance(type) : field.GetValue(null));
IValueConverter valueConverter = obj as IValueConverter;
if (valueConverter != null)
{
if (valueConverter.handledTypes == null)
{
continue;
}
typeArray = valueConverter.handledTypes;
for (i = 0; i < (int)typeArray.Length; i++)
{
Type type1 = typeArray[i];
if (!SerializationMaster._typeConverters.ContainsKey(type1) || type.IsDefined <SerializationOverrideAttribute>(false))
{
SerializationMaster._typeConverters[type1] = valueConverter;
}
}
}
else if (!(obj is ISerializer) || SerializationMaster._serializer != null && !type.IsDefined <SerializationOverrideAttribute>(false))
{
IStager stager = obj as IStager;
if (stager.handledTypes == null)
{
continue;
}
typeArray = stager.handledTypes;
for (i = 0; i < (int)typeArray.Length; i++)
{
Type type2 = typeArray[i];
if (!SerializationMaster._typeStagers.ContainsKey(type2) || type.IsDefined <SerializationOverrideAttribute>(false))
{
SerializationMaster._typeStagers[type2] = stager;
}
}
}
else
{
SerializationMaster._serializer = (ISerializer)obj;
}
}
}
private static IStager GetStager(Type forType)
{
SerializationMaster.EnsureInit();
if (forType.IsGenericType)
{
forType = forType.GetGenericTypeDefinition();
}
else if (forType.IsArray)
{
forType = typeof(Array);
}
IStager stager = null;
SerializationMaster._typeStagers.TryGetValue(forType, out stager);
return(stager);
}
private static IStager GetStager(Type forType)
{
EnsureInit();
if (forType.IsGenericType)
{
forType = forType.GetGenericTypeDefinition();
}
else if (forType.IsArray)
{
forType = typeof(Array);
}
IStager result = null;
_typeStagers.TryGetValue(forType, out result);
return(result);
}
