15191557690

Committed 22 May 2025 04:10PM UTC coverage: 50.616% (+0.6%) from 49.972%

Build # 15191557690

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #127 from moosetechnology/new-generics-implementation

New generics implementation

Run Details

1884 of 3956 branches covered (47.62%)

Branch coverage included in aggregate %.

513 of 1119 new or added lines in 53 files covered. (45.84%)

53 existing lines in 10 files now uncovered.

4277 of 8216 relevant lines covered (52.06%)

2.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

27.7

/app/src/main/java/org/moosetechnology/model/famix/famixjavaentities/TypeParameter.java

// Automagically generated code, please do not change
package org.moosetechnology.model.famix.famixjavaentities;

import ch.akuhn.fame.FameDescription;
import ch.akuhn.fame.FamePackage;
import ch.akuhn.fame.FameProperty;
import ch.akuhn.fame.internal.MultivalueSet;
import java.util.*;

import org.moosetechnology.model.famix.famixtraits.*;

@FamePackage("Famix-Java-Entities")
@FameDescription("TypeParameter")
public class TypeParameter extends Type implements TBounded, TThrowable, TTypeArgument, TTypeParameter {

    private Collection<TWithExceptions> catchingEntities;

    private Collection<TConcretization> concretizations;

    private Collection<TWithExceptions> declaringEntities;

    private TParametricEntity genericEntity;

    private TBound lowerBound;

    private Collection<TConcretization> outgoingConcretizations;

    private Collection<TWithExceptions> throwingEntities;

    private TBound upperBound;



    @FameProperty(name = "catchingEntities", opposite = "caughtExceptions", derived = true)
    public Collection<TWithExceptions> getCatchingEntities() {
        if (catchingEntities == null) {
            catchingEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getCaughtExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getCaughtExceptions().add(TypeParameter.this);
                }
            };
        }
        return catchingEntities;
    }

    public void setCatchingEntities(Collection<? extends TWithExceptions> catchingEntities) {
        this.getCatchingEntities().clear();
        this.getCatchingEntities().addAll(catchingEntities);
    }

    public void addCatchingEntities(TWithExceptions one) {
        this.getCatchingEntities().add(one);
    }

    public void addCatchingEntities(TWithExceptions one, TWithExceptions... many) {
        this.getCatchingEntities().add(one);
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }

    public void addCatchingEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }

    public void addCatchingEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }

    public int numberOfCatchingEntities() {
        return getCatchingEntities().size();
    }

    public boolean hasCatchingEntities() {
        return !getCatchingEntities().isEmpty();
    }

    @FameProperty(name = "concretizations", opposite = "typeParameter", derived = true)
    public Collection<TConcretization> getConcretizations() {
        if (concretizations == null) {
            concretizations = new MultivalueSet<TConcretization>() {
                @Override
                protected void clearOpposite(TConcretization e) {
                    e.setTypeParameter(null);
                }
                @Override
                protected void setOpposite(TConcretization e) {
                    e.setTypeParameter(TypeParameter.this);
                }
            };
        }
        return concretizations;
    }

    public void setConcretizations(Collection<? extends TConcretization> concretizations) {
        this.getConcretizations().clear();
        this.getConcretizations().addAll(concretizations);
    }


    public void addConcretizations(TConcretization one) {
        this.getConcretizations().add(one);
    }

    public void addConcretizations(TConcretization one, TConcretization... many) {
        this.getConcretizations().add(one);
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }

    public void addConcretizations(Iterable<? extends TConcretization> many) {
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }

    public void addConcretizations(TConcretization[] many) {
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }

    public int numberOfConcretizations() {
        return getConcretizations().size();
    }

    public boolean hasConcretizations() {
        return !getConcretizations().isEmpty();
    }

    @FameProperty(name = "declaringEntities", opposite = "declaredExceptions", derived = true)
    public Collection<TWithExceptions> getDeclaringEntities() {
        if (declaringEntities == null) {
            declaringEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getDeclaredExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getDeclaredExceptions().add(TypeParameter.this);
                }
            };
        }
        return declaringEntities;
    }

    public void setDeclaringEntities(Collection<? extends TWithExceptions> declaringEntities) {
        this.getDeclaringEntities().clear();
        this.getDeclaringEntities().addAll(declaringEntities);
    }

    public void addDeclaringEntities(TWithExceptions one) {
        this.getDeclaringEntities().add(one);
    }

    public void addDeclaringEntities(TWithExceptions one, TWithExceptions... many) {
        this.getDeclaringEntities().add(one);
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }

    public void addDeclaringEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }

    public void addDeclaringEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }

    public int numberOfDeclaringEntities() {
        return getDeclaringEntities().size();
    }

    public boolean hasDeclaringEntities() {
        return !getDeclaringEntities().isEmpty();
    }

    @FameProperty(name = "genericEntity", opposite = "typeParameters")
    public TParametricEntity getGenericEntity() {
        return genericEntity;
    }

    public void setGenericEntity(TParametricEntity genericEntity) {
        if (this.genericEntity != null) {
            if (this.genericEntity.equals(genericEntity)) return;
            this.genericEntity.getTypeParameters().remove(this);
        }
        this.genericEntity = genericEntity;
        if (genericEntity == null) return;
        genericEntity.getTypeParameters().add(this);
    }

    @FameProperty(name = "lowerBound", opposite = "lowerBoundedWildcards")
    public TBound getLowerBound() {
        return lowerBound;
    }

    public void setLowerBound(TBound lowerBound) {
        if (this.lowerBound != null) {
            if (this.lowerBound.equals(lowerBound)) return;
            this.lowerBound.getLowerBoundedWildcards().remove(this);
        }
        this.lowerBound = lowerBound;
        if (lowerBound == null) return;
        lowerBound.getLowerBoundedWildcards().add(this);
    }

    @FameProperty(name = "outgoingConcretizations", opposite = "typeArgument", derived = true)
    public Collection<TConcretization> getOutgoingConcretizations() {
        if (outgoingConcretizations == null) {
            outgoingConcretizations = new MultivalueSet<TConcretization>() {
                @Override
                protected void clearOpposite(TConcretization e) {
                    e.setTypeArgument(null);
                }
                @Override
                protected void setOpposite(TConcretization e) {
                    e.setTypeArgument(TypeParameter.this);
                }
            };
        }
        return outgoingConcretizations;
    }

    public void setOutgoingConcretizations(Collection<? extends TConcretization> outgoingConcretizations) {
        this.getOutgoingConcretizations().clear();
        this.getOutgoingConcretizations().addAll(outgoingConcretizations);
    }


    public void addOutgoingConcretizations(TConcretization one) {
        this.getOutgoingConcretizations().add(one);
    }

    public void addOutgoingConcretizations(TConcretization one, TConcretization... many) {
        this.getOutgoingConcretizations().add(one);
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }

    public void addOutgoingConcretizations(Iterable<? extends TConcretization> many) {
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }

    public void addOutgoingConcretizations(TConcretization[] many) {
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }

    public int numberOfOutgoingConcretizations() {
        return getOutgoingConcretizations().size();
    }

    public boolean hasOutgoingConcretizations() {
        return !getOutgoingConcretizations().isEmpty();
    }

    @FameProperty(name = "throwingEntities", opposite = "thrownExceptions", derived = true)
    public Collection<TWithExceptions> getThrowingEntities() {
        if (throwingEntities == null) {
            throwingEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getThrownExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getThrownExceptions().add(TypeParameter.this);
                }
            };
        }
        return throwingEntities;
    }

    public void setThrowingEntities(Collection<? extends TWithExceptions> throwingEntities) {
        this.getThrowingEntities().clear();
        this.getThrowingEntities().addAll(throwingEntities);
    }

    public void addThrowingEntities(TWithExceptions one) {
        this.getThrowingEntities().add(one);
    }

    public void addThrowingEntities(TWithExceptions one, TWithExceptions... many) {
        this.getThrowingEntities().add(one);
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }

    public void addThrowingEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }

    public void addThrowingEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }

    public int numberOfThrowingEntities() {
        return getThrowingEntities().size();
    }

    public boolean hasThrowingEntities() {
        return !getThrowingEntities().isEmpty();
    }

    @FameProperty(name = "upperBound", opposite = "upperBoundedWildcards")
    public TBound getUpperBound() {
        return upperBound;
    }

    public void setUpperBound(TBound upperBound) {
        if (this.upperBound != null) {
            if (this.upperBound.equals(upperBound)) return;
            this.upperBound.getUpperBoundedWildcards().remove(this);
        }
        this.upperBound = upperBound;
        if (upperBound == null) return;
        upperBound.getUpperBoundedWildcards().add(this);
    }



}


1	// Automagically generated code, please do not change
2	package org.moosetechnology.model.famix.famixjavaentities;
3
4	import ch.akuhn.fame.FameDescription;
5	import ch.akuhn.fame.FamePackage;
6	import ch.akuhn.fame.FameProperty;
7	import ch.akuhn.fame.internal.MultivalueSet;
8	import java.util.*;
9
10	import org.moosetechnology.model.famix.famixtraits.*;
11
12	@FamePackage("Famix-Java-Entities")
13	@FameDescription("TypeParameter")
14	public class TypeParameter extends Type implements TBounded, TThrowable, TTypeArgument, TTypeParameter {	3✔
15
16	private Collection<TWithExceptions> catchingEntities;
17
18	private Collection<TConcretization> concretizations;
19
20	private Collection<TWithExceptions> declaringEntities;
21
22	private TParametricEntity genericEntity;
23
24	private TBound lowerBound;
25
26	private Collection<TConcretization> outgoingConcretizations;
27
28	private Collection<TWithExceptions> throwingEntities;
29
30	private TBound upperBound;
31
32
33
34	@FameProperty(name = "catchingEntities", opposite = "caughtExceptions", derived = true)
35	public Collection<TWithExceptions> getCatchingEntities() {
36	if (catchingEntities == null) {	3✔
37	catchingEntities = new MultivalueSet<TWithExceptions>() {	12✔
38	@Override
39	protected void clearOpposite(TWithExceptions e) {
NEW 40	e.getCaughtExceptions().remove(TypeParameter.this);	×
NEW 41	}	×
42	@Override
43	protected void setOpposite(TWithExceptions e) {
NEW 44	e.getCaughtExceptions().add(TypeParameter.this);	×
NEW 45	}	×
46	};
47	}
48	return catchingEntities;	3✔
49	}
50
51	public void setCatchingEntities(Collection<? extends TWithExceptions> catchingEntities) {
NEW 52	this.getCatchingEntities().clear();	×
NEW 53	this.getCatchingEntities().addAll(catchingEntities);	×
NEW 54	}	×
55
56	public void addCatchingEntities(TWithExceptions one) {
NEW 57	this.getCatchingEntities().add(one);	×
NEW 58	}	×
59
60	public void addCatchingEntities(TWithExceptions one, TWithExceptions... many) {
NEW 61	this.getCatchingEntities().add(one);	×
NEW 62	for (TWithExceptions each : many)	×
NEW 63	this.getCatchingEntities().add(each);	×
NEW 64	}	×
65
66	public void addCatchingEntities(Iterable<? extends TWithExceptions> many) {
NEW 67	for (TWithExceptions each : many)	×
NEW 68	this.getCatchingEntities().add(each);	×
NEW 69	}	×
70
71	public void addCatchingEntities(TWithExceptions[] many) {
NEW 72	for (TWithExceptions each : many)	×
NEW 73	this.getCatchingEntities().add(each);	×
NEW 74	}	×
75
76	public int numberOfCatchingEntities() {
NEW 77	return getCatchingEntities().size();	×
78	}
79
80	public boolean hasCatchingEntities() {
NEW 81	return !getCatchingEntities().isEmpty();	×
82	}
83
84	@FameProperty(name = "concretizations", opposite = "typeParameter", derived = true)
85	public Collection<TConcretization> getConcretizations() {
86	if (concretizations == null) {	3✔
87	concretizations = new MultivalueSet<TConcretization>() {	12✔
88	@Override
89	protected void clearOpposite(TConcretization e) {
NEW 90	e.setTypeParameter(null);	×
NEW 91	}	×
92	@Override
93	protected void setOpposite(TConcretization e) {
94	e.setTypeParameter(TypeParameter.this);	4✔
95	}	1✔
96	};
97	}
98	return concretizations;	3✔
99	}
100
101	public void setConcretizations(Collection<? extends TConcretization> concretizations) {
NEW 102	this.getConcretizations().clear();	×
NEW 103	this.getConcretizations().addAll(concretizations);	×
NEW 104	}	×
105
106
107	public void addConcretizations(TConcretization one) {
NEW 108	this.getConcretizations().add(one);	×
NEW 109	}	×
110
111	public void addConcretizations(TConcretization one, TConcretization... many) {
NEW 112	this.getConcretizations().add(one);	×
NEW 113	for (TConcretization each : many)	×
NEW 114	this.getConcretizations().add(each);	×
NEW 115	}	×
116
117	public void addConcretizations(Iterable<? extends TConcretization> many) {
NEW 118	for (TConcretization each : many)	×
NEW 119	this.getConcretizations().add(each);	×
NEW 120	}	×
121
122	public void addConcretizations(TConcretization[] many) {
NEW 123	for (TConcretization each : many)	×
NEW 124	this.getConcretizations().add(each);	×
NEW 125	}	×
126
127	public int numberOfConcretizations() {
128	return getConcretizations().size();	4✔
129	}
130
131	public boolean hasConcretizations() {
NEW 132	return !getConcretizations().isEmpty();	×
133	}
134
135	@FameProperty(name = "declaringEntities", opposite = "declaredExceptions", derived = true)
136	public Collection<TWithExceptions> getDeclaringEntities() {
137	if (declaringEntities == null) {	3✔
138	declaringEntities = new MultivalueSet<TWithExceptions>() {	12✔
139	@Override
140	protected void clearOpposite(TWithExceptions e) {
NEW 141	e.getDeclaredExceptions().remove(TypeParameter.this);	×
NEW 142	}	×
143	@Override
144	protected void setOpposite(TWithExceptions e) {
145	e.getDeclaredExceptions().add(TypeParameter.this);	6✔
146	}	1✔
147	};
148	}
149	return declaringEntities;	3✔
150	}
151
152	public void setDeclaringEntities(Collection<? extends TWithExceptions> declaringEntities) {
NEW 153	this.getDeclaringEntities().clear();	×
NEW 154	this.getDeclaringEntities().addAll(declaringEntities);	×
NEW 155	}	×
156
157	public void addDeclaringEntities(TWithExceptions one) {
NEW 158	this.getDeclaringEntities().add(one);	×
NEW 159	}	×
160
161	public void addDeclaringEntities(TWithExceptions one, TWithExceptions... many) {
NEW 162	this.getDeclaringEntities().add(one);	×
NEW 163	for (TWithExceptions each : many)	×
NEW 164	this.getDeclaringEntities().add(each);	×
NEW 165	}	×
166
167	public void addDeclaringEntities(Iterable<? extends TWithExceptions> many) {
NEW 168	for (TWithExceptions each : many)	×
NEW 169	this.getDeclaringEntities().add(each);	×
NEW 170	}	×
171
172	public void addDeclaringEntities(TWithExceptions[] many) {
NEW 173	for (TWithExceptions each : many)	×
NEW 174	this.getDeclaringEntities().add(each);	×
NEW 175	}	×
176
177	public int numberOfDeclaringEntities() {
NEW 178	return getDeclaringEntities().size();	×
179	}
180
181	public boolean hasDeclaringEntities() {
NEW 182	return !getDeclaringEntities().isEmpty();	×
183	}
184
185	@FameProperty(name = "genericEntity", opposite = "typeParameters")
186	public TParametricEntity getGenericEntity() {
187	return genericEntity;	3✔
188	}
189
190	public void setGenericEntity(TParametricEntity genericEntity) {
191	if (this.genericEntity != null) {	3✔
192	if (this.genericEntity.equals(genericEntity)) return;	6!
NEW 193	this.genericEntity.getTypeParameters().remove(this);	×
194	}
195	this.genericEntity = genericEntity;	3✔
196	if (genericEntity == null) return;	2!
197	genericEntity.getTypeParameters().add(this);	5✔
198	}	1✔
199
200	@FameProperty(name = "lowerBound", opposite = "lowerBoundedWildcards")
201	public TBound getLowerBound() {
202	return lowerBound;	3✔
203	}
204
205	public void setLowerBound(TBound lowerBound) {
NEW 206	if (this.lowerBound != null) {	×
NEW 207	if (this.lowerBound.equals(lowerBound)) return;	×
NEW 208	this.lowerBound.getLowerBoundedWildcards().remove(this);	×
209	}
NEW 210	this.lowerBound = lowerBound;	×
NEW 211	if (lowerBound == null) return;	×
NEW 212	lowerBound.getLowerBoundedWildcards().add(this);	×
NEW 213	}	×
214
215	@FameProperty(name = "outgoingConcretizations", opposite = "typeArgument", derived = true)
216	public Collection<TConcretization> getOutgoingConcretizations() {
217	if (outgoingConcretizations == null) {	3✔
218	outgoingConcretizations = new MultivalueSet<TConcretization>() {	12✔
219	@Override
220	protected void clearOpposite(TConcretization e) {
NEW 221	e.setTypeArgument(null);	×
NEW 222	}	×
223	@Override
224	protected void setOpposite(TConcretization e) {
225	e.setTypeArgument(TypeParameter.this);	4✔
226	}	1✔
227	};
228	}
229	return outgoingConcretizations;	3✔
230	}
231
232	public void setOutgoingConcretizations(Collection<? extends TConcretization> outgoingConcretizations) {
NEW 233	this.getOutgoingConcretizations().clear();	×
NEW 234	this.getOutgoingConcretizations().addAll(outgoingConcretizations);	×
NEW 235	}	×
236
237
238	public void addOutgoingConcretizations(TConcretization one) {
NEW 239	this.getOutgoingConcretizations().add(one);	×
NEW 240	}	×
241
242	public void addOutgoingConcretizations(TConcretization one, TConcretization... many) {
NEW 243	this.getOutgoingConcretizations().add(one);	×
NEW 244	for (TConcretization each : many)	×
NEW 245	this.getOutgoingConcretizations().add(each);	×
NEW 246	}	×
247
248	public void addOutgoingConcretizations(Iterable<? extends TConcretization> many) {
NEW 249	for (TConcretization each : many)	×
NEW 250	this.getOutgoingConcretizations().add(each);	×
NEW 251	}	×
252
253	public void addOutgoingConcretizations(TConcretization[] many) {
NEW 254	for (TConcretization each : many)	×
NEW 255	this.getOutgoingConcretizations().add(each);	×
NEW 256	}	×
257
258	public int numberOfOutgoingConcretizations() {
NEW 259	return getOutgoingConcretizations().size();	×
260	}
261
262	public boolean hasOutgoingConcretizations() {
NEW 263	return !getOutgoingConcretizations().isEmpty();	×
264	}
265
266	@FameProperty(name = "throwingEntities", opposite = "thrownExceptions", derived = true)
267	public Collection<TWithExceptions> getThrowingEntities() {
268	if (throwingEntities == null) {	3✔
269	throwingEntities = new MultivalueSet<TWithExceptions>() {	12✔
270	@Override
271	protected void clearOpposite(TWithExceptions e) {
NEW 272	e.getThrownExceptions().remove(TypeParameter.this);	×
NEW 273	}	×
274	@Override
275	protected void setOpposite(TWithExceptions e) {
NEW 276	e.getThrownExceptions().add(TypeParameter.this);	×
NEW 277	}	×
278	};
279	}
280	return throwingEntities;	3✔
281	}
282
283	public void setThrowingEntities(Collection<? extends TWithExceptions> throwingEntities) {
NEW 284	this.getThrowingEntities().clear();	×
NEW 285	this.getThrowingEntities().addAll(throwingEntities);	×
NEW 286	}	×
287
288	public void addThrowingEntities(TWithExceptions one) {
NEW 289	this.getThrowingEntities().add(one);	×
NEW 290	}	×
291
292	public void addThrowingEntities(TWithExceptions one, TWithExceptions... many) {
NEW 293	this.getThrowingEntities().add(one);	×
NEW 294	for (TWithExceptions each : many)	×
NEW 295	this.getThrowingEntities().add(each);	×
NEW 296	}	×
297
298	public void addThrowingEntities(Iterable<? extends TWithExceptions> many) {
NEW 299	for (TWithExceptions each : many)	×
NEW 300	this.getThrowingEntities().add(each);	×
NEW 301	}	×
302
303	public void addThrowingEntities(TWithExceptions[] many) {
NEW 304	for (TWithExceptions each : many)	×
NEW 305	this.getThrowingEntities().add(each);	×
NEW 306	}	×
307
308	public int numberOfThrowingEntities() {
NEW 309	return getThrowingEntities().size();	×
310	}
311
312	public boolean hasThrowingEntities() {
NEW 313	return !getThrowingEntities().isEmpty();	×
314	}
315
316	@FameProperty(name = "upperBound", opposite = "upperBoundedWildcards")
317	public TBound getUpperBound() {
318	return upperBound;	3✔
319	}
320
321	public void setUpperBound(TBound upperBound) {
322	if (this.upperBound != null) {	3✔
323	if (this.upperBound.equals(upperBound)) return;	6✔
324	this.upperBound.getUpperBoundedWildcards().remove(this);	6✔
325	}
326	this.upperBound = upperBound;	3✔
327	if (upperBound == null) return;	3✔
328	upperBound.getUpperBoundedWildcards().add(this);	5✔
329	}	1✔
330
331
332
333	}
334

moosetechnology / VerveineJ / 15191557690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous