public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
if (SkipInnerTypeDeclaration(node))
{
return;
}
_relationships.AddInnerclassRelationFrom(node);
_relationships.AddInheritanceFrom(node);
var typeName = TypeNameText.From(node);
var name = typeName.Identifier;
var typeParam = typeName.TypeArguments;
var type = $"{name}{typeParam}";
types.Add(name);
WriteLine($"class {type} <<struct>> {{");
nestingDepth++;
base.VisitStructDeclaration(node);
nestingDepth--;
WriteLine("}");
}
public void AddAssociationFrom(FieldDeclarationSyntax node, VariableDeclaratorSyntax field)
{
var baseNode = node.Declaration.Type as SimpleNameSyntax;
var subNode = node.Parent as BaseTypeDeclarationSyntax;
if (baseNode == null || subNode == null)
{
return;
}
var symbol = field.Initializer == null ? "-->" : "o->";
var baseNames = TypeNameText.From(baseNode);
var subName = TypeNameText.From(subNode);
foreach (var baseName in baseNames)
{
if (InvisibleClassOrInterface.Contains(baseName.Identifier))
{
continue;
}
_items.Add(new Relationship(subName, baseName, symbol, "", field.Identifier.ToString() + baseName.TypeArguments));
}
}
public void AddInheritanceFrom(TypeDeclarationSyntax syntax)
{
if (syntax.BaseList == null)
{
return;
}
var subTypeName = TypeNameText.From(syntax);
foreach (var typeStntax in syntax.BaseList.Types)
{
var typeNameSyntax = typeStntax.Type as SimpleNameSyntax;
if (typeNameSyntax == null)
{
continue;
}
var baseTypeNames = TypeNameText.From(typeNameSyntax);
foreach (var baseTypeName in baseTypeNames)
{
// 특정 클래스는 스킵
if (InvisibleClassOrInterface.Contains(baseTypeName.Identifier))
{
continue;
}
_items.Add(new Relationship(baseTypeName, subTypeName, "<|--", baseTypeName.TypeArguments));
}
}
}
public void AddAssociationFrom(PropertyDeclarationSyntax node)
{
var baseNode = node.Type as SimpleNameSyntax;
var subNode = node.Parent as BaseTypeDeclarationSyntax;
if (baseNode == null || subNode == null)
{
return;
}
var symbol = node.Initializer == null ? "-->" : "o->";
var baseName = TypeNameText.From(baseNode);
var subName = TypeNameText.From(subNode);
if (node?.Type?.ToString()?.ToLower()?.Contains("list") ?? false)
{
baseName.Identifier = baseName.TypeArguments.Replace("<", "").Replace(">", "");
_items.Add(new Relationship(subName, baseName, symbol, "", node.Identifier.ToString()));
}
else
{
_items.Add(new Relationship(subName, baseName, symbol, "", node.Identifier.ToString() + baseName.TypeArguments));
}
}
private void VisitTypeDeclaration(TypeDeclarationSyntax node, Action visitBase)
{
if (SkipInnerTypeDeclaration(node))
{
return;
}
_relationships.AddInnerclassRelationFrom(node);
_relationships.AddInheritanceFrom(node);
var modifiers = GetTypeModifiersText(node.Modifiers);
var keyword = (node.Modifiers.Any(SyntaxKind.AbstractKeyword) ? "abstract " : "")
+ node.Keyword.ToString();
var typeName = TypeNameText.From(node);
var name = typeName.Identifier;
var typeParam = typeName.TypeArguments;
var type = $"{name}{typeParam}";
types.Add(name);
WriteLine($"{keyword} {type} {modifiers}{{");
nestingDepth++;
visitBase();
nestingDepth--;
WriteLine("}");
}
private void GenerateAdditionalGenericTypeDeclaration(GenericNameSyntax genericNode)
{
var typename = TypeNameText.From(genericNode);
if (!types.Contains(typename.Identifier))
{
WriteLine($"class {typename.Identifier}{typename.TypeArguments} {{");
WriteLine("}");
types.Add(typename.Identifier);
}
}
public void AddInnerclassRelationFrom(SyntaxNode node)
{
if (!(node.Parent is BaseTypeDeclarationSyntax outerTypeNode) || !(node is BaseTypeDeclarationSyntax innerTypeNode))
{
return;
}
var outerTypeName = TypeNameText.From(outerTypeNode);
var innerTypeName = TypeNameText.From(innerTypeNode);
items.Add(new Relationship(outerTypeName, innerTypeName, "+--"));
}
public void AddAssociationFrom(PropertyDeclarationSyntax node)
{
if (!(node.Type is SimpleNameSyntax baseNode) || !(node.Parent is BaseTypeDeclarationSyntax subNode))
{
return;
}
var symbol = node.Initializer == null ? "-->" : "o->";
var baseName = TypeNameText.From(baseNode);
var subName = TypeNameText.From(subNode);
items.Add(new Relationship(subName, baseName, symbol, "", node.Identifier.ToString() + baseName.TypeArguments));
}
public void AddInnerclassRelationFrom(SyntaxNode node)
{
var outerTypeNode = node.Parent as BaseTypeDeclarationSyntax;
var innerTypeNode = node as BaseTypeDeclarationSyntax;
if (outerTypeNode == null || innerTypeNode == null)
{
return;
}
var outerTypeName = TypeNameText.From(outerTypeNode);
var innerTypeName = TypeNameText.From(innerTypeNode);
_items.Add(new Relationship(outerTypeName, innerTypeName, "+--"));
}
public void AddAssociationFrom(FieldDeclarationSyntax node, VariableDeclaratorSyntax field)
{
var baseNode = node.Declaration.Type as SimpleNameSyntax;
var subNode = node.Parent as BaseTypeDeclarationSyntax;
if (baseNode == null || subNode == null)
{
return;
}
var symbol = field.Initializer == null ? "-->" : "o->";
var baseName = TypeNameText.From(baseNode);
var subName = TypeNameText.From(subNode);
_items.Add(new Relationship(subName, baseName, symbol, "", field.Identifier.ToString() + baseName.TypeArguments));
}
private void GenerateInnerTypeDeclarations()
{
foreach (var node in _innerTypeDeclarationNodes)
{
var generator = new ClassDiagramGenerator(writer, indent);
generator.GenerateInternal(node);
var outerTypeNode = node.Parent as BaseTypeDeclarationSyntax;
var innerTypeNode = node as BaseTypeDeclarationSyntax;
if (outerTypeNode != null && innerTypeNode != null)
{
var outerTypeName = TypeNameText.From(outerTypeNode);
var innerTypeName = TypeNameText.From(innerTypeNode);
WriteLine($"{outerTypeName.Identifier} +-- {innerTypeName.Identifier}");
}
}
}
public void AddInheritanceFrom(TypeDeclarationSyntax syntax)
{
if (syntax.BaseList == null)
{
return;
}
var subTypeName = TypeNameText.From(syntax);
foreach (var typeStntax in syntax.BaseList.Types)
{
if (!(typeStntax.Type is SimpleNameSyntax typeNameSyntax))
{
continue;
}
var baseTypeName = TypeNameText.From(typeNameSyntax);
items.Add(new Relationship(baseTypeName, subTypeName, "<|--", baseTypeName.TypeArguments));
}
}
public void AddFrom(TypeDeclarationSyntax syntax)
{
if (syntax.BaseList == null)
{
return;
}
var subTypeName = TypeNameText.From(syntax);
foreach (var typeStntax in syntax.BaseList.Types)
{
var typeNameSyntax = typeStntax.Type as SimpleNameSyntax;
if (typeNameSyntax == null)
{
continue;
}
var baseTypeName = TypeNameText.From(typeNameSyntax);
_items.Add(new InheritanceRelationsip(baseTypeName, subTypeName));
}
}
