private void ParseForeignTypeToModel(SDType sdType, IType type) { AddParsedArrayTypeElement(sdType, type); AddParsedTypeArguments(sdType, type.TypeArguments); AddParsedBaseTypes(sdType, type.DirectBaseTypes); AddParsedInterfaces(sdType, type.DirectBaseTypes); }
public void AddType(SDType sdType) { if (!Types.ContainsKey(sdType.Identifier)) { Types.Add(sdType.Identifier, sdType); } }
public TypeViewModel(SDType type, NamespaceViewModel parent, ICoreConfigSection sharpDoxConfig) : base(type.Identifier, parent, sharpDoxConfig) { Text = type.NameWithTypeArguments; Accessibility = type.Accessibility; Image = string.Format("pack://application:,,,/SharpDox.GUI;component/Resources/Icons/Class_{0}.png", Accessibility); foreach (var sdEvent in type.Events) { Children.Add(new EventViewModel(sdEvent, this, sharpDoxConfig)); } foreach (var sdField in type.Fields) { Children.Add(new FieldViewModel(sdField, this, sharpDoxConfig)); } foreach (var sdMethod in type.Constructors) { Children.Add(new MethodViewModel(sdMethod, this, sharpDoxConfig)); } foreach (var sdMethod in type.Methods) { Children.Add(new MethodViewModel(sdMethod, this, sharpDoxConfig)); } foreach (var sdProperty in type.Properties) { Children.Add(new PropertyViewModel(sdProperty, this, sharpDoxConfig)); } }
public TypeViewModel(SDType type, NamespaceViewModel parent, ObservableCollection<string> excludedIdentifiers) : base(type.Identifier, parent, excludedIdentifiers) { Text = type.NameWithTypeParam; Accessibility = type.Accessibility; Image = string.Format("pack://application:,,,/SharpDox.Resources;component/Icons/Class_{0}.png", Accessibility); foreach (var sdEvent in type.Events) { Children.Add(new EventViewModel(sdEvent, this, excludedIdentifiers)); } foreach (var sdField in type.Fields) { Children.Add(new FieldViewModel(sdField, this, excludedIdentifiers)); } foreach (var sdMethod in type.Constructors) { Children.Add(new MethodViewModel(sdMethod, this, excludedIdentifiers)); } foreach (var sdMethod in type.Methods) { Children.Add(new MethodViewModel(sdMethod, this, excludedIdentifiers)); } foreach (var sdProperty in type.Properties) { Children.Add(new PropertyViewModel(sdProperty, this, excludedIdentifiers)); } }
public void AddType(SDType sdType) { if (!Types.ContainsKey(sdType.Identifier)) { Types.Add(sdType.Identifier, sdType); } }
private void AddParsedArrayTypeElement(SDType sdType, IType type) { var arrayType = type as ArrayType; if (arrayType != null) { sdType.ArrayElementType = GetParsedType(arrayType.ElementType); } }
public MethodVisitor(SDRepository repository, SDMethod method, SDType type, CSharpFile file) { _repository = repository; _method = method; _type = type; _file = file; _tokenList = method.Calls; }
/// <default> /// <summary> /// Returns a type, referenced by its identifier. /// </summary> /// <param name="identifier">The identifier of the type.</param> /// <returns>The type, if it is available.</returns> /// </default> /// <de> /// <summary> /// Liefert den Typen mit dem angegebenen Identifikator. /// </summary> /// <param name="identifier">Der Identifikator des Typen.</param> /// <returns>Der Typ, falls dieser vorhanden ist.</returns> /// </de> public SDType GetTypeByIdentifier(string identifier) { SDType sdType = null; Types.TryGetValue(identifier, out sdType); return(sdType); }
public void AddType(SDType sdType) { if (!Types.ContainsKey(sdType.Identifier)) { sdType.ShortIdentifier = GetUniqueShortTypeIdentifier(sdType); Types.Add(sdType.Identifier, sdType); } }
public CSharpMethodVisitor(SDRepository repository, SDMethod method, SDType type, Document file) : base(SyntaxWalkerDepth.StructuredTrivia) { _repository = repository; _method = method; _type = type; _file = file; _tokenList = method.Calls; }
private void InsertClassDiagram(SDType sdType) { if(!sdType.IsClassDiagramEmpty()) { var tmpImagePath = Path.Combine(_outputPath, "tmp", sdType.Guid + ".png"); sdType.GetClassDiagram().ToPng(tmpImagePath); _wordTemplater.AppendImage(tmpImagePath, "Diagram"); } }
public void ShouldReturnTrueForClassDiagramIsEmpty() { //Arrange var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests")); //Act var isEmpty = sdType.IsClassDiagramEmpty(); //Assert Assert.AreEqual(true, isEmpty); }
private void ParseTypeToModel(SDType sdType, IType type) { sdType.IsProjectStranger = false; AddParsedTypeArguments(sdType, type.TypeArguments); AddParsedBaseTypes(sdType, type.DirectBaseTypes); AddParsedInterfaces(sdType, type.DirectBaseTypes); AddParsedProperties(sdType, type); AddParsedFields(sdType, type); AddParsedConstructorsAndMethods(sdType, type); AddParsedEvents(sdType, type); }
private void AddParsedBaseType(SDType sdType, INamedTypeSymbol baseType) { if (baseType != null && baseType.TypeKind != TypeKind.Interface) { var typeRef = _typeRefParser.GetParsedTypeReference(baseType); if (sdType.BaseTypes.SingleOrDefault((i => i.Type.Identifier == typeRef.Type.Identifier)) == null && typeRef.Type.Fullname != "System.Object") { sdType.BaseTypes.Add(typeRef); } } }
internal static void ParseMinimalFields(SDType sdType, IType type) { var fields = type.GetFields(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var field in fields) { var parsedField = GetMinimalParsedField(field); if (sdType.Fields.SingleOrDefault(f => f.Name == parsedField.Name) == null) { sdType.Fields.Add(parsedField); } } }
internal static void ParseMinimalFields(SDType sdType, IType type) { var events = type.GetEvents(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var eve in events) { var parsedEvent = GetMinimalParsedEvent(eve); if (sdType.Events.SingleOrDefault(f => f.Name == parsedEvent.Name) == null) { sdType.Events.Add(parsedEvent); } } }
public void ShouldReturnFalseForClassDiagramIsEmptyBecausePropertyPresent() { //Arrange var sdType = new SDType("SharpDox.UML.Tests.DiagramExtensionsTests", "DiagramExtensionTests", new SDNamespace("SharpDox.UML.Tests")); sdType.Properties.Add(new SDProperty("SharpDox.UML.Tests.DiagramExtensionsTests.Property1")); //Act var isEmpty = sdType.IsClassDiagramEmpty(); //Assert Assert.AreEqual(false, isEmpty); }
internal static void ParseMinimalProperties(SDType sdType, IType type) { var properties = type.GetProperties(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var property in properties) { var parsedProperty = GetMinimalParsedProperty(property); if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null) { sdType.Properties.Add(parsedProperty); } } }
private void AddParsedNestedTypes(SDType sdType, IEnumerable<INamedTypeSymbol> nestedTypes) { foreach (var nestedType in nestedTypes) { if (nestedType.TypeKind != TypeKind.Interface) { var typeRef = _typeRefParser.GetParsedTypeReference(nestedType); if (sdType.NestedTypes.SingleOrDefault((i => i.Type.Identifier == typeRef.Type.Identifier)) == null && typeRef.Type.Fullname != "System.Object") { sdType.NestedTypes.Add(typeRef); } } } }
private void AddParsedInterfaces(SDType sdType, IEnumerable<IType> implementedInterfaces) { foreach (var implementedInterface in implementedInterfaces) { if (implementedInterface.Kind == TypeKind.Interface) { var type = GetParsedType(implementedInterface); if (sdType.ImplementedInterfaces.SingleOrDefault((i => i.Identifier == type.Identifier)) == null && type.Fullname != "System.Object") { sdType.ImplementedInterfaces.Add(type); } } } }
private void AddParsedBaseTypes(SDType sdType, IEnumerable<IType> directBaseTypes) { foreach (var baseType in directBaseTypes) { if (baseType.Kind != TypeKind.Interface) { var type = GetParsedType(baseType); if (sdType.BaseTypes.SingleOrDefault((i => i.Identifier == type.Identifier)) == null && type.Fullname != "System.Object") { sdType.BaseTypes.Add(type); } } } }
public ClassDiagram CreateClassDiagram(SDType type) { var attribute = type.IsAbstract && type.Kind.ToLower() != "interface" ? "abstract" : string.Empty; attribute = type.IsStatic ? "static" : attribute; _classDiagram = new ClassDiagram(type.Identifier, type.Name, type.Kind, type.Accessibility, attribute); ParseFields(type.Fields); ParseProperties(type.Properties); ParseMethods(type.Methods); ParseEvents(type.Events); return _classDiagram; }
private void InsertUseUsedBlock(SDType sdType, int navigationLevel) { if (sdType.Uses.Count > 0) { _wordTemplater.AppendHeader(_wordStrings.Uses, navigationLevel); sdType.Uses.Select(u => u.Fullname).ToList().ForEach(u => _wordTemplater.AppendParagraph(u, "CenteredNoMargin")); } if (sdType.UsedBy.Count > 0) { _wordTemplater.AppendHeader(_wordStrings.UsedBy, navigationLevel); sdType.UsedBy.Select(u => u.Fullname).ToList().ForEach(u => _wordTemplater.AppendParagraph(u, "CenteredNoMargin")); } }
internal void ParseFields(SDType sdType, IType type) { var fields = type.GetFields(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var field in fields) { if (!_excludedIdentifiers.Contains(field.GetIdentifier())) { var parsedField = GetParsedField(field); if (sdType.Fields.SingleOrDefault(f => f.Name == parsedField.Name) == null) { sdType.Fields.Add(parsedField); } } } }
private SDType CreateSDType(ITypeSymbol typeSymbol, INamespaceSymbol namespaceSymbol) { var sdNamespace = new SDNamespace(namespaceSymbol.GetIdentifier()) { IsProjectStranger = true }; var sdType = new SDType(typeSymbol.GetIdentifier(), typeSymbol.Name, sdNamespace) { Accessibility = typeSymbol.DeclaredAccessibility.ToString().ToLower(), IsAbstract = typeSymbol.IsAbstract, IsReferenceType = typeSymbol.IsReferenceType, IsSealed = typeSymbol.IsSealed, IsStatic = typeSymbol.IsStatic, IsProjectStranger = true, Kind = typeSymbol.TypeKind.ToString().ToLower() }; return sdType; }
public void InsertType(SDType sdType, int navigationLevel) { var documentation = sdType.Documentations.GetElementOrDefault(_docLanguage); _wordTemplater.AppendHeader(sdType.Name, navigationLevel); _wordTemplater.AppendCodeBlock(sdType.Syntax); InsertDocumentation(null, documentation, navigationLevel + 1); InsertClassDiagram(sdType); InsertUseUsedBlock(sdType, navigationLevel + 1); InsertMemberBlock(_wordStrings.Fields, "field", sdType.Fields.Cast<SDMember>(), navigationLevel + 1); InsertMemberBlock(_wordStrings.Events, "event", sdType.Events.Cast<SDMember>(), navigationLevel + 1); InsertMemberBlock(_wordStrings.Methods, "method", sdType.Methods.Cast<SDMember>(), navigationLevel + 1); InsertMemberBlock(_wordStrings.Properties, "properties", sdType.Properties.Cast<SDMember>(), navigationLevel + 1); _wordTemplater.AppendPageBreak(); }
internal void ParseEvents(SDType sdType, INamedTypeSymbol typeSymbol) { var events = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Event).Select(m => m as IEventSymbol); foreach (var eve in events) { if (!IsMemberExcluded(eve.GetIdentifier(), eve.DeclaredAccessibility)) { var parsedEvent = GetParsedEvent(eve); if (sdType.Events.SingleOrDefault(f => f.Name == parsedEvent.Name) == null) { sdType.Events.Add(parsedEvent); } } } }
internal void ParseEvents(SDType sdType, IType type) { var events = type.GetEvents(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var eve in events) { if (!IsMemberExcluded(eve.GetIdentifier(), eve.Accessibility.ToString())) { var parsedEvent = GetParsedEvent(eve); if (sdType.Events.SingleOrDefault(f => f.Name == parsedEvent.Name) == null) { sdType.Events.Add(parsedEvent); } } } }
internal void ParseFields(SDType sdType, INamedTypeSymbol typeSymbol) { var fields = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Field && !m.IsImplicitlyDeclared).Select(f => f as IFieldSymbol); foreach (var field in fields) { if (!IsMemberExcluded(field.GetIdentifier(), field.DeclaredAccessibility)) { var parsedField = GetParsedField(field); if (sdType.Fields.SingleOrDefault(f => f.Name == parsedField.Name) == null) { sdType.Fields.Add(parsedField); } } } }
internal void ParseProperties(SDType sdType, INamedTypeSymbol typeSymbol) { var properties = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Property).Select(f => f as IPropertySymbol); foreach (var property in properties) { if (!IsMemberExcluded(property.GetIdentifier(), property.DeclaredAccessibility)) { var parsedProperty = GetParsedProperty(property); if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null) { sdType.Properties.Add(parsedProperty); } } } }
internal void ParseProperties(SDType sdType, IType type) { var properties = type.GetProperties(null, GetMemberOptions.IgnoreInheritedMembers); foreach (var property in properties) { if (!IsMemberExcluded(property.GetIdentifier(), property.Accessibility.ToString())) { var parsedProperty = GetParsedProperty(property); if (sdType.Properties.SingleOrDefault(p => p.Name == parsedProperty.Name) == null) { sdType.Properties.Add(parsedProperty); } } } }
public ClassDiagram CreateClassDiagram(SDType type, bool parseConnectedDiagrams = true) { var classDiagram = new ClassDiagram(type); classDiagram.IsProjectStranger = type.IsProjectStranger; if (parseConnectedDiagrams) { ParseTypes(classDiagram.BaseTypes, type.BaseTypes.Select(t => t.Type)); ParseTypes(classDiagram.ImplementedInterfaces, type.ImplementedInterfaces.Select(t => t.Type)); ParseTypes(classDiagram.Uses, type.Uses); ParseTypes(classDiagram.UsedBy, type.UsedBy); } ParseFields(classDiagram, type.Fields); ParseProperties(classDiagram, type.Properties); ParseConstructors(classDiagram, type.Constructors); ParseMethods(classDiagram, type.Methods); ParseEvents(classDiagram, type.Events); return classDiagram; }
public ClassDiagram(SDType sdType) { _classDiagramPngRenderer = new ClassDiagramPngRenderer(); _classDiagramSvgRenderer = new ConnectedClassDiagramSvgRenderer(); var attribute = sdType.IsAbstract && sdType.Kind.ToLower() != "interface" ? "abstract" : string.Empty; attribute = sdType.IsStatic ? "static" : attribute; TypeIdentifier = sdType.Identifier; Name = sdType.Name; Accessibility = string.Format("{0} {1} {2}", sdType.Accessibility, attribute, sdType.Kind); BaseTypes = new List<ClassDiagram>(); ImplementedInterfaces = new List<ClassDiagram>(); Uses = new List<ClassDiagram>(); UsedBy = new List<ClassDiagram>(); ConstructorRows = new List<ClassDiagramRow>(); MethodRows = new List<ClassDiagramRow>(); FieldRows = new List<ClassDiagramRow>(); PropertyRows = new List<ClassDiagramRow>(); EventRows = new List<ClassDiagramRow>(); }
private string GetUniqueShortTypeIdentifier(SDType sdType) { return(GetUniquieShortIdentifier(sdType.Identifier, sdType.Name, _typeNameCount, _uniqueShortTypeIdentifier)); }