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); }