public ClassCodeElement Build () { classCodeElement = new ClassCodeElement (targetClassName); classCodeElement.Summary.Add ("Convenience class to access Animator states and parameters."); classCodeElement.Summary.Add ("Edits will be lost when this class is regenerated. "); classCodeElement.Summary.Add ("Hint: Editing might be useful after renaming animator items in complex projects:"); classCodeElement.Summary.Add (" - Right click on an obsolete member and select Refactor/Rename. "); classCodeElement.Summary.Add (" - Change it to the new name. "); classCodeElement.Summary.Add (" - Delete this member to avoid comile error CS0102 ... already contains a definition ...''. "); string versionString = "" + DateTime.Now; classCodeElement.AddAttribute (new GeneratedClassAttributeCodeElement (versionString)); if (!string.IsNullOrEmpty (config.DefaultNamespace)) { classCodeElement.NameSpace = new NameSpaceCodeElement (config.DefaultNamespace); } ProcessInternalFields (); if (config.GenerateMonoBehaviourComponent) { classCodeElement.SetBaseClass (config.MonoBehaviourComponentBaseClass); AwakeMethod = PrepareAwakeMethod (); } else { AwakeMethod = PrepareConstructors (); } EventManagerInitialiser = PrepareEventManagerInitialiserMethod (); ProcessAnimatorStates (); ProcessAnimatorParameters (); ProcessStateEventHandling (); return classCodeElement; }
public ClassCodeElement Build() { ClassCodeElement classCodeElement = new ClassCodeElement(className); if (!HasType()) { return(classCodeElement); } Type type = obj.GetType(); classCodeElement.NameSpace.Name = type.Namespace; CodeElementUtils.AddAttributes(classCodeElement.Attributes, type.GetCustomAttributes(false)); PropertyInfo[] propertyInfoArray = type.GetProperties(propertiesBinding); List <PropertyInfo> propertyInfos = GetFilteredList(propertyInfoArray, propertyInfoFilter); CodeElementUtils.AddPropertyInfos(classCodeElement.Properties, propertyInfos); MethodInfo[] methodInfoArray = type.GetMethods(methodBinding); List <MethodInfo> methodInfos = GetFilteredList(methodInfoArray, methodInfoFilter); CodeElementUtils.AddMethodInfos(classCodeElement.Methods, methodInfos); FieldInfo[] fieldInfoArray = type.GetFields(fieldBinding); List <FieldInfo> fieldInfos = GetFilteredList(fieldInfoArray, fieldInfoFilter); CodeElementUtils.AddFieldInfos(classCodeElement.Fields, fieldInfos); return(classCodeElement); }
public static int CleanupExistingClass(ClassCodeElement existingClass, ClassCodeElement newClass, bool keepObsolete) { int remaining = RemoveDuplicateElements(existingClass.Properties, newClass.Properties, keepObsolete); remaining += RemoveDuplicateElements(existingClass.Fields, newClass.Fields, keepObsolete); remaining += RemoveDuplicateElements(existingClass.Methods, newClass.Methods, keepObsolete); return(remaining); }
public static List <ClassMemberCompareElement> CompareClasses(ClassCodeElement existingClass, ClassCodeElement newClass, bool removeOldMembers, bool keepObsolete) { List <ClassMemberCompareElement> l = CompareElements(existingClass.Fields, newClass.Fields, removeOldMembers, keepObsolete); l.AddRange(CompareElements(existingClass.Properties, newClass.Properties, removeOldMembers, keepObsolete)); l.AddRange(CompareElements(existingClass.Methods, newClass.Methods, removeOldMembers, keepObsolete)); List <MemberCodeElement> allNew = new List <MemberCodeElement> (); newClass.Fields.ForEach((GenericFieldCodeElement element) => allNew.Add(element)); newClass.Properties.ForEach((GenericPropertyCodeElement element) => allNew.Add(element)); newClass.Methods.ForEach((GenericMethodCodeElement element) => allNew.Add(element)); l.ForEach((ClassMemberCompareElement element) => { if (element.result == ClassMemberCompareElement.Result.Obsolete && element is CodeElementBasedCompareElement) { MemberCodeElement underlyingElement = ((CodeElementBasedCompareElement)element).UnderlyingElement; underlyingElement.Obsolete = true; allNew.Add(underlyingElement); } }); int nextToLast = allNew.Count - 2; for (int i = 0; i <= nextToLast; i++) { MemberCodeElement element = allNew [i]; int duplicateIndex = allNew.FindIndex(i + 1, (MemberCodeElement m) => m.Equals(element)); if (duplicateIndex >= 0) { MemberCodeElement duplicate = allNew [duplicateIndex]; Func <MemberCodeElement, string> formatter = (MemberCodeElement m) => { return((m.Obsolete ? "obsolete " : "") + m.MemberType + " " + m.ElementType + " " + m.GetSignature()); }; string message = string.Format("Possible naming conflict between [{0}] and [{1}].", formatter(element), formatter(duplicate)); if (duplicate.Obsolete) { message += " Previous element " + formatter(duplicate) + " will be removed."; } else { message += " Avoid using the same name for an Animator state and a parameter."; } l.Add(new CodeElementBasedCompareElement(element, message)); Logger.Debug(message); } } return(l); }
public FileCodeElement (ClassCodeElement c) { Classes.Add (c); }
/// <summary> /// Merges all those fields of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose fields will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's fields.</param> public void MergeFields(ClassCodeElement other, Predicate <GenericFieldCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericFieldCodeElement> (Fields, other.Fields, filter); }
/// <summary> /// Merges all those properties of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose properties will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's properties.</param> public void MergeProperties(ClassCodeElement other, Predicate <GenericPropertyCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericPropertyCodeElement> (Properties, other.Properties, filter); }
/// <summary> /// Merges all those methods of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose methods will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's methods.</param> public void MergeMethods(ClassCodeElement other, Predicate <GenericMethodCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericMethodCodeElement> (Methods, other.Methods, filter); }
public FileCodeElement(ClassCodeElement c) { Classes.Add(c); }
/// <summary> /// Initialises templateEngine and builds newClass and existingClass. /// </summary> /// <returns>The classes.</returns> CodeGeneratorResult BuildClasses () { TemplateLookup templateLookup = new TemplateLookup (config); CodeGeneratorResult result = templateLookup.GetPathToTemplate (className); if (result.Success) { result = templateEngine.Prepare (templateLookup.TemplateConfig); if (result.NoSuccess) { return result; } newClass = builder.Build (); if (newClass.IsEmpty ()) { return result.SetError ("No Input", "The input seems to be invalid. Check that there are any states or parameter to process."); } Logger.Debug ("New: " + newClass); if (!existingClassBuilder.HasType ()) { Logger.Info ("Generating source for " + className + " the very first time"); } try { existingClassBuilder.MethodBinding = BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.NonPublic; existingClassBuilder.MethodInfoFilter = (MethodInfo mi) => mi.Name.StartsWith ("Is") || mi.Name.StartsWith ("Set") || mi.Name.StartsWith ("Get") || mi.Name == "IdToName" || mi.Name == "Update" || mi.Name == "FixedUpdate"; existingClass = existingClassBuilder.Build (); // little bit dirty hack: we don't want special methods like Update to participate in the regular // workflow i.e. mark as obsolete to be regenerated once with code throwing NotImplementedException. // So if settings have changed, mark them as obsolete to force their removal List<GenericMethodCodeElement> updateMethods = existingClass.Methods.FindAll ( (GenericMethodCodeElement m) => m.Name == "Update" || m.Name == "FixedUpdate"); updateMethods.ForEach ((GenericMethodCodeElement m) => m.Obsolete = true); } catch (System.Exception ex) { Logger.Warning (ex.Message + "\n" + ex.StackTrace); result.SetError ("Error", "Oops. An unexpected error occurred. Details" + ex.Message + "\n" + ex.StackTrace); } } return result; }
/// <summary> /// Merges all those fields of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose fields will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's fields.</param> public void MergeFields (ClassCodeElement other, Predicate<GenericFieldCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericFieldCodeElement> (Fields, other.Fields, filter); }
/// <summary> /// Merges all those properties of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose properties will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's properties.</param> public void MergeProperties (ClassCodeElement other, Predicate<GenericPropertyCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericPropertyCodeElement> (Properties, other.Properties, filter); }
/// <summary> /// Merges all those methods of other class into this one, that meet the filter condition. /// </summary> /// <param name="other">Other class whose methods will be merged into this class.</param> /// <param name="filter">Filter (optional), defines a subset of other's methods.</param> public void MergeMethods (ClassCodeElement other, Predicate<GenericMethodCodeElement> filter = null) { CodeElementUtils.MergeElements <GenericMethodCodeElement> (Methods, other.Methods, filter); }