public EnsembleTopDownClassifier(ClassHierarchy hierarchy)
{
this._hierarchy = hierarchy;
this._modelMapping = new Dictionary <string, List <Tuple <string, IClassifier> > >();
this._metaModel = new Dictionary <string, IClassifier>();
this._classifierNames = new List <string>();
}
public COOPFunctionConverter(ClassHierarchy hierarchy, COOPClass parentClass)
{
classHierarchy = hierarchy;
this.parentClass = parentClass;
originalNameAndInputTypesToMangledName = new Dictionary <NameInputTypePair, string>(NameInputTypePair.nameInputsComparer);
originalNameAndInputTypesToisStatic = new Dictionary <NameInputTypePair, bool>();
functionToReturnType = new Dictionary <string, COOPClass>();
availableClasses = hierarchy.getLineage(parentClass);
availableClasses.AddRange(parentClass.imports);
generateDictionaries();
}
public CallChain(Dictionary <NameInputTypePair, string> originalNameAndInputTypesToMangledName, Dictionary <NameInputTypePair, bool> originalNameAndInputTypesToisStatic, Dictionary <string, COOPClass> functionToReturnType, Dictionary <string, COOPClass> availableClasses, Dictionary <string, COOPClass> variablesToType, Dictionary <string, bool> isClassDict, COOPClass parentClass, ClassHierarchy hierarchy)
{
this.originalNameAndInputTypesToMangledName = originalNameAndInputTypesToMangledName;
this.originalNameAndInputTypesToisStatic = originalNameAndInputTypesToisStatic;
this.functionToReturnType = functionToReturnType;
this.availableClasses = availableClasses;
this.variablesToType = variablesToType;
this.isClassDict = isClassDict;
this.parentClass = parentClass;
this.hierarchy = hierarchy;
}
public void GenerateCH()
{
if (!programInfo.Contains("CH_TEXT"))
{
var ch = new ClassHierarchy();
ch.Analyze(host);
var text = DGMLSerializer.Serialize(ch);
programInfo.Add("CH", ch);
programInfo.Add("CH_TEXT", text);
}
}
/// <summary>
/// Example use of the CodePrinter class: prints the code of all the methods
/// from an application rooted in a specific assembly file.
/// </summary>
/// <param name="args">Root assembly of the analyzed program.</param>
public static void TestMain(string[] args)
{
AssemblyNode an = AssemblyNode.GetAssembly(args[0]);
if (an == null)
{
Console.WriteLine("assembly \"{0}\" not found", args[0]);
Environment.Exit(1);
}
ClassHierarchy ch = new ClassHierarchy(args[0]); //DataStructUtil.singleton(an));
foreach (Method method in ch.AllMethods())
{
CodePrinter.PrintMethod(Console.Out, method);
}
}
private Dataset GetLocalFlatDataset(Node current, Dataset dataset)
{
ClassHierarchy hierarchy = ((Data.HierarchicalAttribute)dataset.Metadata.Target).Hierarchy;
Node[] siblings = hierarchy.GetSiblings(current);
List <string> negativeClassValues = new List <string>();
foreach (Node sibling in siblings)
{
negativeClassValues.Add(sibling.Name);
}
Dataset local = dataset.GetBinaryFlatLabelSubDataset(current.Name, negativeClassValues.ToArray());
return(local);
}
public void Search( ClassComponent cls )
{
if( cls.CodeClass.Children.Count > 0 )
{
ClassHierarchy ch = new ClassHierarchy();
ch.Parent = cls.Name;
foreach( EnvDTE.CodeClass child in cls.CodeClass.Children )
{
ch.Children.Add( child.Name );
}
m_htClassHierchs[ cls.CodeClass ] = ch;
}
foreach( ClassComponent inner in cls.InnerClasses )
{
Search( inner );
}
}
public void Search(ClassComponent cls)
{
if (cls.CodeClass.Children.Count > 0)
{
ClassHierarchy ch = new ClassHierarchy();
ch.Parent = cls.Name;
foreach (EnvDTE.CodeClass child in cls.CodeClass.Children)
{
ch.Children.Add(child.Name);
}
m_htClassHierchs[cls.CodeClass] = ch;
}
foreach (ClassComponent inner in cls.InnerClasses)
{
Search(inner);
}
}
private List <COOPFunction> getAvailableFunctions(COOPClass coopClass, ClassHierarchy hierarchy)
{
List <COOPFunction> output = new List <COOPFunction>(coopClass.Functions.Values);
List <COOPClass> lineageClasses = new List <COOPClass>(hierarchy.getLineage(coopClass));
lineageClasses.Remove(coopClass);
foreach (COOPClass lineageClass in lineageClasses)
{
output.AddRange(from f in lineageClass.Functions.Values where (int)f.AccessLevel >= 1 select f);
}
foreach (COOPClass coopClassImport in coopClass.imports)
{
output.AddRange(from f in coopClassImport.Functions.Values where f.AccessLevel == AccessLevel.Public select f);
}
return(output);
}
public virtual void ParseGroupCode(int groupcode, string value)
{
switch (groupcode)
{
case 0:
EntityType = value;
break;
case 5:
Handle = value;
break;
case 100:
ClassHierarchy.Add(value);
break;
case 67:
IsInPaperSpace = int.Parse(value) == 1;
break;
case 8:
LayerName = value;
break;
case 6:
LineType = value;
break;
case 62:
ColorNumber = int.Parse(value);
break;
case 48:
LineTypeScale = double.Parse(value);
break;
case 60:
IsInvisible = int.Parse(value) == 1;
break;
}
}
static bool ClassIsSubClassOfClass(TestCompilerResults compilerResults, ClassHierarchy hierarchy, String subClassName, String superClassName) {
ITypeDefinition subClassDefinition = compilerResults.FindTypeWithName(subClassName);
ITypeDefinition superClassDefinition = compilerResults.FindTypeWithName(superClassName);
return hierarchy.AllSubClassesOfClass(superClassDefinition).Contains(subClassDefinition);
}
static bool ClassDirectlySubclassesClass(TestCompilerResults compilerResults, ClassHierarchy hierarchy, String subClassName, String superClassName) {
ITypeDefinition subClassDefinition = compilerResults.FindTypeWithName(subClassName);
Assert.AreNotEqual(null, subClassDefinition, "Couldn't find definition for {0}", subClassName);
ITypeDefinition superClassDefinition = compilerResults.FindTypeWithName(superClassName);
Assert.AreNotEqual(null, superClassDefinition, "Couldn't find definition for {0}", superClassName);
return hierarchy.DirectSubClassesOfClass(superClassDefinition).Contains(subClassDefinition);
}
public LocalPerNodeClassifier(ClassHierarchy hierarchy)
: base(hierarchy)
{
}
public LocalClassifier(ClassHierarchy hierarchy)
{
this._hierarchy = hierarchy;
this._modelMapping = new Dictionary <string, IClassifier>();
}
public Model.Hierarchical.IHierarchicalClassifier CreateClassifier()
{
ClassHierarchy hierarchy = ((Data.HierarchicalAttribute) this._trainingSets[0].Metadata.Target).Hierarchy;
LocalPerNodeClassifier localClassifer = new LocalPerNodeClassifier(hierarchy, _ensembleStrategy);
Node current = hierarchy.Root;
Queue <Node> queue = new Queue <Node>();
foreach (Node node in hierarchy.GetNodes(current.Children))
{
queue.Enqueue(node);
}
int counter = 1;
while (queue.Count != 0)
{
current = queue.Dequeue();
if (localClassifer.Contains(current.Name))
{
continue;
}
List <ClassifierInfo> ensemble = CreateEnsemble(current);
if (_ensembleStrategy is EnsembleStrategy.EnsembleStackClassificationStrategy)
{
List <Dataset> localDatasets = new List <Dataset>();
foreach (Dataset trainingSet in this._trainingSets)
{
localDatasets.Add(GetLocalFlatDataset(current, trainingSet));
}
IClassifier metaClassifier = EnsembleStrategy.EnsembleStackClassificationStrategy.CreateMetaClassifier(this._algorithm, localDatasets, ensemble);
ClassifierInfo metaInfo = new ClassifierInfo()
{
Desc = "metaClassifier", Classifier = metaClassifier, Quality = -1
};
ensemble.Add(metaInfo);
}
if (_serialize)
{
IO.Serializer.SerializeEnsmeble(ensemble, current.Name);
localClassifer.PutEnsemble(current.Name, null);
}
else
{
localClassifer.PutEnsemble(current.Name, ensemble);
}
if (_fireEvents)
{
this.onPostNodeProcessing(current, new NodeCounterEventArgs()
{
Counter = counter
});
}
counter++;
if (current.Children != null)
{
foreach (string child in current.Children)
{
if (!queue.Contains(hierarchy[child]))
{
queue.Enqueue(hierarchy[child]);
}
}
}
}
if (_serialize)
{
foreach (Node node in hierarchy.GetDescendants(hierarchy.Root))
{
localClassifer.PutEnsemble(node.Name, IO.Serializer.DeserializeEnsemble(node.Name));
}
}
return(localClassifer);
}
public static void ChapterTwo()
{
#region [ Create types ]
CreateTypes createTypes = new CreateTypes();
//createTypes.StructAndClasses();
//createTypes.Aliens();
//createTypes.MyStackGeneric();
//createTypes.ThisConstructor();
//createTypes.DestoryAlien();
//createTypes.SummaryOfCh1to2_1();
#endregion
#region [ Consume types ]
ConsumeTypes consumeTypes = new ConsumeTypes();
//consumeTypes.BoxingAndUnboxing();
//consumeTypes.ImplicitExplicitOperator();
//consumeTypes.UsingDynamic();
#endregion
#region [ Class hierarchies ]
ClassHierarchy ch = new ClassHierarchy();
//ch.DepositInMyBank(20);
//ch.ComparePricesInMyBank();
#endregion
#region [ Reflection ]
#region [ Attributes, Methods Invoke, Load Assemblies]
RuntimeReflection reflection = new RuntimeReflection();
//reflection.TestConditional();
//reflection.CheckAttribute();
//reflection.CheckCustomAttribute();
//reflection.IdentityMembersInClass();
//reflection.CallMethodUsingReflection();
//reflection.ScanAssembly();
#endregion
#region [ Code DOM , Expression Trees and Reflection ]
#region [ CodeDOM ]
CodeDOMExample cde = new CodeDOMExample();
//cde.GenerateCodDOM();
#endregion
#region [ Expression Trees ]
ExpressionTrees et = new ExpressionTrees();
//et.ExpressionTreeMultiply();
//et.ExpressionTreeModifyToAdd();
//et.IsAdultFemale();
#endregion
#region [ More Reflection ]
Assemblies assemblies = new Assemblies();
//assemblies.DisplayAssemblyInfo();
//assemblies.GetPropertyInfo();
//assemblies.GetMethodInfo();
#endregion
#endregion
#endregion
#region [ Manipulate strings ]
ManipulateStrings manipulateStrings = new ManipulateStrings();
//manipulateStrings.StringInterning();
//manipulateStrings.StringWriter();
//manipulateStrings.StringReader();
//manipulateStrings.SearchStrings();
//manipulateStrings.StringComparisonAndCulture();
//manipulateStrings.FormatString();
//manipulateStrings.FormattableString();
//manipulateStrings.MusicTrackFormatter();
#endregion
}
/// <summary>
/// Example use of the CodePrinter class: prints the code of all the methods
/// from an application rooted in a specific assembly file.
/// </summary>
/// <param name="args">Root assembly of the analyzed program.</param>
public static void TestMain(string[] args) {
AssemblyNode an = AssemblyNode.GetAssembly(args[0]);
if(an == null) {
Console.WriteLine("assembly \"{0}\" not found", args[0]);
Environment.Exit(1);
}
ClassHierarchy ch = new ClassHierarchy(args[0]); //DataStructUtil.singleton(an));
foreach(Method method in ch.AllMethods()) {
CodePrinter.PrintMethod(Console.Out, method);
}
}
public Collection <FunctionConvertedInformation> convert(COOPFunction coopObject, ClassHierarchy hierarchy)
{
AccessLevel accessLevel = coopObject.AccessLevel;
bool isStatic = coopObject.IsStatic;
string signature = generateSignature(coopObject);
string body = coopObject.bodyInC? coopObject.Body : fixBody(coopObject.Body, generateTypeNames(coopObject), coopObject.IsStatic);
FunctionConvertedInformation functionConvertedInformation = new FunctionConvertedInformation
(accessLevel, isStatic, signature, body, coopObject.ReturnType, coopObject.InputTypes);
functionConvertedInformation.OriginalName = coopObject.Name;
return(new Collection <FunctionConvertedInformation> {
functionConvertedInformation
});
}
public Collection <FileConvertedInformation> convert(COOPClass coopObject, ClassHierarchy hierarchy)
{
var output = new Collection <FileConvertedInformation>();
COOPClass parent = hierarchy.getParent(coopObject);
bool createProtected, createPrivate;
string publicStructure = generatePublicStructure(coopObject, parent, out createProtected, out createPrivate);
string cFile = "",
protectedHeader = $"#ifndef SRC_PROTECTED_FILE_{coopObject.Name}\n#define SRC_PROTECTED_FILE_{coopObject.Name}\n",
publicHeader = $"#ifndef SRC_PUBLIC_FILE_{coopObject.Name}\n#define SRC_PUBLIC_FILE_{coopObject.Name}\n";
foreach (COOPClass coopObjectImport in coopObject.imports)
{
cFile += $"#include \"{coopObjectImport.Name}.h\"\n";
}
if (coopObject.Parent != null)
{
cFile += $"#include \"{coopObject.Parent.Name}_protected.h\"\n";
}
cFile += $"#include \"{coopObject.Name}_protected.h\"\n";
if (createPrivate)
{
cFile += generatePrivateStructure(coopObject);
}
protectedHeader += $"#include \"{coopObject.Name}.h\"\n";
if (createProtected)
{
protectedHeader += generateProtectedStructure(coopObject);
}
publicHeader += publicStructure;
COOPFunctionConverter functionConverter = new COOPFunctionConverter(hierarchy, coopObject);
List <FunctionConvertedInformation> functionConvertedInformations = new List <FunctionConvertedInformation>();
foreach (var coopObjectFunction in coopObject.getFunctions())
{
var f = functionConverter.convert(coopObjectFunction);
functionConvertedInformations.AddRange(f);
}
foreach (FunctionConvertedInformation functionConvertedInformation in
from f in functionConvertedInformations where f.accessLevel == AccessLevel.Private select f)
{
cFile += functionConvertedInformation.signature + ";\n";
}
foreach (FunctionConvertedInformation functionConvertedInformation in
from f in functionConvertedInformations where f.accessLevel == AccessLevel.Protected select f)
{
protectedHeader += functionConvertedInformation.signature + ";\n";
}
bool hasMain = false;
string sig = "";
foreach (FunctionConvertedInformation functionConvertedInformation in
from f in functionConvertedInformations where f.accessLevel == AccessLevel.Public select f)
{
publicHeader += functionConvertedInformation.signature + ";\n";
//Console.WriteLine(functionConvertedInformation.signature);
if (functionConvertedInformation.OriginalName == "main")
{
Console.WriteLine("Main Method Found: " + functionConvertedInformation.signature);
hasMain = true;
sig = functionConvertedInformation.signature;
}
}
foreach (FunctionConvertedInformation functionConvertedInformation in functionConvertedInformations)
{
cFile += functionConvertedInformation.signature + "{\n";
cFile += functionConvertedInformation.body;
cFile += "}\n";
}
publicHeader += "#endif";
protectedHeader += "#endif";
if (humanReadable)
{
cFile = toHumanReadable(cFile);
publicHeader = toHumanReadable(publicHeader);
protectedHeader = toHumanReadable(protectedHeader);
}
output.Add(new FileConvertedInformation(coopObject.Name + ".c", cFile));
output.Add(new FileConvertedInformation(coopObject.Name + "_protected.h", protectedHeader));
output.Add(new FileConvertedInformation(coopObject.Name + ".h", publicHeader));
if (hasMain)
{
output[2].hasMainMethod = true;
output[2].mainMethod = sig;
Console.WriteLine("Main Method Confirmed: " + sig);
}
return(output);
}
public LocalPerNodeClassifier(ClassHierarchy hierarchy, EnsembleStrategy.IEnsembleClassificationStrategy ensembleStrategy)
: base(hierarchy, ensembleStrategy)
{
}
public EnsemblePerNodeTopDownClassifier(ClassHierarchy hierarchy)
: base(hierarchy)
{
}
public Collection <FunctionCallConvertedInformation> convert(string functionCall, ClassHierarchy hierarchy)
{
Parser parser = new Parser(functionCall, Parser.ReadOptions.STRING);
ParseTree parseTree = new ParseTree(parser.ParseObject);
if (!parseTree.successfulParse)
{
return(null);
}
string output = fixCall(parseTree.Head);
return(new Collection <FunctionCallConvertedInformation> {
new FunctionCallConvertedInformation(output)
});
}
static void ConstructClassHierarchyForSources(string[] sources, ClassHierarchyResultDelegate resultDelegate) {
// Each source is assumed to refer to all the sources before it
CompileSourcesAndRun(sources, ".dll", compilerResult => {
WholeProgram wholeProgram = new WholeProgram(new IAssembly[] { compilerResult.MainAssembly }, compilerResult.Host);
ClassHierarchy classHierarchy = new ClassHierarchy(wholeProgram.AllDefinedTypes(), compilerResult.Host);
resultDelegate(compilerResult, classHierarchy);
});
}
public LocalClassifier(ClassHierarchy hierarchy, EnsembleStrategy.IEnsembleClassificationStrategy ensembleStrategy)
{
this._hierarchy = hierarchy;
this._modelMapping = new Dictionary <string, List <ClassifierInfo> >();
this._ensembleStrategy = ensembleStrategy;
}
public static EnsemblePerNodeTopDownClassifier CreateEnsembleDSPerNodeTopDownClassifier(List <Data.Dataset> trainingSets, IClassificationAlgorithm algorithm)
{
ClassHierarchy hierarchy = ((Data.HierarchicalAttribute)trainingSets[0].Metadata.Target).Hierarchy;
EnsemblePerNodeTopDownClassifier topDownClassifier = new EnsemblePerNodeTopDownClassifier(hierarchy);
Data.Attribute[] metaAttributes = new Data.Attribute[2];
string[] values = new string[trainingSets.Count];
for (int i = 0; i < metaAttributes.Length; i++)
{
values[i] = trainingSets[i].Metadata.DatasetName;
}
metaAttributes[0] = new Data.Attribute("Dataset", 0, values);
metaAttributes[1] = new Data.Attribute("Prediction", 1, new string[] { "yes", "no" });
Data.Attribute target = new Data.Attribute("class", metaAttributes.Length, new string[] { "yes", "no" });
Metadata meta = new Metadata("metaModel", metaAttributes, target);
Node current = hierarchy.Root;
Queue <Node> queue = new Queue <Node>();
foreach (Node node in hierarchy.GetNodes(current.Children))
{
queue.Enqueue(node);
}
while (queue.Count != 0)
{
current = queue.Dequeue();
Node[] siblings = hierarchy.GetSiblings(current);
List <string> negativeClassValues = new List <string>();
foreach (Node sibling in siblings)
{
negativeClassValues.Add(sibling.Name);
}
Dataset dsLocal = new Dataset(meta.Clone());
int i = 0;
foreach (Dataset trainingSet in trainingSets)
{
Dataset local = trainingSet.GetBinaryFlatLabelSubDataset(current.Name, negativeClassValues.ToArray());
algorithm.TrainingSet = local;
IClassifier classifier = algorithm.CreateClassifier();
topDownClassifier.AddClassifier(current.Name, local.Metadata.DatasetName, classifier);
//Example metaExample=new Example(dsLocal,i,
}
//algorithm.TrainingSet = local;
//IClassifier classifier = algorithm.CreateClassifier();
//topDownClassifier.PutClassifier(current.Name, trainingSet.Metadata.DatasetName, classifier);
//if (current.Children != null)
// foreach (string child in current.Children)
// queue.Enqueue(hierarchy[child]);
}
return(topDownClassifier);
}
