defaultprojectcontent.cs

SharpDevelop2.0.0 c#开发免费工具

		public void UpdateCompilationUnit(ICompilationUnit oldUnit, ICompilationUnit parserOutput, string fileName, bool updateCommentTags)
		{
			if (updateCommentTags) {
				TaskService.UpdateCommentTags(fileName, parserOutput.TagComments);
			}
			
			lock (namespaces) {
				if (oldUnit != null) {
					RemoveClasses(oldUnit, parserOutput);
				}
				
				foreach (IClass c in parserOutput.Classes) {
					AddClassToNamespaceListInternal(c);
				}
			}
		}
		
		void RemoveClasses(ICompilationUnit oldUnit, ICompilationUnit newUnit)
		{
			foreach (IClass c in oldUnit.Classes) {
				bool found = false;
				foreach (IClass c2 in newUnit.Classes) {
					if (c.FullyQualifiedName == c2.FullyQualifiedName) {
						found = true;
						break;
					}
				}
				if (!found) {
					RemoveClass(c);
				}
			}
		}
		
		void RemoveClass(IClass @class)
		{
			string fullyQualifiedName = @class.FullyQualifiedName;
			if (@class.IsPartial) {
				// remove a part of a partial class
				// Use "as" cast to fix SD2-680: the stored class might be a part not marked as partial
				CompoundClass compound = GetClassInternal(fullyQualifiedName, @class.TypeParameters.Count, language) as CompoundClass;
				if (compound == null) return;
				lock (compound) {
					compound.Parts.Remove(@class);
					if (compound.Parts.Count > 0) {
						compound.UpdateInformationFromParts();
						return;
					} else {
						@class = compound; // all parts removed, remove compound class
					}
				}
			}
			
			IClass classInDictionary;
			if (!GetClasses(language).TryGetValue(fullyQualifiedName, out classInDictionary)) {
				return;
			}
			
			GenericClassContainer gcc = classInDictionary as GenericClassContainer;
			if (gcc != null) {
				gcc.Remove(@class.TypeParameters.Count);
				if (gcc.RealClassCount > 0) {
					return;
				}
			}
			
			foreach (Dictionary<string, IClass> classes in ClassLists) {
				classes.Remove(fullyQualifiedName);
			}
			
			string nSpace = @class.Namespace;
			if (nSpace == null) {
				nSpace = String.Empty;
			}
			
			// Remove class from namespace lists
			List<IClass> classList = GetNamespaces(this.language)[nSpace].Classes;
			for (int i = 0; i < classList.Count; i++) {
				if (language.NameComparer.Equals(classList[i].FullyQualifiedName, fullyQualifiedName)) {
					classList.RemoveAt(i);
					break;
				}
			}
			if (classList.Count == 0) {
				RemoveEmptyNamespace(nSpace);
			}
		}
		
		#region Default Parser Layer dependent functions
		public IClass GetClass(string typeName)
		{
			return GetClass(typeName, 0);
		}
		
		public IClass GetClass(string typeName, int typeParameterCount)
		{
			return GetClass(typeName, typeParameterCount, language, true);
		}
		
		protected IClass GetClassInternal(string typeName, int typeParameterCount, LanguageProperties language)
		{
			lock (namespaces) {
				IClass c;
				if (GetClasses(language).TryGetValue(typeName, out c)) {
					GenericClassContainer gcc = c as GenericClassContainer;
					if (gcc != null) {
						return gcc.GetBest(typeParameterCount);
					}
					return c;
				}
				return null;
			}
		}
		
		public IClass GetClass(string typeName, int typeParameterCount, LanguageProperties language, bool lookInReferences)
		{
			IClass c = GetClassInternal(typeName, typeParameterCount, language);
			if (c != null && c.TypeParameters.Count == typeParameterCount) {
				return c;
			}
			
			// Search in references:
			if (lookInReferences) {
				foreach (IProjectContent content in referencedContents) {
					IClass contentClass = content.GetClass(typeName, typeParameterCount, language, false);
					if (contentClass != null) {
						if (contentClass.TypeParameters.Count == typeParameterCount) {
							return contentClass;
						} else {
							c = contentClass;
						}
					}
				}
			}
			
			if (c != null) {
				return c;
			}
			
			// not found -> maybe nested type -> trying to find class that contains this one.
			int lastIndex = typeName.LastIndexOf('.');
			if (lastIndex > 0) {
				string outerName = typeName.Substring(0, lastIndex);
				IClass upperClass = GetClassInternal(outerName, typeParameterCount, language);
				if (upperClass != null) {
					foreach (IClass upperBaseClass in upperClass.ClassInheritanceTree) {
						List<IClass> innerClasses = upperBaseClass.InnerClasses;
						if (innerClasses != null) {
							string innerName = typeName.Substring(lastIndex + 1);
							foreach (IClass innerClass in innerClasses) {
								if (language.NameComparer.Equals(innerClass.Name, innerName)) {
									return innerClass;
								}
							}
						}
					}
				}
			}
			return null;
		}
		
		public ArrayList GetNamespaceContents(string nameSpace)
		{
			ArrayList namespaceList = new ArrayList();
			AddNamespaceContents(namespaceList, nameSpace, language, true);
			return namespaceList;
		}
		
		/// <summary>
		/// Adds the contents of the specified <paramref name="nameSpace"/> to the <paramref name="list"/>.
		/// </summary>
		public void AddNamespaceContents(ArrayList list, string nameSpace, LanguageProperties language, bool lookInReferences)
		{
			if (nameSpace == null) {
				return;
			}
			
			if (lookInReferences) {
				foreach (IProjectContent content in referencedContents) {
					content.AddNamespaceContents(list, nameSpace, language, false);
				}
			}
			
			Dictionary<string, NamespaceStruct> dict = GetNamespaces(language);
			if (dict.ContainsKey(nameSpace)) {
				NamespaceStruct ns = dict[nameSpace];
				int newCapacity = list.Count + ns.Classes.Count + ns.SubNamespaces.Count;
				if (list.Capacity < newCapacity)
					list.Capacity = newCapacity;
				foreach (IClass c in ns.Classes) {
					if (c is GenericClassContainer) {
						foreach (IClass realClass in ((GenericClassContainer)c).RealClasses) {
							AddNamespaceContentsClass(list, realClass, language, lookInReferences);
						}
					} else {
						AddNamespaceContentsClass(list, c, language, lookInReferences);
					}
				}
				foreach (string subns in ns.SubNamespaces) {
					if (!list.Contains(subns))
						list.Add(subns);
				}
			}
		}
		
		void AddNamespaceContentsClass(ArrayList list, IClass c, LanguageProperties language, bool lookInReferences)
		{
			if (c.IsInternal && !lookInReferences) {
				// internal class and we are looking at it from another project content
				return;
			}
			if (language.ShowInNamespaceCompletion(c))
				list.Add(c);
			if (language.ImportModules && c.ClassType == ClassType.Module) {
				foreach (IMember m in c.Methods) {
					if (m.IsAccessible(null, false))
						list.Add(m);
				}
				foreach (IMember m in c.Events) {
					if (m.IsAccessible(null, false))
						list.Add(m);
				}
				foreach (IMember m in c.Fields) {
					if (m.IsAccessible(null, false))
						list.Add(m);
				}
				foreach (IMember m in c.Properties) {
					if (m.IsAccessible(null, false))
						list.Add(m);
				}
			}
		}
		
		public bool NamespaceExists(string name)
		{
			return NamespaceExists(name, language, true);
		}
		
		public bool NamespaceExists(string name, LanguageProperties language, bool lookInReferences)
		{
			if (name == null) {
				return false;
			}
			
			if (lookInReferences) {
				foreach (IProjectContent content in referencedContents) {
					if (content.NamespaceExists(name, language, false)) {
						return true;
					}
				}
			}
			
			return GetNamespaces(language).ContainsKey(name);
		}
		
		
		public string SearchNamespace(string name, IClass curType, ICompilationUnit unit, int caretLine, int caretColumn)
		{
			if (NamespaceExists(name)) {
				return name;
			}
			
			if (unit == null) {
				return null;
			}
			
			foreach (IUsing u in unit.Usings) {
				if (u != null) {
					string nameSpace = u.SearchNamespace(name);
					if (nameSpace != null) {
						return nameSpace;
					}
				}
			}
			if (defaultImports != null) {
				string nameSpace = defaultImports.SearchNamespace(name);
				if (nameSpace != null) {
					return nameSpace;
				}
			}
			if (curType != null) {
				// Try parent namespaces of the current class
				string fullname = curType.Namespace;
				if (fullname != null && fullname.Length > 0) {
					string[] namespaces = fullname.Split('.');
					StringBuilder curnamespace = new StringBuilder();
					for (int i = 0; i < namespaces.Length; ++i) {
						curnamespace.Append(namespaces[i]);
						curnamespace.Append('.');
						
						curnamespace.Append(name);
						string nameSpace = curnamespace.ToString();
						if (NamespaceExists(nameSpace)) {
							return nameSpace;
						}
						// remove class name again to try next namespace
						curnamespace.Length -= name.Length;
					}
				}
			}
			return null;
		}
		
		public IReturnType SearchType(string name, int typeParameterCount, IClass curType, int caretLine, int caretColumn)
		{
			if (curType == null) {
				return SearchType(name, typeParameterCount, null, null, caretLine, caretColumn);
			}
			return SearchType(name, typeParameterCount, curType, curType.CompilationUnit, caretLine, caretColumn);
		}
		
		public IReturnType SearchType(string name, int typeParameterCount, IClass curType, ICompilationUnit unit, int caretLine, int caretColumn)
		{
			if (name == null || name.Length == 0) {
				return null;
			}
			
			// Try if name is already the full type name
			IClass c = GetClass(name, typeParameterCount);
			if (c != null) {
				return c.DefaultReturnType;
			}
			// fallback-class if the one with the right type parameter count is not found.
			IReturnType fallbackClass = null;
			if (curType != null) {
				// Try parent namespaces of the current class
				string fullname = curType.FullyQualifiedName;
				string[] namespaces = fullname.Split('.');
				StringBuilder curnamespace = new StringBuilder();
				for (int i = 0; i < namespaces.Length; ++i) {
					curnamespace.Append(namespaces[i]);
					curnamespace.Append('.');
					
					curnamespace.Append(name);
					c = GetClass(curnamespace.ToString(), typeParameterCount);
					if (c != null) {
						if (c.TypeParameters.Count == typeParameterCount)
							return c.DefaultReturnType;
						else
							fallbackClass = c.DefaultReturnType;
					}
					// remove class name again to try next namespace
					curnamespace.Length -= name.Length;
				}
				
				if (name.IndexOf('.') < 0) {
					// Try inner classes (in full inheritance tree)
					// Don't use loop with cur = cur.BaseType because of inheritance cycles
					foreach (IClass baseClass in curType.ClassInheritanceTree) {
						if (baseClass.ClassType == ClassType.Class) {
							foreach (IClass innerClass in baseClass.InnerClasses) {
								if (language.NameComparer.Equals(innerClass.Name, name))
									return innerClass.DefaultReturnType;
							}
						}
					}
				}
			}
			if (unit != null) {
				// Combine name with usings
				foreach (IUsing u in unit.Usings) {
					if (u != null) {
						IReturnType r = u.SearchType(name, typeParameterCount);
						if (r != null) {
							if (r.TypeParameterCount == typeParameterCount) {
								return r;
							} else {
								fallbackClass = r;
							}
						}
					}
				}
			}
			if (defaultImports != null) {
				IReturnType r = defaultImports.SearchType(name, typeParameterCount);
				if (r != null) {
					if (r.TypeParameterCount == typeParameterCount) {
						return r;
					} else {
						fallbackClass = r;
					}
				}
			}
			return fallbackClass;
		}
		
		/// <summary>
		/// Gets the position of a member in this project content (not a referenced one).
		/// </summary>
		/// <param name="fullMemberName">Fully qualified member name (always case sensitive).</param>
		public Position GetPosition(string fullMemberName)
		{
			IClass curClass = GetClass(fullMemberName, 0, LanguageProperties.CSharp, false);
			if (curClass != null) {
				return new Position(curClass.CompilationUnit, curClass.Region.BeginLine, curClass.Region.BeginColumn);
			}
			int pos = fullMemberName.LastIndexOf('.');
			if (pos > 0) {
				string className = fullMemberName.Substring(0, pos);
				string memberName = fullMemberName.Substring(pos + 1);
				curClass = GetClass(className, 0, LanguageProperties.CSharp, false);
				if (curClass != null) {
					IMember member = curClass.SearchMember(memberName, LanguageProperties.CSharp);
					if (member != null) {
						return new Position(curClass.CompilationUnit, member.Region.BeginLine, member.Region.BeginColumn);
					}
				}
			}
			return new Position(null, -1, -1);
		}
		#endregion
		
		public event EventHandler ReferencedContentsChanged;
		
		protected virtual void OnReferencedContentsChanged(EventArgs e)
		{
			if (ReferencedContentsChanged != null) {
				ReferencedContentsChanged(this, e);
			}
		}
	}
}