/** * Inserts the given statement list after a set of insertion points given by * a filter. */ @DerivedProperty <T extends CtStatementList> T insertAfter(Filter<? extends CtStatement> insertionPoints, CtStatementList statements);
@Override @UnsettableProperty public CtExecutable setParameters(List list) { // unsettable property return this; }
/** * Gets the last statement of this block. */ @DerivedProperty <T extends CtStatement> T getLastStatement();
@Override @UnsettableProperty public CtExecutable setThrownTypes(Set thrownTypes) { // unsettable property return this; }
/** * Returns the actual annotation (a dynamic proxy for this element). * * <p> * NOTE: before using an annotation proxy, you have to make sure that all * the types referenced by the annotation have been compiled and are in the * classpath so that accessed values can be converted into the actual types. */ @DerivedProperty A getActualAnnotation();
@Override @UnsettableProperty public <C extends CtExecutable<T>> C setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes) { return (C) this; }
/** * @return the original raw comment from the source file including comment prefix and suffix, indentation (including TABs) original EOLs, * based on the attached position object (the returned value is "derived" from the position). * If the file pointed to in the position object does not exist on disk anymore, * then the empty string "" is returned * Note: the call of {@link #setContent(String)} doesn't influence the returned value, only the value of the position object. */ @DerivedProperty String getRawContent();
@Override @UnsettableProperty public <F, C extends CtType<Object>> C addField(CtField<F> field) { // unsettable property return (C) this; }
/** * Useful proxy to {@link #getDefaultExpression()}. */ @Override @DerivedProperty CtExpression<T> getAssignment();
@Override @UnsettableProperty public <N, C extends CtType<Object>> C addNestedType(CtType<N> nestedType) { // unsettable property return (C) this; }
@Override @DerivedProperty public <T extends CtElement> T setParent(T parent) { return (T) this; }
@Override @UnsettableProperty public <C extends CtType<Object>> C setNestedTypes(Set<CtType<?>> nestedTypes) { // unsettable property return (C) this; }
/** * Returns always VOID. * * @see #getAccessedType() to get the accessed type. */ @Override @DerivedProperty CtTypeReference<Void> getType();
@Override @UnsettableProperty public <S, C extends CtType<Object>> C addSuperInterface(CtTypeReference<S> interfac) { // unsettable property return (C) this; }
/** * @return {@link #getAccessedType()}.isImplicit() */ @Override @DerivedProperty boolean isImplicit();
@Override @UnsettableProperty public <S> boolean removeSuperInterface(CtTypeReference<S> interfac) { // unsettable property return false; }
/** * Calls {@link #getAccessedType()}.setImplicit() */ @Override @DerivedProperty <E extends CtElement> E setImplicit(boolean implicit);
@Override @UnsettableProperty public <T extends CtBodyHolder> T setBody(CtStatement statement) { return (T) this; }
/** * Gets the fields declared by this type and by all its supertypes if * applicable. */ @DerivedProperty Collection<CtFieldReference<?>> getAllFields();
@Override @DerivedProperty public CtPackage getPackage() { return null; }