1 package org.kite9.diagram.builders;
2
3 import java.lang.reflect.Method;
4 import java.lang.reflect.Modifier;
5 import java.lang.reflect.Type;
6 import java.util.ArrayList;
7 import java.util.List;
8
9 import org.kite9.framework.model.MemberHandle;
10 import org.kite9.framework.model.ProjectModel;
11
12 public class MethodBuilder extends AbstractAnnotatedElementBuilder<Method> {
13
14 public MethodBuilder(List<Tie<? extends Object, Method>> ties, ProjectModel model) {
15 super(ties, model);
16 }
17
18 public MethodBuilder show(Format f) {
19 return (MethodBuilder) super.show(f);
20 }
21
22 public ClassBuilder withReturns(Format f) {
23 List<Tie<? extends Object, Class<?>>> ties = new ArrayList<Tie<? extends Object, Class<?>>>();
24
25 for (Method m : allElements) {
26 ties.add(new Tie<Method, Class<?>>(m, Relationship.RETURNS, m.getReturnType()));
27 }
28 return new ClassBuilder(ties, model);
29 }
30
31 public MethodBuilder showReturns(Format f) {
32 for (Tie<? extends Object, Method> m : ties) {
33 f.write(m.getObject(), Relationship.RETURNS, m.getObject().getGenericReturnType());
34 }
35 return this;
36 }
37
38 public MethodBuilder showParameters(Format f) {
39 for (Tie<? extends Object, Method> m : ties) {
40 for (Type t : m.getObject().getGenericParameterTypes()) {
41 f.write(m.getObject(), HasRelationship.PARAMETER, t);
42 }
43 }
44 return this;
45 }
46
47 public MethodBuilder showVisibility(Format f) {
48 for (Tie<? extends Object, Method> m : ties) {
49 if (Modifier.isPublic(m.getObject().getModifiers())) {
50 f.write(m.getObject(), HasRelationship.VISIBILITY, new JavaModifier("public"));
51 } else if (Modifier.isPrivate(m.getObject().getModifiers())) {
52 f.write(m.getObject(), HasRelationship.VISIBILITY, new JavaModifier("private"));
53 } else if (Modifier.isProtected(m.getObject().getModifiers())) {
54 f.write(m.getObject(), HasRelationship.VISIBILITY, new JavaModifier("protected"));
55 }
56 }
57 return this;
58 }
59
60 /***
61 * Returns the methods which call this one.
62 *
63 * @param f
64 * @return
65 */
66 public MethodBuilder withCallingMethods(Filter<? super Method> f) {
67 final ClassLoader cl = Thread.currentThread().getContextClassLoader();
68
69 List<Tie<? extends Object, Method>> ties = new ArrayList<Tie<? extends Object, Method>>();
70 for (Method m : allElements) {
71 for (MemberHandle mh : model.getCalledBy(new MemberHandle(m))) {
72 Method m2 = MemberHandle.hydrateMethod(mh, cl);
73 if ((f == null) || (f.accept(m2))) {
74 ties.add(new Tie<Method, Method>(m, Relationship.CALLED_BY, m2));
75 }
76 }
77 }
78
79 return new MethodBuilder(ties, model);
80 }
81
82 /***
83 * Returns classes of methods which call this one
84 */
85 public ClassBuilder withCallingClasses(Filter<? super Class<?>> f) {
86 final ClassLoader cl = Thread.currentThread().getContextClassLoader();
87 List<Tie<? extends Object, Class<?>>> ties = new ArrayList<Tie<? extends Object, Class<?>>>();
88 for (Method m : allElements) {
89 for (MemberHandle mh : model.getCalledBy(new MemberHandle(m))) {
90 Method m2 = MemberHandle.hydrateMethod(mh, cl);
91 Class<?> c2 = m2.getDeclaringClass();
92 if ((f == null) || (f.accept(c2))) {
93 ties.add(new Tie<Method, Class<?>>(m, Relationship.CALLED_BY, c2));
94 }
95 }
96 }
97
98 return new ClassBuilder(ties, model);
99 }
100
101 /***
102 * Returns methods which are called by this one
103 */
104 public MethodBuilder withCalledMethods(Filter<? super Method> f) {
105 final ClassLoader cl = Thread.currentThread().getContextClassLoader();
106 List<Tie<? extends Object, Method>> ties = new ArrayList<Tie<? extends Object, Method>>();
107 for (Method m : allElements) {
108 for (MemberHandle mh : model.getCalls(new MemberHandle(m))) {
109 Method m2 = MemberHandle.hydrateMethod(mh, cl);
110 if ((f == null) || (f.accept(m2))) {
111 ties.add(new Tie<Method, Method>(m, Relationship.CALLS, m2));
112 }
113 }
114 }
115
116 return new MethodBuilder(ties, model);
117 }
118
119 /***
120 * Returns classes of methods which call this one
121 */
122 public ClassBuilder withDeclaringClasses(Filter<? super Class<?>> f) {
123 List<Tie<? extends Object, Class<?>>> ties = new ArrayList<Tie<? extends Object, Class<?>>>();
124 for (Method m : allElements) {
125 Class<?> c2 = m.getDeclaringClass();
126 if ((f == null) || (f.accept(c2))) {
127 ties.add(new Tie<Method, Class<?>>(m, HasRelationship.METHOD_OF, c2));
128 }
129
130 }
131
132 return new ClassBuilder(ties, model);
133 }
134
135 @Override
136 public MethodBuilder reduce(Filter<? super Method> f) {
137 return new MethodBuilder(reduceInner(f), model);
138 }
139 }