//------------------------------------------------------------------------------
SettingInfo ProcessArbitraryDynamicSetting(SettingInfo inSettingInfo, SettingsEnumerationMode mode,
ref SettingsHelperData settingHelperData)
{
var fh = GetFunctionalityHook();
var settingsObjectInfo = new SettingsObjectInfo();
settingsObjectInfo.ForegroundSerializer = this.Context.GetSettingsForegroundSerializer();
settingsObjectInfo.SettingAttributeType = typeof(ATTRIBUTE);
settingsObjectInfo.Settings = this.Context;
if (mode == SettingsEnumerationMode.Save)
{
inSettingInfo.SettingValue = DynamicSettingTypeCorrector.MakeDynamicSetting(inSettingInfo);
}
SettingInfo outSettingInfo;
var processStatus = SettingsHelper.ProcessSetting(settingsObjectInfo, inSettingInfo, mode, settingHelperData, out outSettingInfo, fh);
if (processStatus)
{
return(outSettingInfo);
}
return(null);
}
//------------------------------------------------------------------------------
static void ProcessClass(object settings, SettingsEnumerationMode mode)
{
lock (s_lockObject)
{
InitializeSettings();
var members = settings.GetType().GetTypeInfo().DeclaredMembers;
var settingsHelperData = new SettingsHelperData()
{
SerializersCache = new Dictionary <Type, KeyValuePair <ISettingsSerializer, bool /*skip external serializer*/> >(),
SerializersToSync = new OrderedSet <ISettingsSerializer>(),
};
var serializersInClass = GetSerializersInClass(settings, ref settingsHelperData.SerializersCache);
foreach (var serializerInClass in serializersInClass)
{
DoSerializerInitialization(serializerInClass);
}
foreach (var serializerInClass in serializersInClass)
{
DoSerializerStartAction(serializerInClass, mode);
}
var settingsObjectInfo = new SettingsObjectInfo();
var inSettingInfo = new SettingInfo();
foreach (var member in members)
{
settingsObjectInfo.Settings = settings;
settingsObjectInfo.ForegroundSerializer = GetForegroundSerializer();
settingsObjectInfo.MemberInfo = member;
SettingInfo outSettingInfo;
SettingsHelper.ProcessSetting(settingsObjectInfo,
inSettingInfo,
mode,
settingsHelperData,
out outSettingInfo,
null);
}
SettingsHelper.SynchronizeSerializers(settingsHelperData.SerializersToSync);
foreach (var serializerInClass in serializersInClass)
{
DoSerializerEndAction(serializerInClass, mode);
}
}
}
//------------------------------------------------------------------------------
public static ISettingsSerializer GetSerializerForSettingAttributeType(object settings, ISettingsSerializer foregroundSerializer,
Type settingAttributeType,
ref Dictionary <Type, KeyValuePair <ISettingsSerializer, bool> > serializersCache)
{
SettingsObjectInfo soi = new SettingsObjectInfo()
{
Settings = settings,
SettingAttributeType = settingAttributeType,
ForegroundSerializer = foregroundSerializer
};
return(GetSerializerForMember(soi, ref serializersCache));
}
//------------------------------------------------------------------------------
static void ProcessExpression <T>(object settings, Expression <Func <ST, T> > value, SettingsEnumerationMode mode)
{
lock (s_lockObject)
{
InitializeSettings();
MemberExpression me = value.Body as MemberExpression;
if (me != null)
{
var settingsHelperData = new SettingsHelperData()
{
SerializersCache = new Dictionary <Type, KeyValuePair <ISettingsSerializer, bool /*skip external serializer*/> >(),
SerializersToSync = new OrderedSet <ISettingsSerializer>(),
};
var serializer = SettingsHelper.GetSerializerForMemberInfo(settings, GetForegroundSerializer(), me.Member, ref settingsHelperData.SerializersCache);
DoSerializerInitialization(serializer);
DoSerializerStartAction(serializer, mode);
var inSettingInfo = new SettingInfo();
var settingsObjectInfo = new SettingsObjectInfo()
{
Settings = settings,
ForegroundSerializer = GetForegroundSerializer(),
MemberInfo = me.Member,
};
SettingInfo outSettingInfo;
SettingsHelper.ProcessSetting(settingsObjectInfo,
inSettingInfo,
mode,
settingsHelperData,
out outSettingInfo,
null);
SettingsHelper.SynchronizeSerializers(settingsHelperData.SerializersToSync);
DoSerializerEndAction(serializer, mode);
}
}
}
//------------------------------------------------------------------------------
public static bool ProcessSetting(SettingsObjectInfo settingsObjectInfo,
SettingInfo inSettingInfo,
SettingsEnumerationMode mode,
SettingsHelperData settingsHelperData,
out SettingInfo outSettingInfo,
FunctionalityHook functionalityHook)
{
bool processStatus = false;
outSettingInfo = new SettingInfo();
SettingBaseAttribute settingBaseAttribute = null;
if (settingsObjectInfo.MemberInfo != null)
{
settingBaseAttribute = settingsObjectInfo.MemberInfo.GetCustomAttribute <SettingBaseAttribute>();
if (settingBaseAttribute == null)
{
return(false);
}
}
ISettingsSerializer serializer = null;
if (settingsObjectInfo.MemberInfo != null)
{
serializer = GetSerializerForMemberInfo(settingsObjectInfo.Settings,
settingsObjectInfo.ForegroundSerializer,
settingsObjectInfo.MemberInfo,
ref settingsHelperData.SerializersCache);
}
else
{
serializer = GetSerializerForSettingAttributeType(settingsObjectInfo.Settings,
settingsObjectInfo.ForegroundSerializer,
settingsObjectInfo.SettingAttributeType,
ref settingsHelperData.SerializersCache);
}
Debug.Assert(serializer != null);
if (settingsObjectInfo.MemberInfo != null)
{
inSettingInfo.SettingName = SettingNameFormatInfo.GetFullSettingName(settingsObjectInfo.Settings.GetType(),
settingsObjectInfo.MemberInfo,
settingBaseAttribute,
serializer as ISettingsSerializerWishes,
SettingNameMode.Static);
}
if (settingsObjectInfo.MemberInfo != null)
{
var settingValueType = SettingsSerializer.GetSettingType(settingsObjectInfo.MemberInfo);
inSettingInfo.SettingValueType = settingValueType;
inSettingInfo.SettingValue = SettingsSerializer.GetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings);
}
bool secure = false;
var settingSecureAttr = settingBaseAttribute as SettingAttribute;
if (settingSecureAttr != null)
{
secure = settingSecureAttr.Secure;
}
switch (mode)
{
case SettingsEnumerationMode.Load:
{
Wrapper defaultValueWrapper = null;
if (settingBaseAttribute != null && settingBaseAttribute.DefaultValueInUse)
{
var defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
defaultValueWrapper = new Wrapper()
{
Value = defaultValue
};
}
processStatus = SettingsSerializer.Load(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
defaultValueWrapper,
inSettingInfo.SettingValueType,
ref outSettingInfo,
functionalityHook);
// outSettingInfo.SettingValue type was corrected
// in the SettingsSerializer.Load method
if (processStatus && settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings, outSettingInfo.SettingValue);
}
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Load,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.Save:
{
if (settingsObjectInfo.MemberInfo != null)
{
inSettingInfo.SettingValue = SettingsSerializer.GetSettingValue(settingsObjectInfo.MemberInfo, settingsObjectInfo.Settings);
}
processStatus = SettingsSerializer.Save(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
inSettingInfo.SettingValue,
functionalityHook);
settingsHelperData.SerializersToSync.Add(serializer);
outSettingInfo = inSettingInfo;
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Save,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.Delete:
{
processStatus = SettingsSerializer.Delete(serializer,
settingBaseAttribute,
inSettingInfo.SettingName, secure,
functionalityHook);
settingsHelperData.SerializersToSync.Add(serializer);
object defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
outSettingInfo.SettingName = inSettingInfo.SettingName;
outSettingInfo.SettingValue = defaultValue;
outSettingInfo.SettingDefaultValue = defaultValue;
outSettingInfo.SettingValueType = inSettingInfo.SettingValueType;
if (processStatus && settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo,
settingsObjectInfo.Settings,
defaultValue);
}
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.Delete,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
case SettingsEnumerationMode.LoadDefaults:
{
Debug.Assert(inSettingInfo.SettingValueType != null);
var defaultValue = SettingsSerializer.GetDefaultValue(settingBaseAttribute, inSettingInfo.SettingValueType);
if (settingsObjectInfo.MemberInfo != null)
{
SettingsSerializer.SetSettingValue(settingsObjectInfo.MemberInfo,
settingsObjectInfo.Settings,
defaultValue);
}
outSettingInfo.SettingName = inSettingInfo.SettingName;
outSettingInfo.SettingValue = defaultValue;
outSettingInfo.SettingDefaultValue = defaultValue;
outSettingInfo.SettingValueType = inSettingInfo.SettingValueType;
processStatus = true;
#if __TDD__
SettingsBaseConfiguration.TDDData.SerializerAction(serializer.GetType(),
TDDData.SerializerActions.LoadDefaults,
inSettingInfo.SettingName,
secure);
#endif // __TDD__
break;
}
default:
Debug.Assert(false);
throw new NotImplementedException(String.Format("Not implemented for '{0}' mode", mode));
}
return(processStatus);
}
//------------------------------------------------------------------------------
static ISettingsSerializer GetSerializerForMember(SettingsObjectInfo settingsObjectInfo,
ref Dictionary <Type, KeyValuePair <ISettingsSerializer, bool> > serializersCache)
{
if (settingsObjectInfo.SettingAttributeType == null)
{
if (settingsObjectInfo.MemberInfo == null)
{
throw new ArgumentNullException(nameof(settingsObjectInfo.MemberInfo));
}
SettingBaseAttribute settingBaseAttr = settingsObjectInfo.MemberInfo.GetCustomAttribute <SettingBaseAttribute>();
if (settingBaseAttr == null)
{
return(null);
}
settingsObjectInfo.SettingAttributeType = settingBaseAttr.GetType();
}
ISettingsSerializer serializer = settingsObjectInfo.ForegroundSerializer;
bool skipExternalSerializer = false;
ISettingsSerializer attributeSerializer = null;
// try to get setting attribute corresponding serializer
if (serializer == null)
{
var serializerInfo = GetSerializerInfoDependFromSettingAttributeType(settingsObjectInfo.Settings, settingsObjectInfo.SettingAttributeType, ref serializersCache);
attributeSerializer = serializerInfo.Key;
skipExternalSerializer = serializerInfo.Value;
}
if (settingsObjectInfo.MemberInfo != null)
{
// try to get setting (field) serializer
if (serializer == null && !skipExternalSerializer)
{
SerializerAttribute serializerAttr = settingsObjectInfo.MemberInfo.GetCustomAttribute <SerializerAttribute>();
MethodSerializerAttribute methodSerializerAttrForField = settingsObjectInfo.MemberInfo.GetCustomAttribute <MethodSerializerAttribute>();
if (methodSerializerAttrForField != null)
{
serializer = new MethodSerializerForField(methodSerializerAttrForField, settingsObjectInfo.Settings);
}
else if (serializerAttr != null)
{
serializer = GetCustomSerializer(settingsObjectInfo.Settings, serializerAttr.Type, ref serializersCache).Key;
}
}
}
// try to get class serializer
if (serializer == null && !skipExternalSerializer)
{
SerializerAttribute serializerAttr = settingsObjectInfo.Settings.GetType().GetTypeInfo().
GetCustomAttribute <SerializerAttribute>();
MethodSerializerAttribute methodSerializerAttrForClass = settingsObjectInfo.Settings.GetType().GetTypeInfo().
GetCustomAttribute <MethodSerializerAttribute>();
if (methodSerializerAttrForClass != null)
{
serializer = new MethodSerializerForClass(methodSerializerAttrForClass, settingsObjectInfo.Settings);
}
else if (serializerAttr != null)
{
serializer = GetCustomSerializer(settingsObjectInfo.Settings, serializerAttr.Type, ref serializersCache).Key;
}
}
// try to get library serializer
if (serializer == null && !skipExternalSerializer)
{
serializer = SettingsBaseConfiguration.Serializer;
}
// try to get attribute serializer in case if allowed
if (serializer == null && !skipExternalSerializer)
{
serializer = attributeSerializer;
}
return(serializer);
}
