public void VisitDiagramCreated(UmlDiagram diagram)
{
if (_action != null)
{
_action(diagram);
}
}
public void VisitBeforeEmit(UmlDiagram diagram)
{
var typesToAdd = new List <Type>();
foreach (var diagClass in diagram.GetEntities())
{
foreach (var mem in diagClass.Members)
{
switch (mem)
{
case MethodUmlMember methodUmlMember:
var types1 = ProcessMethod(diagram, diagClass, methodUmlMember);
typesToAdd.AddRange(types1);
break;
case PropertyUmlMember propertyUmlMember:
var types2 = ProcessProperty(diagram, diagClass, propertyUmlMember);
typesToAdd.AddRange(types2);
break;
}
}
}
foreach (var i in typesToAdd)
{
diagram.UpdateTypeInfo(i, null);
}
}
public void Visit(UmlDiagram diagram, UmlEntity info)
{
var t = info.Type;
foreach (var att in t.GetCustomAttributes <T>())
{
VisitInternal(diagram, info, att);
}
}
public void Visit(UmlDiagram diagram, UmlEntity info)
{
var att = info.Type.GetCustomAttribute <T>();
if (att == null)
{
return;
}
VisitInternal(diagram, info, att);
}
private static IEnumerable <Type> ProcessMethod(UmlDiagram diagram, UmlEntity diagClass, MethodUmlMember member)
{
if (diagClass.Type != member.Method.DeclaringType)
{
if (diagram.ContainsType(diagClass.Type.BaseType.MeOrGeneric()))
{
member.HideOnList = true;
yield break;
}
}
var att = member.Method.GetCustomAttribute <UmlRelationAttribute>();
if (att == null)
{
yield break;
}
var ti = new TypeExInfo(att.RelatedType ?? member.Method.ReturnType, att.DoNotResolveCollections);
if (!diagram.ContainsType(ti.ElementType))
{
yield break;
}
// create relation
member.HideOnList = true;
var owner = diagClass.Type;
var component = ti.ElementType;
const string ownerLabel = "";
const string componentLabel = "";
var arrow = UmlRelationArrow.MkArrow(att, GetMultiplicity(att.Multiple, ti.IsCollection));
if (att.ForceAddToDiagram)
{
yield return(ti.ElementType);
}
var rel = new UmlRelation
{
Left = new UmlRelationEnd(diagram.GetTypeName(owner), ownerLabel),
Right = new UmlRelationEnd(diagram.GetTypeName(component), componentLabel),
Arrow = arrow,
Label = string.IsNullOrEmpty(att.Name) ? GetLabel(member) : att.Name
}
.WithNote(att)
.WitCreatorMeta <MemberToRelationVisitor>(owner, component);
rel.Tag = att.Tag;
rel.BaseMember = member;
diagram.Relations.Add(rel);
}
public void VisitBeforeEmit(UmlDiagram diagram)
{
foreach (var info in diagram.GetEntities())
{
UpdateContainerFromAttributes(info, info.Type);
foreach (var i in info.Members)
{
UpdateContainerFromAttributes(i, i.GetMemberInfo());
}
}
}
private static UmlRelation Inherits(Type baseClass, Type subClass, UmlDiagram diagram)
{
var rel = new UmlRelation
{
Left = new UmlRelationEnd(diagram.GetTypeName(subClass)),
Right = new UmlRelationEnd(diagram.GetTypeName(baseClass)),
Arrow = UmlRelationArrow.InheritRight
}
.WitCreatorMeta <AddInheritRelationVisitor>(subClass, baseClass);
return(rel);
}
private static bool CanAddRelation(UmlDiagram diagram, PropertyUmlMember prop)
{
var reflectedType = prop.Property.ReflectedType;
var interfaces = reflectedType.GetInterfaces();
var propertyName = prop.Property.Name;
if (reflectedType.IsInterface)
{
return(true);
}
foreach (var intf in interfaces)
{
if (diagram.ContainsType(intf))
{
//
var map = reflectedType.GetInterfaceMap(intf);
foreach (var i in map.TargetMethods)
{
if (!IsPropertyMethod(i, propertyName))
{
continue;
}
// don't add relation if there is interface on the diagrarm with same relation
if (prop.Property.GetMethod == i || prop.Property.SetMethod == i)
{
return(false);
}
}
}
}
var declaringType = prop.Property.DeclaringType;
if (reflectedType != declaringType)
{
var tt = reflectedType.BaseType;
while (tt != null)
{
if (diagram.ContainsType(tt))
{
return(false);
}
if (tt == declaringType)
{
break;
}
tt = tt.BaseType;
}
}
return(true);
}
public void Visit(UmlDiagram diagram, UmlEntity info)
{
var members = info.Type.GetMembers(MyBindingFlags);
foreach (var memberInfo in members)
{
var typeExInfo = GetTi(memberInfo);
if (typeExInfo != null)
{
diagram.UpdateTypeInfo(typeExInfo.ElementType, null);
}
}
}
public void Visit(UmlDiagram diagram, UmlEntity info)
{
for (var index = 0; index < info.Members.Count; index++)
{
var umlMember = info.Members[index];
var memberInfo = umlMember.GetMemberInfo();
var hide = ShouldBeHidden(memberInfo);
if (hide)
{
umlMember.HideOnList = true;
}
}
}
public SetFlagResult DefaultHideMethod(UmlDiagram diagram, UmlMember umlMember, UmlEntity entity)
{
bool AlreadyOnDiagram(Type entityType, Type declaringType)
{
if (entityType == null || entityType == declaringType)
{
return(false);
}
while (true)
{
var bt = entityType.BaseType.MeOrGeneric();
if (bt == null)
{
return(false);
}
if (diagram.ContainsType(bt))
{
return(true);
}
entityType = bt;
}
}
if (!(umlMember is MethodUmlMember mum))
{
return(SetFlagResult.LeaveUnchanged);
}
var mi = mum.Method;
if (mi.DeclaringType == typeof(object))
{
return(SetFlagResult.SetToTrue);
}
if (AlreadyOnDiagram(entity.Type, mi.DeclaringType))
{
return(SetFlagResult.SetToTrue);
}
if (HideShouldSerializeMethods)
{
if (IsShouldSerializeMethod(mi))
{
return(SetFlagResult.SetToTrue);
}
}
return(SetFlagResult.LeaveUnchanged);
}
public void Visit(Assembly assembly, UmlDiagram diagram)
{
var packages = diagram.Packages;
foreach (var attribute in assembly.GetCustomAttributes <UmlPackageStyleAttribute>())
{
if (!attribute.CanBeUsedFor(diagram))
{
continue;
}
var umlPackageName = new UmlPackageName(attribute.PackageName);
if (!packages.TryGetValue(umlPackageName, out var x))
{
packages[umlPackageName] = x = new UmlPackage();
}
x.Kind = attribute.Kind;
}
}
public override void WriteTo(CodeWriter cf, UmlDiagram diagram)
{
var code = Method.MethodToUml(diagram.GetTypeName);
code = GetCodePrefix() + code;
var lines = code.MakeAction(MaxLineLength, (lineIndex, text) =>
{
if (lineIndex == 1)
{
cf.IncIndent();
}
cf.Writeln(text);
});
if (lines > 1)
{
cf.DecIndent();
}
}
public void VisitBeforeEmit(UmlDiagram diagram)
{
foreach (var entity in diagram.GetEntities())
{
foreach (var me in entity.Members)
{
var hide = HideMember?.Invoke(diagram, me, entity) ?? SetFlagResult.LeaveUnchanged;
if (hide == SetFlagResult.LeaveUnchanged)
{
hide = DefaultHideMethod(diagram, me, entity);
}
if (hide != SetFlagResult.LeaveUnchanged)
{
me.HideOnList = hide == SetFlagResult.SetToTrue;
}
}
}
}
public UmlDiagram GetOrCreateDiagram(string diagramName)
{
if (Diagrams.TryGetValue(diagramName, out var x))
{
return(x);
}
Diagrams[diagramName] = x = new UmlDiagram
{
Name = diagramName,
Title = "Diagram " + diagramName
};
x.OnAddTypeToDiagram += XOnOnAddTypeToDiagram;
{
var handler = OnAddDiagram;
if (handler != null)
{
handler.Invoke(this, new AddDiagramEventArgs
{
Diagram = x
});
}
}
return(x);
}
public abstract void WriteTo(CodeWriter cf, UmlDiagram diagram);
public override void WriteTo(CodeWriter cf, UmlDiagram diagram)
{
var code = Method.MethodToUml(diagram.GetTypeName);
cf.Writeln(GetCodePrefix() + code);
}
protected abstract void VisitInternal(UmlDiagram diagram, UmlEntity info, [NotNull] T att);
public override void WriteTo(CodeWriter cf, UmlDiagram diagram)
{
var code = diagram.GetTypeName(Property.PropertyType) + " " + Property.Name;
cf.Writeln(GetCodePrefix() + code);
}
public override void WriteTo(CodeWriter cf, UmlDiagram diagram)
{
cf.Writeln(GetCodePrefix() + Text);
}
public void VisitBeforeEmit(UmlDiagram diagram)
{
foreach (var e in diagram.GetEntities())
{
var entityType = e.Type;
var bt = entityType.BaseType.MeOrGeneric();
if (entityType.BaseType != null && diagram.ContainsType(bt))
{
var rel = Inherits(bt, entityType, diagram).With(UmlArrowDirections.Up);
var a1 = entityType.BaseType.GetGenericTypeArgumentsIfPossible();
if (a1.Length > 0)
{
var a4 = entityType.BaseType.MeOrGeneric().GetGenericArguments();
var sb = new StringBuilder();
for (var i = 0; i < a4.Length; i++)
{
var t1 = a1[i];
var t2 = a4[i];
var txt = t2.Name + "=" + diagram.GetTypeName(t1);
if (i > 0)
{
sb.Append(", ");
}
sb.Append(txt);
}
rel.Label = sb.ToString();
}
diagram.Relations.Add(rel);
}
bool CanAddR(Type clasType, Type interfaceType)
{
clasType = clasType.BaseType;
while (clasType != null)
{
if (!diagram.ContainsType(clasType))
{
return(true);
}
if (clasType.GetInterfaces().Contains(interfaceType))
{
return(false);
}
clasType = clasType.BaseType;
}
return(true);
}
var entityInterfaces = entityType
.GetInterfaces()
.Select(a => a.MeOrGeneric())
.ToHashSet();
var hideRelationToInterface = new HashSet <Type>();
foreach (var entityInterface in entityInterfaces)
{
var baseInterfaces = entityInterface.GetInterfaces();
foreach (var baseI in baseInterfaces)
{
if (diagram.ContainsType(baseI))
{
hideRelationToInterface.Add(baseI);
}
}
}
foreach (var i in hideRelationToInterface)
{
entityInterfaces.Remove(i);
}
foreach (var interfaceType in entityInterfaces)
{
if (!diagram.ContainsType(interfaceType))
{
continue;
}
if (!CanAddR(entityType, interfaceType))
{
continue;
}
var umlRelation = Inherits(interfaceType, entityType, diagram)
.With(UmlArrowDirections.Up);
diagram.Relations.Add(umlRelation);
}
}
}
private IEnumerable <Type> ProcessProperty(UmlDiagram diagram, UmlEntity diagClass,
PropertyUmlMember property)
{
var decision = ConvertToRelation?.Invoke(property) ?? ChangeDecision.Auto;
if (decision == ChangeDecision.Auto)
{
if (property.Property.GetCustomAttribute <DontConvertToRelationAttribute>() != null)
{
decision = ChangeDecision.No;
}
else
{
decision = ChangeDecision.Yes;
}
}
if (decision == ChangeDecision.No)
{
yield break;
}
if (diagClass.Type != property.Property.DeclaringType)
{
if (diagram.ContainsType(diagClass.Type.BaseType))
{
property.HideOnList = true;
yield break;
}
}
var doNotResolveCollections =
property.Property.GetCustomAttribute <BaseRelationAttribute>()?.DoNotResolveCollections ?? false;
var ti = new TypeExInfo(property.Property.PropertyType, doNotResolveCollections);
if (!diagram.ContainsType(ti.ElementType))
{
yield break;
}
// create relation
if (!CanAddRelation(diagram, property))
{
yield break;
}
property.HideOnList = true;
var arrow = new UmlRelationArrow(
ArrowEnd.Empty,
ti.IsCollection ? ArrowEnd.Multiple : ArrowEnd.ArrowOpen);
var owner = diagClass.Type;
var arrowTargetType = ti.ElementType;
const string ownerLabel = "";
const string componentLabel = "";
var att = property.Property.GetCustomAttribute <UmlRelationAttribute>();
if (att != null)
{
var relationTi = new TypeExInfo(att.RelatedType ?? property.Property.PropertyType,
att.DoNotResolveCollections);
arrow = UmlRelationArrow.MkArrow(att, GetMultiplicity(att.Multiple, relationTi.IsCollection));
if (att.ForceAddToDiagram)
{
yield return(relationTi.ElementType);
}
arrowTargetType = relationTi.ElementType;
}
var rel = new UmlRelation
{
Left = new UmlRelationEnd(diagram.GetTypeName(owner), ownerLabel),
Right = new UmlRelationEnd(diagram.GetTypeName(arrowTargetType), componentLabel),
Arrow = arrow,
Label = string.IsNullOrEmpty(att?.Name) ? property.Name : att.Name
}
.WithNote(att)
.WitCreatorMeta <MemberToRelationVisitor>(owner, arrowTargetType);
rel.Tag = att?.Tag;
rel.BaseMember = property;
{
var eventHandler = AfterConversionProperty;
if (eventHandler != null)
{
var args = new AfterConversionPropertyEventArgs
{
Diagram = diagram,
Entity = diagClass,
BaseUmlMember = property,
Relation = rel
};
eventHandler(this, args);
}
}
diagram.Relations.Add(rel);
}
public void VisitDiagramCreated(UmlDiagram diagram)
{
}
public bool CanBeUsedFor(UmlDiagram diagram)
{
return(string.IsNullOrEmpty(DiagramName) ||
string.Equals(DiagramName, diagram?.Name.Trim(), StringComparison.OrdinalIgnoreCase));
}
public void Visit(UmlDiagram diagram, UmlEntity info)
{
var type = info.Type;
var properties = ScanProperties(type, ScanFlags);
info.Members.AddRange(properties);
var r = BindingFlags.Public | BindingFlags.NonPublic;
if (ScanFlags.HasFlag(ReflectionFlags.InstanceMethod))
{
r |= BindingFlags.Instance;
}
if (ScanFlags.HasFlag(ReflectionFlags.StaticMethod))
{
r |= BindingFlags.Static;
}
var methodInfos = type.GetMethods(r);
{
var h = SortAndPrepareMethods;
if (h != null)
{
var args = new SortAndPrepareMethodsEventArgs {
Methods = methodInfos
};
h.Invoke(this, args);
methodInfos = args.Methods;
}
}
foreach (var mi in methodInfos)
{
var add = CheckSkipDefault(mi);
var flag = GetMFlag(mi, ReflectionFlags.PublicMethod, ReflectionFlags.ProtectedMethod,
ReflectionFlags.PrivateMethod);
if (add)
{
if (!H(flag, ScanFlags))
{
add = false;
}
}
var h = AddTypeToDiagram;
if (h is null && !add)
{
continue;
}
var member = new MethodUmlMember
{
Group = 20,
Name = mi.Name,
Method = mi,
Visibility = GetVisibilityFromFlags(flag)
};
if (mi.IsAbstract)
{
member.Kind = UmlMemberKind.Abstract;
}
if (mi.IsStatic)
{
member.Kind = UmlMemberKind.Static;
}
if (h != null)
{
var args = new AddTypeToDiagramEventArgs
{
Decision = add ? AddDecision.Add : AddDecision.Skip,
Member = mi,
UmlMember = member
};
h(this, args);
if (args.Decision != AddDecision.Default)
{
add = args.Decision == AddDecision.Add;
}
}
if (!add)
{
continue;
}
info.Members.Add(member);
}
}
public void VisitBeforeEmit(UmlDiagram diagram)
{
}
