//------------------------------------------------------------------------------
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);
}
//------------------------------------------------------------------------------
void ProcessDynamicSetting(string settingName, SettingsEnumerationMode mode, bool saveSettingsOrder = false)
{
var settingsHelperData = new SettingsHelperData()
{
SerializersCache = new Dictionary <Type, KeyValuePair <ISettingsSerializer, bool> >(),
SerializersToSync = new OrderedSet <ISettingsSerializer>(),
};
var dynamicSettingInfo = m_dynamicSettings[settingName];
var inSettingInfo = new SettingInfo(settingName, dynamicSettingInfo);
ProcessDynamicSetting(inSettingInfo, mode, ref settingsHelperData);
if (mode == SettingsEnumerationMode.Delete)
{
m_dynamicSettings.Remove(settingName);
}
if (saveSettingsOrder)
{
var serializer = SettingsHelper.GetSerializerDependFromSettingAttributeType(this.Context, typeof(ATTRIBUTE));
var settingsClassType = this.Context.GetType();
SaveDynamicSettingsDefaultOrder(serializer, settingsClassType, ref settingsHelperData);
SaveDynamicSettingsCustomOrder(serializer, settingsClassType, ref settingsHelperData);
}
SettingsHelper.SynchronizeSerializers(settingsHelperData.SerializersToSync);
}
//------------------------------------------------------------------------------
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);
}
}
}
//------------------------------------------------------------------------------
void ProcessDynamicSettings(SettingsEnumerationMode mode, ref SettingsHelperData settingHelperData)
{
if (settingHelperData.SerializersToSync == null)
{
settingHelperData.SerializersToSync = new OrderedSet <ISettingsSerializer>();
}
foreach (var fullSettingName in m_dynamicSettings.GetFullSettingsNamesWithDefaultOrder())
{
var dynamicSettingInfo = m_dynamicSettings[fullSettingName];
var inSettingInfo = new SettingInfo(fullSettingName, dynamicSettingInfo);
ProcessDynamicSetting(inSettingInfo, mode, ref settingHelperData);
}
SettingsHelper.SynchronizeSerializers(settingHelperData.SerializersToSync);
}
//------------------------------------------------------------------------------
bool ProcessDynamicSetting(SettingInfo inSettingInfo, SettingsEnumerationMode mode,
ref SettingsHelperData settingHelperData)
{
var outSettingInfo = ProcessArbitraryDynamicSetting(inSettingInfo, mode, ref settingHelperData);
bool precessStatus = (outSettingInfo != null);
if (precessStatus && mode == SettingsEnumerationMode.Load)
{
m_dynamicSettings[inSettingInfo.SettingName] = new DynamicSettingInfo(outSettingInfo);
}
else if (mode == SettingsEnumerationMode.Load)
{
// remove if processStatus is false
m_dynamicSettings.Remove(inSettingInfo.SettingName);
}
return(precessStatus);
}
//------------------------------------------------------------------------------
static void DoSerializerEndAction(ISettingsSerializer serializer, SettingsEnumerationMode mode)
{
var generalNotificationSink = serializer as ISerializerNotificationSink;
if (generalNotificationSink != null)
{
switch (mode)
{
case SettingsEnumerationMode.Load:
generalNotificationSink.OnEndLoadSettings();
break;
case SettingsEnumerationMode.Save:
generalNotificationSink.OnEndSaveSettings();
break;
case SettingsEnumerationMode.Delete:
generalNotificationSink.OnEndDeleteSettings();
break;
}
generalNotificationSink.OnEndSerializerAction();
}
}
//------------------------------------------------------------------------------
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);
}
