public static string BuildDocumentation(Definitions.Description.Message message, int indent) { if (message == null) { return(null); } StringBuilder str = new StringBuilder(); if (!String.IsNullOrWhiteSpace(message.DocumentationId)) { str.AppendHeading(String.Format("{0} {1}{2}:", message.DocumentationId, message.Protocol.Name, (message.IsRefined) ? " (refined)" : "")); str.AppendParagraph(String.Format("<strong>{0}</strong>", MethodHelper.BuildMethodHeader(message.Selector, message))); } string tmp = message.Synopsis.Text; if (!String.IsNullOrWhiteSpace(tmp)) { str.AppendHeading("Synopsys:"); str.AppendParagraph(tmp); } tmp = message.DefinitionDescription.Text; if (!String.IsNullOrWhiteSpace(tmp) || !String.IsNullOrWhiteSpace(message.DefinitionProtocol)) { str.AppendHeading(String.Format("Definition: {0}", message.DefinitionProtocol)); if (!String.IsNullOrWhiteSpace(tmp)) { str.AppendParagraph(tmp); } } foreach (var pair in message.Refinement) { str.AppendHeading(String.Format("Refinement: {0}", pair.Key)); str.AppendParagraph(pair.Value.Text); } foreach (var param in message.Parameters) { str.AppendHeading("Parameter:"); str.AppendParagraph(String.Format("<strong>{0}</strong>: {1} - {2}", param.Name, String.Join(", ", param.Protocols), param.Aliasing)); } if (message.ReturnValue != null) { str.AppendHeading("Return Value:"); str.AppendParagraph(String.Format("{0} - {1}{2} {2}", String.Join(", ", message.ReturnValue.Protocols), message.ReturnValue.Aliasing, (String.IsNullOrWhiteSpace(message.ReturnValue.Description.Text) ? "" : ":"), message.ReturnValue.Description.Text)); } tmp = message.Errors.Text; if (!String.IsNullOrWhiteSpace(tmp)) { str.AppendHeading("Errors:"); str.AppendParagraph(tmp); } //StringBuilder str = new StringBuilder(); //if (!String.IsNullOrWhiteSpace(message.DocumentationId)) //{ // str.Indent(indent); // str.AppendFormat("<p><strong>{0} {1}{2}:</strong></p>", // message.DocumentationId, // message.Protocol.Name, // (message.IsRefined) ? " (refined)" : ""); // str.AppendMultiline(MethodHelper.BuildMethodHeader(message.Selector, message), indent+1); // str.AppendSectionSeparator(); //} //string tmp = message.Synopsis.Text; //if (!String.IsNullOrWhiteSpace(tmp)) //{ // str.Indent(indent); // str.Append("<p><strong>Synopsys:</strong></p>"); // str.AppendMultiline(tmp, indent+1); // str.AppendSectionSeparator(); //} //tmp = message.DefinitionDescription.Text; //if (!String.IsNullOrWhiteSpace(tmp) || !String.IsNullOrWhiteSpace(message.DefinitionProtocol)) //{ // str.Indent(indent); // str.AppendFormat("<p><strong>Definition: {0}</strong></p>", message.DefinitionProtocol); // if (!String.IsNullOrWhiteSpace(tmp)) // str.AppendMultiline(tmp, indent+1); // str.AppendSectionSeparator(); //} //foreach (var pair in message.Refinement) //{ // str.Indent(indent); // str.AppendFormat("<p><strong>Refinement: {0}</strong></p>", pair.Key); // str.AppendMultiline(pair.Value.Text, indent + 1); // str.AppendSectionSeparator(); //} //foreach (var param in message.Parameters) //{ // str.Indent(indent); // str.Append("<p><strong>Parameter:</strong></p>"); // str.AppendMultiline(String.Format("<strong>{0}</strong>: {1} - {2}", // param.Name, String.Join(", ", param.Protocols), param.Aliasing), indent+1); // str.AppendSectionSeparator(); //} //if (message.ReturnValue != null) //{ // str.Indent(indent); // str.Append("<p><strong>Return Value:</strong>"); // str.AppendMultiline(String.Format("{0} - {1}{2} {2}", // String.Join(", ", message.ReturnValue.Protocols), // message.ReturnValue.Aliasing, // (String.IsNullOrWhiteSpace(message.ReturnValue.Description.Text) ? "" : ":"), // message.ReturnValue.Description.Text), indent + 1); // str.AppendSectionSeparator(); //} //tmp = message.Errors.Text; //if (!String.IsNullOrWhiteSpace(tmp)) //{ // str.Indent(indent); // str.Append("<p><strong>Errors:</strong></p>"); // str.AppendMultiline(tmp, indent + 1); // str.AppendSectionSeparator(); //} return(str.ToString()); }
/// <summary> /// Get (or try to get) the first and the best protocol that implements the given message. /// </summary> /// <param name="methodName">Selector of the message to look for.</param> /// <param name="methodType">Type of the method (instance / class) to look for.</param> /// <param name="cls">Class where to start looking for the method.</param> /// <param name="protocolName">Optional protocol that may contain the message.</param> /// <returns>Message definition for the given selector or null if one was not found.</returns> public static Definitions.Description.Message GetMessageForMethod(string methodName, MethodType methodType, Class cls, string protocolName) { if (String.IsNullOrWhiteSpace(methodName)) { throw new ArgumentNullException("methodName"); } if (methodType == null) { throw new ArgumentNullException("methodType"); } if (cls == null) { throw new ArgumentNullException("cls"); } while (cls != null) { Definitions.Description.Message msg = null; var prot = cls.Parent.SmalltalkSystem.SystemDescription.Protocols.FirstOrDefault(p => p.Name == protocolName); if (prot != null) { msg = prot.Messages.FirstOrDefault(m => m.Selector == methodName); } if (msg != null) { return(msg); } List <Class> classesList; List <Class> superclassesList; Dictionary <string, Class> classesMap; Dictionary <string, List <Class> > protocolNameClassesMap; Dictionary <string, List <Class> > protocolNameSuperslassesMap; Dictionary <string, List <Class> > methodNameClassesMap; Dictionary <string, List <Class> > methodNameSuperclassesMap; Dictionary <string, List <string> > methodNameProtocolNamesMap; Dictionary <string, List <string> > allMethodNameProtocolNamesMap; Dictionary <string, Definitions.Description.Protocol> protocolMap; HashSet <string> subclassResponsibilityMethods; Dictionary <string, List <Class> > methodNameLocalImplementorsMap; Dictionary <string, List <Class> > methodNameSuperImplementorsMap; MethodHelper.BuildLists(cls, cls, methodType, out classesList, out superclassesList, out classesMap, out protocolNameClassesMap, out protocolNameSuperslassesMap, out methodNameClassesMap, out methodNameSuperclassesMap, out methodNameProtocolNamesMap, out allMethodNameProtocolNamesMap, out protocolMap, out subclassResponsibilityMethods, out methodNameLocalImplementorsMap, out methodNameSuperImplementorsMap); List <string> pns; methodNameProtocolNamesMap.TryGetValue(methodName, out pns); if ((pns != null) && (pns.Count > 0)) { protocolMap.TryGetValue(pns[0], out prot); if (prot != null) { msg = prot.Messages.FirstOrDefault(m => m.Selector == methodName); } } if (msg != null) { return(msg); } if (String.IsNullOrWhiteSpace(cls.SuperclassName)) { cls = null; } else { cls = cls.Parent.Classes.FirstOrDefault(c => c.Name == cls.SuperclassName); } } return(null); }
/// <summary> /// Build lists of interesting class, protocol and method relations. /// </summary> /// <param name="currentClass">Current class to build lists for.</param> /// <param name="includeUpToClass">Build the list form the <paramref name="currentClass">currentClass</paramref> up-to this class.</param> /// <param name="methodType">Type of methods to include in the lists (instance or class)</param> /// <param name="classesList">List of classes from <paramref name="currentClass">currentClass</paramref> up-to <paramref name="includeUpToClass">includeUpToClass</paramref></param> /// <param name="superclassesList">List of classes from <paramref name="includeUpToClass">includeUpToClass</paramref> (but not included) up-to the root class.</paramref></param> /// <param name="classesMap">Map of class-name to class-object of the classes in <paramref name="classesList">classesList</paramref></param> /// <param name="protocolNameClassesMap">Mep between the protocols involved in <paramref name="classesList">classesList</paramref> and the classes where they are implemented</param> /// <param name="methodNameClassesMap">Map between the methods involved in <paramref name="classesList">classesList</paramref> and the classes where they are implemented</param> /// <param name="methodNameProtocolNamesMap">Map between the methods defined by the protocols involved in <paramref name="classesList">classesList</paramref> and <paramref name="superclassesList">superclassesList</paramref> and the protocol where they are defined</param> /// <param name="protocolMap">>Map of protocol-name to protocol-object of the protocols in <paramref name="protocolNameClassesMap">protocolNameClassesMap</paramref></param> /// <param name="subclassResponsibilityMethods">Collection of methods that are subclass-responsibility (must be implemented in this class)</param> /// <param name="methodNameLocalImplementorsMap">Map of method names and list of local implementors of those relative to <paramref name="currentClass"/>currentClass</paramref>, but excluding the class itself.</param> public static void BuildLists(Class currentClass, Class includeUpToClass, MethodType methodType, out List <Class> classesList, out List <Class> superclassesList, out Dictionary <string, Class> classesMap, out Dictionary <string, List <Class> > protocolNameClassesMap, out Dictionary <string, List <Class> > protocolNameSuperslassesMap, out Dictionary <string, List <Class> > methodNameClassesMap, out Dictionary <string, List <Class> > methodNameSuperclassesMap, out Dictionary <string, List <string> > methodNameProtocolNamesMap, out Dictionary <string, List <string> > allMethodNameProtocolNamesMap, out Dictionary <string, Definitions.Description.Protocol> protocolMap, out HashSet <string> subclassResponsibilityMethods, out Dictionary <string, List <Class> > methodNameLocalImplementorsMap, out Dictionary <string, List <Class> > methodNameSuperImplementorsMap ) { classesList = new List <Class>(); superclassesList = new List <Class>(); classesMap = new Dictionary <string, Class>(); protocolMap = new Dictionary <string, Definitions.Description.Protocol>(); protocolNameClassesMap = new Dictionary <string, List <Class> >(); protocolNameSuperslassesMap = new Dictionary <string, List <Class> >(); methodNameClassesMap = new Dictionary <string, List <Class> >(); methodNameSuperclassesMap = new Dictionary <string, List <Class> >(); methodNameProtocolNamesMap = new Dictionary <string, List <string> >(); allMethodNameProtocolNamesMap = new Dictionary <string, List <string> >(); subclassResponsibilityMethods = new HashSet <string>(); methodNameLocalImplementorsMap = new Dictionary <string, List <Class> >(); methodNameSuperImplementorsMap = new Dictionary <string, List <Class> >(); if (currentClass == null) { return; } if (includeUpToClass == null) { includeUpToClass = currentClass; } // Build a list of classes up to the wanted class ... and map between names and classes List <Class> col = classesList; foreach (Class cls in currentClass.WithAllSuperclasses()) { col.Add(cls); classesMap[cls.Name] = cls; if (cls == includeUpToClass) { col = superclassesList; } } // Build a map between the protocols involved in <classesList> and the classes where they are implemented foreach (Class cls in classesList) { var protocols = (methodType == MethodType.Instance) ? cls.ImplementedInstanceProtocols : cls.ImplementedClassProtocols; foreach (string pn in protocols) { if (!protocolNameClassesMap.ContainsKey(pn)) { protocolNameClassesMap.Add(pn, new List <Class>()); } protocolNameClassesMap[pn].Add(cls); } } // Build a map between the protocols involved in <superclassesList> and the classes where they are implemented foreach (Class cls in superclassesList) { var protocols = (methodType == MethodType.Instance) ? cls.ImplementedInstanceProtocols : cls.ImplementedClassProtocols; foreach (string pn in protocols) { if (!protocolNameSuperslassesMap.ContainsKey(pn)) { protocolNameSuperslassesMap.Add(pn, new List <Class>()); } protocolNameSuperslassesMap[pn].Add(cls); } } // Build a map between the methods involved in <classesList> and the classes where they are implemented foreach (Class cls in classesList) { var mths = (methodType == MethodType.Instance) ? cls.InstanceMethods : cls.ClassMethods; foreach (Method mth in mths) { if (!methodNameClassesMap.ContainsKey(mth.Selector)) { methodNameClassesMap.Add(mth.Selector, new List <Class>()); } methodNameClassesMap[mth.Selector].Add(cls); } } // Build a map between the methods involved in <superclassesList> and the classes where they are implemented foreach (Class cls in superclassesList) { var mths = (methodType == MethodType.Instance) ? cls.InstanceMethods : cls.ClassMethods; foreach (Method mth in mths) { if (!methodNameSuperclassesMap.ContainsKey(mth.Selector)) { methodNameSuperclassesMap.Add(mth.Selector, new List <Class>()); } methodNameSuperclassesMap[mth.Selector].Add(cls); } } // Build a map between the methods defined by the protocols involved in <classesList> and the protocol where they are defined foreach (string pn in protocolNameClassesMap.Keys) { var prot = currentClass.Parent.SmalltalkSystem.SystemDescription.Protocols.FirstOrDefault(p => p.Name == pn); if (prot != null) { if (!protocolMap.ContainsKey(pn)) { protocolMap.Add(pn, prot); } foreach (var msg in prot.Messages) { if (!methodNameProtocolNamesMap.ContainsKey(msg.Selector)) { methodNameProtocolNamesMap.Add(msg.Selector, new List <string>()); } methodNameProtocolNamesMap[msg.Selector].Add(pn); } } } // Build a map between the methods defined by the protocols involved in <classesList> and <superclassesList> the protocol where they are defined foreach (var pair in methodNameProtocolNamesMap) { allMethodNameProtocolNamesMap[pair.Key] = new List <string>(pair.Value); } foreach (string pn in protocolNameSuperslassesMap.Keys) { var prot = currentClass.Parent.SmalltalkSystem.SystemDescription.Protocols.FirstOrDefault(p => p.Name == pn); if (prot != null) { if (!protocolMap.ContainsKey(pn)) { protocolMap.Add(pn, prot); } foreach (var msg in prot.Messages) { if (!allMethodNameProtocolNamesMap.ContainsKey(msg.Selector)) { allMethodNameProtocolNamesMap.Add(msg.Selector, new List <string>()); } allMethodNameProtocolNamesMap[msg.Selector].Add(pn); } } } // Build a list of method names that have a super implementor with #subclassResponsibility. Dictionary <string, bool?> srm = new Dictionary <string, bool?>(); foreach (Class cls in currentClass.WithAllSuperclasses()) { var mths = (methodType == MethodType.Instance) ? cls.InstanceMethods : cls.ClassMethods; foreach (Method mth in mths) { bool?sr = null; srm.TryGetValue(mth.Selector, out sr); if (sr == null) { if (MethodHelper.IsSubclassResponsibility(mth)) { sr = (cls != currentClass); } else if (MethodHelper.HasImplementation(mth)) { sr = false; } else { sr = true; // Not really subcl.res., but a method without code, so this needs attention as well } } srm[mth.Selector] = sr; } } foreach (KeyValuePair <string, bool?> pair in srm) { if (pair.Value ?? false) { subclassResponsibilityMethods.Add(pair.Key); } } // Find out which methods have local implementors HashSet <string> methodNames = new HashSet <string>(); methodNames.UnionWith(methodNameClassesMap.Keys); methodNames.UnionWith(methodNameProtocolNamesMap.Keys); foreach (string selector in methodNames) { methodNameLocalImplementorsMap[selector] = new List <Class>(); } foreach (Class cls in currentClass.AllSubclasses().OrderBy(c => c.Name)) { var mths = (methodType == MethodType.Instance) ? cls.InstanceMethods : cls.ClassMethods; foreach (Method mth in mths) { if (methodNameLocalImplementorsMap.ContainsKey(mth.Selector)) { methodNameLocalImplementorsMap[mth.Selector].Add(cls); } } } // Find out which methods wiht super implementors foreach (string selector in methodNames) { methodNameSuperImplementorsMap[selector] = new List <Class>(); } foreach (Class cls in includeUpToClass.AllSuperclasses()) { var mths = (methodType == MethodType.Instance) ? cls.InstanceMethods : cls.ClassMethods; foreach (Method mth in mths) { if (methodNameSuperImplementorsMap.ContainsKey(mth.Selector)) { methodNameSuperImplementorsMap[mth.Selector].Add(cls); } } } }
private void FillView() { if (this.ListItemChanging) { return; } this.Enabled = false; this.listMethods.Items.Clear(); if (this.Class == null) { return; } if (String.IsNullOrWhiteSpace(this.ProtocolName)) { return; } if (this.MethodType == null) { return; } this.listMethods.BeginUpdate(); Font normalFont = this.listMethods.Font; Font boldFont = new Font(normalFont, FontStyle.Bold); List <Class> classesList; List <Class> superclassesList; Dictionary <string, Class> classesMap; Dictionary <string, List <Class> > protocolNameClassesMap; Dictionary <string, List <Class> > protocolNameSuperslassesMap; Dictionary <string, List <Class> > methodNameClassesMap; Dictionary <string, List <Class> > methodNameSuperclassesMap; Dictionary <string, List <string> > methodNameProtocolNamesMap; Dictionary <string, List <string> > allMethodNameProtocolNamesMap; Dictionary <string, Definitions.Description.Protocol> protocolMap; HashSet <string> subclassResponsibilityMethods; Dictionary <string, List <Class> > methodNameLocalImplementorsMap; Dictionary <string, List <Class> > methodNameSuperImplementorsMap; MethodHelper.BuildLists(this.Class, this.IncludeUpToClass, this.MethodType, out classesList, out superclassesList, out classesMap, out protocolNameClassesMap, out protocolNameSuperslassesMap, out methodNameClassesMap, out methodNameSuperclassesMap, out methodNameProtocolNamesMap, out allMethodNameProtocolNamesMap, out protocolMap, out subclassResponsibilityMethods, out methodNameLocalImplementorsMap, out methodNameSuperImplementorsMap); /* *** CREATE THE LIST OF METHODS *** * The logic is as follows: * 1. Consider methods that: * a. Are implemented by the this.Class itself * b. Are implemented by any superclass up to and incl. this.IncludeUpToClass * c. Are defined (actually messages) in any protocol that this.Class wants to implement * d. Are defined (actually messages) in any protocol that any superclass up to and incl. this.IncludeUpToClass wants to implement * * Obviously, depending on this.MethodType we concider only the class methods/protocols or the instance ones * 2. Filter methods so: * a. If this.ProtocolName is "ANY", then include everything. * b. If this.ProtocolName is "PRIVATE", then include method found in 1.a. or 1.b. but NOT also in 1.c. and 1.d. * c. Include methods found in 1.c. or 1.d. according to the name of the selected protocol * d. Similar to b., but also method in any protocol that any of the superclasses wants to implements * * 3. Create list items for each method with following details: * a. Method selector * b. Lists if protocols defining it (similar to 1.c and 1.d but up to the root class) * c. Local implementors of the methods (subclasses of this.Class, but NOT this.Class itself) * d. Super implementors of the methods (superclasses of this.IncludeUpToClass, but NOT this.IncludeUpToClass itself) * 4. Decorate (color) each item: * a. Only defined (in protocols) but not implemented: Gray * b. Implementation is empty and super implementor exists that says subclassResponsibility: Red * c. Found in 1.a. or 1.c. (as oposite to 1.b and 1.d): Bold Font */ HashSet <string> methodNames = new HashSet <string>(); methodNames.UnionWith(methodNameClassesMap.Keys); methodNames.UnionWith(methodNameProtocolNamesMap.Keys); foreach (string selector in methodNames.OrderBy(s => s)) { bool include; if (this.ProtocolName == "ANY") { include = true; } else if (this.ProtocolName == "PRIVATE") { include = !methodNameProtocolNamesMap.ContainsKey(selector) || (methodNameProtocolNamesMap[selector].Count == 0); } else { include = allMethodNameProtocolNamesMap.ContainsKey(selector) && allMethodNameProtocolNamesMap[selector].Contains(this.ProtocolName); } if (include) { ListViewItem lvi = this.listMethods.Items.Add(selector, "method"); lvi.Tag = selector; lvi.UseItemStyleForSubItems = false; // Is the method implemented by any class (as oposite by only defined by a protocol implemented by the class) if (!methodNameClassesMap.ContainsKey(selector)) { lvi.ForeColor = Color.Gray; } // Is this a method that we must override? if (subclassResponsibilityMethods.Contains(selector)) { lvi.ForeColor = Color.Red; } IEnumerable <string> definingProtocols = new string[0]; if (allMethodNameProtocolNamesMap.ContainsKey(selector)) { definingProtocols = allMethodNameProtocolNamesMap[selector]; } // This is a method defined in locally implemented protocol if (definingProtocols.Any(pn => protocolNameClassesMap.ContainsKey(pn) && protocolNameClassesMap[pn].Contains(this.Class))) { lvi.Font = boldFont; } // This is a locally implemented method if (methodNameClassesMap.ContainsKey(selector) && methodNameClassesMap[selector].Contains(this.Class)) { lvi.Font = boldFont; } IEnumerable <Class> implementingClasses = new Class[0]; if (methodNameClassesMap.ContainsKey(selector)) { implementingClasses = methodNameClassesMap[selector]; } // Protocols: (which protocols defines the method) string protocols = String.Join(", ", definingProtocols.OrderBy(p => p)); lvi.SubItems.Add((String.IsNullOrWhiteSpace(protocols) ? "PRIVATE" : protocols)); lvi.SubItems[lvi.SubItems.Count - 1].Font = lvi.Font; lvi.SubItems[lvi.SubItems.Count - 1].ForeColor = lvi.ForeColor; // Local Implementors: (excluding the current class) lvi.SubItems.Add(String.Join(", ", methodNameLocalImplementorsMap[selector].Select(c => c.Name))).Font = normalFont; // Super Implementors: (excluding listed classes) lvi.SubItems.Add(String.Join(", ", methodNameSuperImplementorsMap[selector].Select(c => c.Name))).Font = normalFont; lvi.ToolTipText = String.Format("Defined: {0}\nImplemented: {1}", protocols, String.Join(", ", implementingClasses.Select(c => c.Name))); lvi.Selected = (this.MethodName == selector); } } this.listMethods.EndUpdate(); if (this.listMethods.SelectedItems.Count > 0) { this.listMethods.SelectedItems[0].EnsureVisible(); } this.Enabled = true; }