protected internal bool GenerateConfigurationsInterfaces(specialsGeneratorProgressHandler progressHandler)
{
ExtClass baseConfigInterface = this.addBaseInterface(
SpecialsGenerator.BASE_CONFIGS_INTERFACE_NAME,
"Base configurations interface.",
ClassType.CLASS_CONFIGS
);
this.addBaseIndexer(ref baseConfigInterface);
int processedClassesCount = 0;
ExtClass configClass;
Store store = this.processor.Store;
ExtClass extBaseClass = store.GetByFullName("Ext.Base");
if (extBaseClass == null)
{
throw new Exception("Class `Ext.Base` not found!");
}
foreach (ExtClass standardClass in store.ExtStandardClasses)
{
if (standardClass.Members.Configations.Count > 0)
{
configClass = new ExtClass(
standardClass.Name.FullName + SpecialsGenerator.CONFIGS_NAME_ADDITION,
SpecialsGenerator.BASE_CONFIGS_INTERFACE_NAME,
standardClass.Docs
);
configClass.Package = standardClass.Package;
//configClass.SrcJson = standardClass.SrcJson;
configClass.Name.PackagedNamespace = standardClass.Name.PackagedNamespace;
configClass.ClassType = ClassType.CLASS_CONFIGS;
configClass.Link = new string[] {
standardClass.Name.FullName,
this.processor.Reader.GetLinkHrefForClass(
standardClass.Name.FullName
)
};
foreach (var confMemberItem in standardClass.Members.Configations)
{
configClass.Members.Configations.Add(
confMemberItem.Key,
(confMemberItem.Value as Configuration).Clone()
);
}
// Add only template methods:
this.generateConfigurationsInterfacesTemplateMethods(
standardClass, ref configClass
);
// Add only instance methods from Ext.Base:
this.generateConfigurationsInterfacesExtBaseMethods(
standardClass, extBaseClass, ref configClass
);
configClass.HasMembers = true;
store.AddExtClass(configClass);
}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, standardClass.Name.FullName);
}
return(true);
}
protected internal bool GenerateStandardClassesInheritanceCompatibleMembers(specialsGeneratorProgressHandler progressHandler)
{
int processedClassesCount = 0;
int[] parentsCountsKeys = this.processor.Store.ExtClassesParentsCounts.Keys.ToArray <int>();
int parentsCountsKey;
Dictionary <int, Dictionary <string, int> > parentsCountsRecords;
int[] moduleNameComplexityKeys;
int moduleNameComplexityKey;
Dictionary <string, int> parentsCountsRecord;
string[] classNames;
string className;
int classIndex;
ExtClass extClass;
InheritanceResolver resolver = new InheritanceResolver(this.processor);
for (int i = 0; i < parentsCountsKeys.Length; i++)
{
parentsCountsKey = parentsCountsKeys[i];
parentsCountsRecords = this.processor.Store.ExtClassesParentsCounts[parentsCountsKey];
moduleNameComplexityKeys = parentsCountsRecords.Keys.ToArray <int>();
for (int j = 0; j < moduleNameComplexityKeys.Length; j++)
{
moduleNameComplexityKey = moduleNameComplexityKeys[j];
parentsCountsRecord = parentsCountsRecords[moduleNameComplexityKey];
classNames = parentsCountsRecord.Keys.ToArray <string>();
for (int k = 0; k < classNames.Length; k++)
{
className = classNames[k];
classIndex = parentsCountsRecord[className];
extClass = this.processor.Store.ExtAllClasses[classIndex];
if (
extClass.ClassType == ClassType.CLASS_STANDARD || (
extClass.ClassType == ClassType.CLASS_METHOD_PARAM_CONF_OBJ &&
extClass.Extends != null &&
extClass.Extends.FullName != SpecialsGenerator.BASE_PARAMS_INTERFACE_NAME
)
)
{
// Only standard classes and method config object params classes extended
// from something higher than base config interface are resolved here:
resolver.Resolve(ref extClass);
}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, extClass.Name.FullName);
}
}
}
return(true);
}
protected internal bool GenerateDefinitionsClasses(specialsGeneratorProgressHandler progressHandler)
{
int processedClassesCount = 0;
ExtClass definitionsClass;
Store store = this.processor.Store;
ExtClass extClassCfg = store.GetByFullName("Ext.Class" + SpecialsGenerator.CONFIGS_NAME_ADDITION);
if (extClassCfg == null)
{
throw new Exception("Configuration interface for `Ext.Class` not found!");
}
List <Configuration> extClassConfigs = (
from item in extClassCfg.Members.Configations
orderby item.Key ascending
select item.Value as Configuration
).ToList <Configuration>();
foreach (ExtClass standardClass in this.processor.Store.ExtStandardClasses)
{
if (!standardClass.Singleton /* && !standardClass.Private*/)
{
definitionsClass = new ExtClass(
standardClass.Name.FullName + SpecialsGenerator.DEFINITIONS_NAME_ADDITION,
standardClass.Name.FullName,
standardClass.Docs
);
definitionsClass.Package = standardClass.Package;
//definitionsClass.SrcJson = standardClass.SrcJson;
definitionsClass.Name.PackagedNamespace = standardClass.Name.PackagedNamespace;
definitionsClass.ClassType = ClassType.CLASS_DEFINITIONS;
definitionsClass.Link = new string[] {
standardClass.Name.FullName,
this.processor.Reader.GetLinkHrefForClass(
standardClass.Name.FullName
)
};
// Add all configuration elements as public instance properties:
this.generateDefinitionsClassesAddDefsClassConfigItems(
extClassConfigs, standardClass, ref definitionsClass
);
definitionsClass.HasMembers = true;
store.AddExtClass(definitionsClass);
}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, standardClass.Name.FullName);
}
return(true);
}
protected internal bool GenerateEventsInterfaces(specialsGeneratorProgressHandler progressHandler)
{
this.generateEventsInterfacesBases();
int processedClassesCount = 0;
ExtClass eventClass;
List <Member> eventMemberVariants;
foreach (ExtClass standardClass in this.processor.Store.ExtStandardClasses)
{
if (standardClass.Members.Events.Count > 0 /* && !standardClass.Private*/)
{
eventClass = new ExtClass(
standardClass.Name.FullName + SpecialsGenerator.EVENTS_NAME_ADDITION,
SpecialsGenerator.BASE_EVENTS_INTERFACE_NAME,
standardClass.Docs
);
eventClass.Package = standardClass.Package;
//eventClass.SrcJson = standardClass.SrcJson;
eventClass.Name.PackagedNamespace = standardClass.Name.PackagedNamespace;
eventClass.ClassType = ClassType.CLASS_EVENTS;
eventClass.Link = new string[] {
standardClass.Name.FullName,
this.processor.Reader.GetLinkHrefForClass(
standardClass.Name.FullName
)
};
foreach (var eventMemberItem in standardClass.Members.Events)
{
eventMemberVariants = new List <Member>();
foreach (var eventVariant in eventMemberItem.Value)
{
eventMemberVariants.Add((eventVariant as Event).Clone());
}
eventClass.Members.Events.Add(
eventMemberItem.Key,
eventMemberVariants
);
eventClass.HasMembers = true;
}
this.processor.Store.AddExtClass(eventClass);
}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, standardClass.Name.FullName);
}
return(true);
}
protected internal bool GenerateStaticsInterfaces(specialsGeneratorProgressHandler progressHandler)
{
ExtClass baseStaticsInterface = this.addBaseInterface(
SpecialsGenerator.BASE_STATICS_INTERFACE_NAME,
"Base static members interface.",
ClassType.CLASS_STATICS
);
this.addBaseIndexer(ref baseStaticsInterface);
int processedClassesCount = 0;
ExtClass staticsClass;
List <Member> methodMemberVariants;
Property prop;
Method methodVariant;
foreach (ExtClass standardClass in this.processor.Store.ExtStandardClasses)
{
/*if (
* standardClass.Members.MethodsStatic.Count > 0 ||
* standardClass.Members.PropertiesStatic.Count > 0
* ) {*/
staticsClass = new ExtClass(
standardClass.Name.FullName + SpecialsGenerator.STATICS_NAME_ADDITION,
SpecialsGenerator.BASE_STATICS_INTERFACE_NAME,
standardClass.Docs
);
staticsClass.Package = standardClass.Package;
//staticsClass.SrcJson = standardClass.SrcJson;
staticsClass.Name.PackagedNamespace = standardClass.Name.PackagedNamespace;
staticsClass.ClassType = ClassType.CLASS_STATICS;
staticsClass.Link = new string[] {
standardClass.Name.FullName,
this.processor.Reader.GetLinkHrefForClass(
standardClass.Name.FullName
)
};
Property propClone;
foreach (var propMemberItem in standardClass.Members.PropertiesStatic)
{
prop = propMemberItem.Value as Property;
if (prop.Renderable)
{
propClone = prop.Clone();
propClone.OwnedByCurrent = true; // always render js docs for statics interfaces, there is no inheritance
staticsClass.Members.PropertiesStatic.Add(
propMemberItem.Key,
propClone
);
}
}
Method methodVariantClone;
foreach (var methodMemberItem in standardClass.Members.MethodsStatic)
{
methodMemberVariants = new List <Member>();
foreach (Member methodMember in methodMemberItem.Value)
{
methodVariant = methodMember as Method;
if (methodVariant.Renderable)
{
methodVariantClone = methodVariant.Clone();
methodVariantClone.OwnedByCurrent = true; // always render js docs for statics interfaces, there is no inheritance
methodMemberVariants.Add(methodVariantClone);
}
}
if (methodMemberVariants.Count > 0)
{
staticsClass.Members.MethodsStatic.Add(
methodMemberItem.Key,
methodMemberVariants
);
}
}
/*if (
* staticsClass.Members.PropertiesStatic.Count > 0 ||
* staticsClass.Members.MethodsStatic.Count > 0
* ) { */
staticsClass.HasMembers = true;
this.processor.Store.AddExtClass(staticsClass);
//}
//}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, standardClass.Name.FullName);
}
return(true);
}
