public FieldMetadataBuilder(final String declaredbyMetadataId, final FieldMetadata existing) { super(declaredbyMetadataId, existing); init(existing.getFieldName(), existing.getFieldType(), existing.getFieldInitializer()); this.commentStructure = existing.getCommentStructure(); }
public final boolean addConstructor(final ConstructorMetadata constructor) { if (constructor == null) { return false; } return addConstructor(new ConstructorMetadataBuilder(constructor)); }
/** * Ensures that the governor extends the given type, i.e. introduces that * type as a supertype iff it's not already one * * @param javaType the type to extend (required) * @since 1.2.0 */ protected final void ensureGovernorExtends(final JavaType javaType) { if (!governorTypeDetails.extendsType(javaType)) { builder.addExtendsTypes(javaType); } }
@Override public FieldMetadata build() { final FieldMetadataBuilder fieldMetadataBuilder = new FieldMetadataBuilder(declaredByMetadataId); fieldMetadataBuilder.setAnnotations(annotations); fieldMetadataBuilder.setFieldInitializer(fieldInitializer); fieldMetadataBuilder.setFieldName(fieldName); fieldMetadataBuilder.setFieldType(fieldType); fieldMetadataBuilder.setModifier(modifier); return fieldMetadataBuilder.build(); } }
@Override protected void onAddField(final FieldMetadataBuilder md) { Validate.isTrue(governor.getDeclaredField(md.getFieldName()) == null, "Field '%s' already defined in target type '%s' (ITD target '%s')", md.getFieldName(), governor.getName().getFullyQualifiedTypeName(), aspect.getFullyQualifiedTypeName()); Validate.isTrue(build().getDeclaredField(md.getFieldName()) == null, "Field '%s' already defined in ITD (ITD target '%s')", md.getFieldName(), aspect.getFullyQualifiedTypeName()); }
public MethodMetadataBuilder(final String declaredbyMetadataId, final MethodMetadata existing) { super(declaredbyMetadataId, existing); init(existing.getMethodName(), existing.getReturnType()); }
public final boolean addField(final FieldMetadata field) { if (field == null) { return false; } return addField(new FieldMetadataBuilder(field)); }
/** * Adds the given method to this builder * * @param method the method to add; can be <code>null</code> * @return <code>true</code> if the state of this builder changed */ public final boolean addMethod(final MethodMetadata method) { if (method == null) { return false; } return addMethod(new MethodMetadataBuilder(method)); }
/** * Ensures that the governor has provided constructor * * @param ConstructorMetadataBuilder the constructor to include(required) * @since 2.0 */ protected final void ensureGovernorHasConstructor( final ConstructorMetadataBuilder constructorMetadata) { if (governorTypeDetails.getDeclaredConstructor(AnnotatedJavaType .convertFromAnnotatedJavaTypes(constructorMetadata.getParameterTypes())) == null) { builder.addConstructor(constructorMetadata); } }
/** * Return true if field is annotated with @OneToOne or @ManyToOne JPA annotation * * @param field * @return */ private boolean isAnyToOneRelation(FieldMetadata field) { return field.getAnnotation(JpaJavaType.MANY_TO_ONE) != null || field.getAnnotation(JpaJavaType.ONE_TO_ONE) != null; }
@Override public PhysicalTypeCategory getPhysicalTypeCategory() { return cid.getPhysicalTypeCategory(); } };
/** * Ensures that the governor implements the given type. * * @param javaType the type to implement (required) * @since 1.2.0 */ protected final void ensureGovernorImplements(final JavaType javaType) { if (!governorTypeDetails.implementsType(javaType)) { builder.addImplementsType(javaType); } }
private boolean isAlreadyDefinedMethod(MethodMetadata method, Collection<MethodMetadata> values) { for (MethodMetadata value : values) { if (method.matchSignature(value)) { return true; } } return false; }
/** * Constructor * * @param declaredbyMetadataId * @param existing */ protected AbstractMemberHoldingTypeDetailsBuilder(final String declaredbyMetadataId, final MemberHoldingTypeDetails existing) { super(declaredbyMetadataId, existing); init(existing); }
public ImportMetadataBuilder(final String declaredbyMetadataId, final int modifier, final JavaPackage importPackage, final JavaType importType, final boolean isStatic, final boolean isAsterisk) { this(declaredbyMetadataId); setModifier(modifier); this.importPackage = importPackage; this.importType = importType; this.isStatic = isStatic; this.isAsterisk = isAsterisk; }
/** * Constructor * * @param declaredbyMetadataId * @param existing */ protected AbstractIdentifiableJavaStructureBuilder(final String declaredbyMetadataId, final IdentifiableJavaStructure existing) { super(existing); this.declaredByMetadataId = declaredbyMetadataId; this.modifier = existing.getModifier(); }
public InitializerMetadataBuilder(final String declaredbyMetadataId, final int modifier, boolean isStatic, final InvocableMemberBodyBuilder bodyBuilder) { this(declaredbyMetadataId); setModifier(modifier); if (modifier == Modifier.STATIC) { isStatic = true; } this.isStatic = isStatic; this.bodyBuilder = bodyBuilder; }
/** * Converts the annotation into a string-based form. * * @param annotation to covert (required) * @return a string-based representation (never null) */ public static String toSourceForm(final AnnotationMetadata annotation) { return toSourceForm(annotation, null); }
public FieldMetadataBuilder(final FieldMetadata existing) { super(existing); init(existing.getFieldName(), existing.getFieldType(), existing.getFieldInitializer()); this.commentStructure = existing.getCommentStructure(); }
public MethodMetadataBuilder(final MethodMetadata existing) { super(existing); init(existing.getMethodName(), existing.getReturnType()); }