public PluginModule()
{
SubModules.Add(new TriggeringRecordModule());
SubModules.Add(new GenericsModule());
SubModules.Add(new VersioningModule());
SubModules.Add(new RecordTypeConverterModule());
SubModules.Add(new CorrectnessModule());
SubModules.Add(new ModModule());
SubModules.Add(new ColorTypeModule());
SubModules.Add(new LinkModule());
SubModules.Add(new MajorRecordModule());
SubModules.Add(new MajorRecordEnumerationModule());
SubModules.Add(new ContainerParentModule());
SubModules.Add(new MajorRecordFlagModule());
SubModules.Add(new DataTypeModule());
SubModules.Add(new LinkInterfaceModule());
SubModules.Add(new WarmupModule());
SubModules.Add(new MajorRecordRemovalModule());
SubModules.Add(new MajorRecordContextEnumerationModule());
SubModules.Add(new AspectInterfaceModule());
SubModules.Add(new TypeOptionSolidifier());
SubModules.Add(new LinkCacheExtensionsModule());
SubModules.Add(new DuplicateModule());
SubModules.Add(new GameCategoryExtensionsModule());
SubModules.Add(new InterfaceDocumentationModule());
SubModules.Add(new MapsToGetterModule());
SubModules.Add(new GameEnvironmentStateModule());
SubModules.Add(new MajorRecordLinkEqualityModule());
SubModules.Add(new ImplicitsModule());
SubModules.Add(new BreakMarkingModule());
}
public Module AddSubModule(string name, int codeLinesNumber, bool isImportant = true)
{
Module module = new Module(name, codeLinesNumber, isImportant);
module.MainModule = this;
SubModules.Add(module);
return(module);
}
public Module AddSubModule(string name, int codeLinesCount, bool isImportant = true)
{
Module module = new Module(name, codeLinesCount, isImportant);
module.Requirement = this;
SubModules.Add(module);
return(module);
}
// Find community information in each module
public static void FindCommunity(double Alfa, List <List <int> > Modules, double[,] WeightMatrix, List <ComponentStruct> VerticeMatrix, int[,] RelativeMotionMatrix,
out List <List <List <int> > > Communities, out List <double> Modularity, out List <double[, ]> SubGraphs, out List <List <ComponentStruct> > SubVerticeMs, out List <int[, ]> SubRelativeMs)
{
int NumOfModules = Modules.Count;
Communities = new List <List <List <int> > >();
Modularity = new List <double>();
SubGraphs = new List <double[, ]>();
SubVerticeMs = new List <List <ComponentStruct> >();;;
SubRelativeMs = new List <int[, ]>();
double[,] WMIntraModules;
int NumOfIteration = 5;
double CrossOverRatio = 0.4;
double MutationRatio = 0.05;
List <int> NumOfPopulation = new List <int>();
List <int> NumOfGeneration = new List <int>();
List <List <int> > SubModules;
double[] T_BestFitness;
List <int> sublist = new List <int>();
MPCCD.MPCCDSubGraph(Modules, WeightMatrix, VerticeMatrix, RelativeMotionMatrix, out WMIntraModules, out SubGraphs, out SubVerticeMs, out SubRelativeMs);
int x = 0;
for (int i = 0; i < NumOfModules; i++)
{
NumOfPopulation.Add((int)(Modules[x].Count / 2) + 1);
NumOfGeneration.Add(5 * Modules[x].Count);
x++;
}
// find the maximum modularity in each module
for (int i = 0; i < NumOfModules; i++)
{
GAModuleDiv.FindBestSolution_Multiple(SubGraphs[i], NumOfPopulation[i], NumOfGeneration[i], CrossOverRatio, MutationRatio, out SubModules, out T_BestFitness);
double XX = T_BestFitness.Max();
if (T_BestFitness.Max() > Alfa)
{
Communities.Add(SubModules.ToList());
Modularity.Add(T_BestFitness.Max());
}
else
{
SubModules.Clear();
for (int j = 0; j < Modules[i].Count; j++)
{
sublist.Add(j + 1);
}
SubModules.Add(sublist.ToList());
Communities.Add(SubModules);
Modularity.Add(T_BestFitness.Max());
sublist.Clear();
}
}
}
protected override EntityBase CreateAndBuildEntity(DataHelper.Framework.SafeDataReader dr)
{
SubModules theEntity = new SubModules();
theEntity.SUBMODULE_ID = !dr.IsDBNull(0) ? dr.GetValue(0).ToString() : string.Empty;
theEntity.SUBMODULE_NAME = !dr.IsDBNull(1) ? dr.GetValue(1).ToString() : string.Empty;
theEntity.MODULE_ID = !dr.IsDBNull(2) ? dr.GetValue(2).ToString() : string.Empty;
return(theEntity);
}
public string ToTSString()
{
var declarestring = IsDeclared ? " declare " : "export";
var formats = declarestring + " module {0} {{"
+ Settings.EndOfLine
+ "{1}" + Settings.EndOfLine
+ "{2}" + Settings.EndOfLine
+ "{3}" + Settings.EndOfLine
+ "}}"
+ Settings.EndOfLine;
var indentedEOL = Settings.EndOfLine + Settings.Indentation;
var allInterfaces = string.Join(Settings.EndOfLine, Interfaces.Where(i => !Settings.IgnoreInterfaces.Contains(i.InterFaceName)).Select(i => i.ToTSString())).Replace(Settings.EndOfLine, indentedEOL);
var allenums = string.Join(Settings.EndOfLine, Enumerations.Select(e => e.ToTSString())).Replace(Settings.EndOfLine, indentedEOL);
var submods = string.Join(Settings.EndOfLine, SubModules.Select(m => m.ToTSString())).Replace(Settings.EndOfLine, indentedEOL);
return(string.Format(formats, Name, allenums, allInterfaces, submods).Replace(Settings.EndOfLine, indentedEOL));
}
public void AddSubNamespaceType(List <string> ns, Type type)
{
if (ns.Count == 0)
{
var ti = type.GetTypeInfo();
if (ti.IsEnum)
{
if (Settings.ConstEnumsEnabled)
{
var tsconstenum = new TSConstEnumeration(type)
{
IsExported = true
};
Enumerations.Add(tsconstenum);
}
return;
}
var tsinterface = new TSInterface(type, _mapType)
{
IsExported = true
};
Interfaces.Add(tsinterface);
return;
}
var root = ns.First();
var mod = SubModules.FirstOrDefault(m => m.Name == root);
if (mod == null)
{
mod = new TSModule(root, _mapType);
SubModules.Add(mod);
}
ns.RemoveAt(0);
mod.AddSubNamespaceType(ns, type);
}
protected override IDbDataParameter[] CreateSelectParameters(EntityBase anEntity)
{
SubModules theEntity = (SubModules)anEntity;
List <IDbDataParameter> cmdParams = new List <IDbDataParameter>();
if (!string.IsNullOrEmpty(theEntity.SUBMODULE_ID))
{
cmdParams.Add(DataAccessFactory.CreateDataParameter("SUBMODULE_ID", theEntity.SUBMODULE_ID));
}
if (!string.IsNullOrEmpty(theEntity.SUBMODULE_NAME))
{
cmdParams.Add(DataAccessFactory.CreateDataParameter("SUBMODULE_NAME", theEntity.SUBMODULE_NAME));
}
if (!string.IsNullOrEmpty(theEntity.MODULE_ID))
{
cmdParams.Add(DataAccessFactory.CreateDataParameter("MODULE_ID", theEntity.MODULE_ID));
}
cmdParams.Add(DataAccessFactory.CreateDataParameter("Result", ""));
return(cmdParams.ToArray());
}
public Module AddSubModule(Module module)
{
module.MainModule = this;
SubModules.Add(module);
return(module);
}
/// <summary>
/// Writes the module to a stream.
/// </summary>
/// <param name="wr"><see cref="StreamWriter"/> object to write the entity to.</param>
/// <param name="indentOffset">Number of indents to add before any documentation begins.</param>
/// <exception cref="ArgumentNullException"><paramref name="wr"/> is a null reference.</exception>
/// <exception cref="InvalidOperationException">Unable to write the object out in its current state.</exception>
/// <exception cref="IOException">An error occurred while writing to the <see cref="StreamWriter"/> object.</exception>
public void Write(StreamWriter wr, int indentOffset)
{
if (wr == null)
{
throw new ArgumentNullException("wr");
}
if (indentOffset < 0)
{
indentOffset = 0;
}
ValidateChildNames();
// Write the entity.
Entity.Write(wr, indentOffset);
DocumentationHelper.WriteLine(wr);
DocumentationHelper.WriteLine(wr, string.Format("architecture {0} of {1} is", Enum.GetName(typeof(ArchitecturalType), Type), Entity.Name), indentOffset);
DocumentationHelper.WriteLine(wr);
// Functions
BaseTypeInfo.WriteBaseTypeInfos("Functions", wr, Functions.ToArray(), indentOffset, Entity.Name, "module");
if (Functions.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Types and Constants
DeclarationInfo.WriteDeclarations(wr, DeclaredTypes.ToArray(), indentOffset, Entity.Name, "module");
if (DeclaredTypes.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Procedures
BaseTypeInfo.WriteBaseTypeInfos("Procedures", wr, Procedures.ToArray(), indentOffset, Entity.Name, "module");
if (Procedures.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Components
ComponentInfo[] components = SubModule.GetUniqueComponents(SubModule.GetAllSubModules(this), true);
BaseTypeInfo.WriteBaseTypeInfos("Components", wr, components, indentOffset, Entity.Name, "module");
if (components.Length > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Signals
BaseTypeInfo.WriteBaseTypeInfos("Signals", wr, Signals.ToArray(), indentOffset, Entity.Name, "module");
if (Signals.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Aliases
BaseTypeInfo.WriteBaseTypeInfos("Aliases", wr, Aliases.ToArray(), indentOffset, Entity.Name, "module");
if (Aliases.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Attributes
AttributeSpecificationInfo.WriteAttributes(wr, Attributes.ToArray(), indentOffset, Entity.Name, "module");
if (Attributes.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
DocumentationHelper.WriteLine(wr, "begin", indentOffset);
DocumentationHelper.WriteLine(wr);
// Concurrent Statements
foreach (string line in ConcurrentStatements)
{
DocumentationHelper.WriteLine(wr, line, indentOffset);
}
if (ConcurrentStatements.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Processes
BaseTypeInfo.WriteBaseTypeInfos("Processes", wr, Processes.ToArray(), indentOffset, Entity.Name, "module");
if (Processes.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
// Generates
BaseTypeInfo.WriteBaseTypeInfos("Generates", wr, Generates.ToArray(), indentOffset, Entity.Name, "module");
if (Generates.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
BaseTypeInfo.WriteBaseTypeInfos("Sub-Modules", wr, SubModules.ToArray(), indentOffset, Entity.Name, "module");
if (SubModules.Count > 0)
{
DocumentationHelper.WriteLine(wr);
}
StringBuilder sb = new StringBuilder();
sb.Append("end");
if (DefaultValues.AddOptionalTypeNames)
{
sb.Append(" architecture");
}
if (DefaultValues.AddOptionalNames)
{
sb.AppendFormat(" {0}", Enum.GetName(typeof(ArchitecturalType), Type));
}
sb.Append(";");
DocumentationHelper.Write(wr, sb.ToString(), indentOffset);
}
public Module AddSubModule(Module module)
{
module.Requirement = this;
SubModules.Add(module);
return(module);
}
