protected internal bool ConsolidateParentsCountsOrder(consolidateProgressHandler progressHandler)
{
this.progressHandler = progressHandler;
// dct key: parents counts, dct value: (dct key: modules parts count, dct value: (dct with class names as keys and class indexes as values))
Dictionary <int, Dictionary <int, Dictionary <string, int> > > orderStore = new Dictionary <int, Dictionary <int, Dictionary <string, int> > >();
ExtClass extClass;
int processedClassesCount = 0;
for (int i = 0; i < this.processor.Store.ExtAllClasses.Count; i++)
{
extClass = this.processor.Store.ExtAllClasses[i];
// check if class is not only the method params function callback class object,
// because those classes are rendered directly, not as types:
if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_METHOD_PARAM_CALLBACK)
{
processedClassesCount += 1;
this.progressHandler.Invoke(processedClassesCount, extClass.Name.FullName);
continue;
}
this.consolidateParentsCountsOrderForClass(
ref orderStore, ref extClass
);
processedClassesCount += 1;
this.progressHandler.Invoke(processedClassesCount, extClass.Name.FullName);
}
this.consolidateParentsCountsOrderSortCollections(
orderStore, processedClassesCount
);
return(true);
}
protected internal bool ConsolidateClassesIntoNsGroups(consolidateProgressHandler progressHandler)
{
this.progressHandler = progressHandler;
int extClassesIndex = 0;
string optimalizedNamespaceName;
bool indexesRecordExist;
Dictionary <string, List <int> > extBaseNsClasses;
List <int> extClassesIndexes;
// Consolidate classes into optimalized package namespaces groups:
ExtClass extClass;
ExtJsPackage package;
for (int i = 0; i < this.processor.Store.ExtAllClasses.Count; i++)
{
//if (i == 160) Debugger.Break();
extClass = this.processor.Store.ExtAllClasses[i];
// Check if class is not only the method params function callback class object,
// because those classes are rendered directly, not as types:
if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_METHOD_PARAM_CALLBACK)
{
extClassesIndex += 1;
this.progressHandler.Invoke(extClassesIndex, extClass.Name.FullName);
continue;
}
package = extClass.Package;
// Consolidate class index into optimalized namespace group:
optimalizedNamespaceName = this.getClassOptimalizedNamespaceName(
extClass, this.processor.Store.ExtBaseNs[package]
);
if (!this.processor.Store.ExtBaseNsClasses.ContainsKey(package))
{
this.processor.Store.ExtBaseNsClasses.Add(package, new Dictionary <string, List <int> >());
}
extBaseNsClasses = this.processor.Store.ExtBaseNsClasses[package];
indexesRecordExist = extBaseNsClasses.ContainsKey(optimalizedNamespaceName);
if (indexesRecordExist)
{
extClassesIndexes = extBaseNsClasses[optimalizedNamespaceName];
}
else
{
extClassesIndexes = new List <int>();
}
extClassesIndexes.Add(extClassesIndex);
if (indexesRecordExist)
{
extBaseNsClasses[optimalizedNamespaceName] = extClassesIndexes;
}
else
{
extBaseNsClasses.Add(optimalizedNamespaceName, extClassesIndexes);
}
//
extClassesIndex += 1;
this.progressHandler.Invoke(extClassesIndex, extClass.Name.FullName);
}
return(true);
}
protected internal bool OptimalizeNamespacesIntoGroups(consolidateProgressHandler progressHandler)
{
this.progressHandler = progressHandler;
int extClassesIndex = 0;
ExtJsPackage package;
Dictionary <ExtJsPackage, List <Dictionary <string, int> > > allPackagesBaseNamespaces = new Dictionary <ExtJsPackage, List <Dictionary <string, int> > >();
List <Dictionary <string, int> > packageBaseNamespaces = new List <Dictionary <string, int> >();
ExtClass extClass;
for (int i = 0; i < this.processor.Store.ExtAllClasses.Count; i++)
{
extClass = this.processor.Store.ExtAllClasses[i];
// Check if class is not only the method params function callback class object,
// because those classes are rendered directly, not as types:
if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_METHOD_PARAM_CALLBACK)
{
extClassesIndex += 1;
this.progressHandler.Invoke(extClassesIndex, extClass.Name.FullName);
continue;
}
package = extClass.Package;
if (!allPackagesBaseNamespaces.ContainsKey(package))
{
allPackagesBaseNamespaces.Add(package, new List <Dictionary <string, int> >());
}
packageBaseNamespaces = allPackagesBaseNamespaces[package];
this.consolidateClassesPackagedNamespaces(extClass, ref packageBaseNamespaces);
extClassesIndex += 1;
this.progressHandler.Invoke(extClassesIndex, extClass.Name.FullName);
}
// Consolidate namespaces with lowest class counts into small packages:
foreach (var item in allPackagesBaseNamespaces)
{
this.processor.Store.ExtBaseNs.Add(
item.Key,
/*this.consolidateClassNamespacesNotOptimalized(
* item.Value
* )*/
this.consolidateClassesPackagedNamespacesOptimalized(
item.Value
)
);
}
return(true);
}
protected internal bool GenerateAlternativeClasses(consolidateProgressHandler progressHandler)
{
// generate empty classes to use classes alternative names:
int extClassesIndex = 0;
ExtClass alternativeAliasClass;
Store store = this.processor.Store;
Reader reader = this.processor.Reader;
foreach (ExtClass extClass in store.ExtStandardClasses)
{
if (extClass.AlternativeNames.Count > 0)
{
foreach (NameInfo altClassNameInfo in extClass.AlternativeNames)
{
alternativeAliasClass = new ExtClass(
altClassNameInfo, extClass.Name
);
alternativeAliasClass.Package = extClass.Package;
//alternativeAliasClass.SrcJson = extClass.SrcJson;
alternativeAliasClass.Name.PackagedNamespace = reader.GetPackagedNamespaceFromFullClassName(
extClass.Name.FullName
);
alternativeAliasClass.ClassType = ClassType.CLASS_ALIAS;
if (store.ExtClassesMap.ContainsKey(
alternativeAliasClass.Name.FullName
))
{
try {
throw new Exception(
"There was not possible to create alias class `"
+ alternativeAliasClass.Name.FullName
+ " ` for class `"
+ extClass.Name.FullName
+ "`. Class with this name already exists."
);
} catch (Exception e) {
this.processor.Exceptions.Add(e);
}
}
else
{
store.AddExtClass(alternativeAliasClass);
}
}
}
extClassesIndex += 1;
progressHandler.Invoke(
extClassesIndex,
extClass.Name.FullName
);
}
// Generate proxy classes for global browser classes like:
// Object, Array, Date, Element, Function, Error, Promise:
foreach (string jsGlobalAlsoInExtNs in JavascriptInternals.JsGlobalsAlsoInExtNamespace)
{
this.generateBrowserGlobalProxyClass(jsGlobalAlsoInExtNs);
}
this.generateBaseMethodParamsAndReturnsInterfaces();
return(true);
}
