public virtual ModuleCatalog AddGroup(InitializationMode initializationMode, string refValue, params ModuleInfo[] moduleInfos)
{
if (moduleInfos == null)
{
throw new ArgumentNullException(nameof(moduleInfos));
}
ModuleInfoGroup newGroup = new ModuleInfoGroup();
newGroup.InitializationMode = initializationMode;
newGroup.Ref = refValue;
foreach (ModuleInfo info in moduleInfos)
{
newGroup.Add(info);
}
this.items.Add(newGroup);
return(this);
}
private static IEnumerable <FieldInfo> GetInitialFieldsToRecord(object obj, InitializationMode addMode)
{
switch (addMode)
{
case InitializationMode.NoFields:
return(Enumerable.Empty <FieldInfo>());
case InitializationMode.AllAttributedField:
return(obj
.GetType()
.GetFields()
.Where(field => field.GetCustomAttributes <RecordedFieldAttribute>(false).Any()));
case InitializationMode.AllFields:
return(obj
.GetType()
.GetFields());
default:
throw new ArgumentOutOfRangeException(nameof(addMode), addMode, null);
}
}
public void AddModule(string moduleName,
string moduleType,
string refValue,
InitializationMode initializationMode,
params string[] dependsOn)
{
if (moduleName == null)
{
throw new ArgumentNullException(nameof(moduleName));
}
if (moduleType == null)
{
throw new ArgumentNullException(nameof(moduleType));
}
var moduleInfo = new ModuleInfo(moduleName, moduleType);
moduleInfo.Dependencies.AddRange(dependsOn);
moduleInfo.InitializationMode = initializationMode;
moduleInfo.Ref = refValue;
m_items.Add(moduleInfo);
}
private static ModuleInfo CreateModuleInfo(string name, InitializationMode initializationMode, params string[] dependsOn)
{
ModuleInfo moduleInfo = new ModuleInfo(name, name);
moduleInfo.InitializationMode = initializationMode;
moduleInfo.DependsOn.AddRange(dependsOn);
return moduleInfo;
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo"/> to the catalog.
/// </summary>
/// <param name="moduleName">Name of the module to be added.</param>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog"/> instance with the added module.</returns>
public ModuleCatalog AddModule(string moduleName, string moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
return(this.AddModule(moduleName, moduleType, null, initializationMode, dependsOn));
}
/// <summary>
/// Adds the <see cref="IModule"/>
/// </summary>
/// <typeparam name="T">Type of <see cref="IModule"/></typeparam>
/// <param name="catalog">The <see cref="IModuleCatalog"/> to add the <see cref="IModule"/> to.</param>
/// <param name="mode"></param>
/// <param name="dependsOn">The names of the <see cref="IModule"/>'s that should be loaded when this <see cref="IModule"/> is loaded.</param>
/// <returns>The <see cref="IModuleCatalog"/></returns>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, InitializationMode mode, params string[] dependsOn)
where T : IModule =>
catalog.AddModule <T>(typeof(T).Name, mode, dependsOn);
/// <summary>
/// Adds the module.
/// </summary>
/// <returns>The module.</returns>
/// <param name="catalog">Catalog</param>
/// <param name="mode"><see cref="InitializationMode"/></param>
/// <typeparam name="T">The <see cref="IModule"/> type parameter.</typeparam>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, InitializationMode mode = InitializationMode.WhenAvailable)
where T : IModule =>
catalog.AddModule <T>(typeof(T).Name, mode);
/// <summary>
/// Initializes a new instance of <see cref="ModuleInfo"/>.
/// </summary>
/// <param name="moduleName">The module's name.</param>
/// <param name="moduleType">The module's type.</param>
/// <param name="initializationMode">The module's <see cref="InitializationMode"/>.</param>
public ModuleInfo(string moduleName, Type moduleType, InitializationMode initializationMode) : this(moduleName, moduleType)
{
InitializationMode = initializationMode;
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo" /> to the catalog.
/// </summary>
/// <param name="moduleType"><see cref="Type" /> of the module to be added.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName" />) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog" /> instance with the added module.</returns>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleType" /> is <c>null</c>.</exception>
public ModuleCatalog AddModule(Type moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
Argument.IsNotNull("moduleType", moduleType);
return(AddModule(moduleType.Name, moduleType.AssemblyQualifiedName, initializationMode, dependsOn));
}
public void WriteEventLog(List<string> folderList, InitializationMode myInitMode)
{
try
{
EventLog MyLog = new EventLog(Application.ProductName);
// create a new event log
// Check if the the Event Log Exists
if (!EventLog.SourceExists("TreeGUI"))
{
// Create Log
EventLog.CreateEventSource("TreeGUI", "TreeGUI Log");
}
MyLog.Source = "TreeGUI";
string log = null;
for (int i = 0; i <= folderList.Count - 1; i++)
{
log += "Indexed " + folderList[i] + "\n";
}
switch (myInitMode)
{
case InitializationMode.MANUAL:
log += "\n" + MSG_MANUAL;
break;
case InitializationMode.INTERVAL_BASED_SERVICE:
log += "\n" + getNextScheduledRunTime();
log += "\n" + MSG_INIT_SERVICE;
break;
case InitializationMode.INTERVAL_BASED_GUI:
log += "\n" + getNextScheduledRunTime();
log += "\n" + MSG_INIT_TREEGUI;
break;
case InitializationMode.DATETIME_BASED_SERVICE:
log += "\n" + MSG_DATETIME_BASED;
log += "\n" + MSG_INIT_SERVICE;
break;
case InitializationMode.DATETIME_BASED_GUI:
log += "\n" + MSG_DATETIME_BASED;
log += "\n" + MSG_INIT_TREEGUI;
break;
}
// BUG: 2.2.3.3 Writing Event Log while logged on as Limited caused program crash
EventLog.WriteEntry("TreeGUI Log", log, EventLogEntryType.Information);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
public void AddModule(string moduleName, string moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
AddModule(moduleName, moduleType, null, initializationMode, dependsOn);
}
/// <summary>
/// Initializes a new instance of the <see cref="InitializationApiCopRule" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="description">The description.</param>
/// <param name="level">The level.</param>
/// <param name="recommendedInitializationMode">The recommended initialization mode.</param>
/// <param name="url">The URL.</param>
public InitializationApiCopRule(string name, string description, ApiCopRuleLevel level,
InitializationMode recommendedInitializationMode, string url = null)
: base(name, description, level, url)
{
RecommendedInitializationMode = recommendedInitializationMode;
}
/// <summary>
/// Sets the initialization model. If the value is already set, it won't be updated so it can be used without
/// checking for previous states.
/// </summary>
/// <param name="initializationMode">The initialization mode.</param>
/// <param name="tag">The tag.</param>
public void SetInitializationMode(InitializationMode initializationMode, string tag)
{
var propertyBag = GetPropertyBagForTag(tag);
if (propertyBag.IsPropertyAvailable("ActualInitializationMode"))
{
return;
}
propertyBag.SetPropertyValue("ActualInitializationMode", initializationMode);
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo"/> to the catalog.
/// </summary>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog"/> instance with the added module.</returns>
public ModuleCatalog AddModule(Type moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
if (moduleType == null) throw new System.ArgumentNullException("moduleType");
return this.AddModule(moduleType.Name, moduleType.AssemblyQualifiedName, initializationMode, dependsOn);
}
/// <summary>
/// Initializes a new instance of <see cref="ModuleInfo"/>.
/// </summary>
/// <param name="moduleName">The module's name.</param>
/// <param name="moduleType">The module's type.</param>
/// <param name="initializationMode">The module's <see cref="InitializationMode"/>.</param>
public ModuleInfo(string moduleName, Type moduleType, InitializationMode initializationMode) : this (moduleName, moduleType)
{
InitializationMode = initializationMode;
}
public void ModuleHasSpecifiedInitializationMode(string moduleName, InitializationMode mode)
{
var catalog = new BasicCatalog();
Assert.Single(catalog.Modules, mi => mi.ModuleName == moduleName && mi.InitializationMode == mode);
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo"/> to the catalog.
/// </summary>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog"/> instance with the added module.</returns>
public ModuleCatalog AddModule(Type moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
return(this.AddModule(moduleType.Name, moduleType.AssemblyQualifiedName, initializationMode, dependsOn));
}
/// <summary>
/// Initializes a new instance of the <see cref="InitializationApiCopRule" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="description">The description.</param>
/// <param name="level">The level.</param>
/// <param name="recommendedInitializationMode">The recommended initialization mode.</param>
/// <param name="url">The URL.</param>
public InitializationApiCopRule(string name, string description, ApiCopRuleLevel level,
InitializationMode recommendedInitializationMode, string url = null)
: base(name, description, level, url)
{
RecommendedInitializationMode = recommendedInitializationMode;
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo"/> to the catalog.
/// </summary>
/// <param name="catalog">The catalog to add the module to.</param>
/// <param name="moduleName">Name of the module to be added.</param>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="refValue">Reference to the location of the module to be added assembly.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="IModuleCatalog"/> instance with the added module.</returns>
public static IModuleCatalog AddModule(this IModuleCatalog catalog, string moduleName, string moduleType, string refValue, InitializationMode initializationMode, params string[] dependsOn)
{
if (moduleName == null)
{
throw new ArgumentNullException(nameof(moduleName));
}
if (moduleType == null)
{
throw new ArgumentNullException(nameof(moduleType));
}
ModuleInfo moduleInfo = new ModuleInfo(moduleName, moduleType, dependsOn)
{
InitializationMode = initializationMode,
Ref = refValue
};
return(catalog.AddModule(moduleInfo));
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo" /> to the catalog.
/// </summary>
/// <param name="moduleName">Name of the module to be added.</param>
/// <param name="moduleType"><see cref="Type" /> of the module to be added.</param>
/// <param name="refValue">Reference to the location of the module to be added assembly.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName" />) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog" /> instance with the added module.</returns>
/// <exception cref="System.ArgumentException">The <paramref name="moduleName" /> is <c>null</c> or whitespace.</exception>
/// <exception cref="System.ArgumentException">The <paramref name="moduleType" /> is <c>null</c> or whitespace.</exception>
public ModuleCatalog AddModule(string moduleName, string moduleType, string refValue, InitializationMode initializationMode, params string[] dependsOn)
{
Argument.IsNotNullOrWhitespace("moduleName", moduleName);
Argument.IsNotNullOrWhitespace("moduleType", moduleType);
var moduleInfo = new ModuleInfo(moduleName, moduleType);
moduleInfo.DependsOn.AddRange(dependsOn);
moduleInfo.InitializationMode = initializationMode;
moduleInfo.Ref = refValue;
Items.Add(moduleInfo);
return(this);
}
/// <summary>
/// Adds the module to the <see cref="IModuleCatalog"/>.
/// </summary>
/// <param name="catalog">The catalog to add the module to.</param>
/// <param name="name">Name of the module to be added.</param>
/// <param name="mode">The <see cref="InitializationMode"/> to use.</param>
/// <param name="dependsOn">Collection of module names (<see cref="IModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <typeparam name="T">The <see cref="IModule"/> type parameter.</typeparam>
/// <returns>The same <see cref="IModuleCatalog"/> instance with the added module.</returns>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name, InitializationMode mode = InitializationMode.WhenAvailable, params string[] dependsOn)
where T : IModule
{
return(catalog.AddModule(name, typeof(T).AssemblyQualifiedName, mode, dependsOn));
}
/// <summary>
/// Initializes a new instance of <see cref="ModuleInfo"/>.
/// </summary>
/// <param name="moduleType">The module's type.</param>
/// <param name="moduleName">The module's name.</param>
/// <param name="initializationMode">The module's <see cref="InitializationMode"/>.</param>
public ModuleInfo(Type moduleType, string moduleName, InitializationMode initializationMode)
: this(moduleName, moduleType.AssemblyQualifiedName)
{
InitializationMode = initializationMode;
}
/// <summary>
/// Adds a groupless <see cref="IModuleInfo"/> to the catalog.
/// </summary>
/// <param name="catalog">The catalog to add the module to.</param>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="IModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="IModuleCatalog"/> instance with the added module.</returns>
public static IModuleCatalog AddModule(this IModuleCatalog catalog, Type moduleType, InitializationMode initializationMode, params string[] dependsOn)
{
if (moduleType == null)
{
throw new ArgumentNullException(nameof(moduleType));
}
return(catalog.AddModule(moduleType.Name, moduleType.AssemblyQualifiedName, initializationMode, dependsOn));
}
/// <summary>
/// Adds the module.
/// </summary>
/// <returns>The module.</returns>
/// <param name="catalog">Catalog.</param>
/// <param name="name">Name.</param>
/// <param name="mode"><see cref="IModule"/>.</param>
/// <typeparam name="T">The <see cref="IModule"/> type parameter.</typeparam>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name, InitializationMode mode)
where T : IModule =>
catalog.AddModule(new ModuleInfo(typeof(T), name, mode));
public BigBang(int size)
{
world = new World(size);
initMode = InitializationMode.STANDARD;
CreateCells();
}
/// <summary>
/// Adds the <see cref="IModule"/>
/// </summary>
/// <typeparam name="T">Type of <see cref="IModule"/></typeparam>
/// <param name="catalog">The <see cref="IModuleCatalog"/> to add the <see cref="IModule"/> to.</param>
/// <param name="name">The name of the <see cref="IModule"/></param>
/// <param name="mode">The <see cref="InitializationMode"/></param>
/// <param name="dependsOn">The names of the <see cref="IModule"/>'s that should be loaded when this <see cref="IModule"/> is loaded.</param>
/// <returns>The <see cref="IModuleCatalog"/></returns>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name, InitializationMode mode, params string[] dependsOn)
where T : IModule
{
var moduleInfo = new ModuleInfo(name, typeof(T).AssemblyQualifiedName, dependsOn)
{
InitializationMode = mode
};
return(catalog.AddModule(moduleInfo));
}
public BigBang(int size, InitializationMode initMode)
{
world = new World(size);
this.initMode = initMode;
CreateCells();
}
/// <summary>
/// Adds a groupless <see cref="ModuleInfo"/> to the catalog.
/// </summary>
/// <param name="moduleName">Name of the module to be added.</param>
/// <param name="moduleType"><see cref="Type"/> of the module to be added.</param>
/// <param name="refValue">Reference to the location of the module to be added assembly.</param>
/// <param name="initializationMode">Stage on which the module to be added will be initialized.</param>
/// <param name="dependsOn">Collection of module names (<see cref="ModuleInfo.ModuleName"/>) of the modules on which the module to be added logically depends on.</param>
/// <returns>The same <see cref="ModuleCatalog"/> instance with the added module.</returns>
public ModuleCatalog AddModule(string moduleName, string moduleType, string refValue, InitializationMode initializationMode, params string[] dependsOn)
{
if (moduleName == null)
{
throw new ArgumentNullException("moduleName");
}
if (moduleType == null)
{
throw new ArgumentNullException("moduleType");
}
ModuleInfo moduleInfo = new ModuleInfo(moduleName, moduleType);
moduleInfo.DependsOn.AddRange(dependsOn);
moduleInfo.InitializationMode = initializationMode;
moduleInfo.Ref = refValue;
this.Items.Add(moduleInfo);
return(this);
}
public BigBang(InitializationParams initParams, InitializationMode initMode)
{
world = new World(initParams.worldSize);
this.initMode = initMode;
CreateCells(initParams.cellSpreadModifier);
}
private static ModuleInfo CreateModuleInfo(Type type, InitializationMode initializationMode, params string[] dependsOn)
{
ModuleInfo moduleInfo = new ModuleInfo(type.Name, type.AssemblyQualifiedName);
moduleInfo.InitializationMode = initializationMode;
moduleInfo.DependsOn.AddRange(dependsOn);
return moduleInfo;
}
/// <summary>
/// Initializes a new instance of <see cref="ModuleInfo"/>.
/// </summary>
/// <param name="moduleType">The module's type.</param>
/// <param name="moduleName">The module's name.</param>
/// <param name="initializationMode">The module's <see cref="InitializationMode"/>.</param>
public ModuleInfo(Type moduleType, string moduleName, InitializationMode initializationMode)
{
ModuleType = moduleType;
ModuleName = moduleName;
InitializationMode = initializationMode;
}
