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