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