Java Code Examples for net.bytebuddy.dynamic.DynamicType#Builder

@Override
public <E> DynamicType.Builder<E> processMethod(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation)
{
    String methodName = method.getName();
    if (methodName.startsWith("get"))
        return createInterceptor(builder, method);
    else if (methodName.startsWith("set"))
        return createInterceptor(builder, method);

    throw new WindupException("Only get* and set* method names are supported for @" + MapInAdjacentProperties.class.getSimpleName());
}
 

@Override
protected Class<?> buildResponseClass(final Class<?> clz, final Method method, final Naming naming) {
    DynamicType.Builder<?> builder = new ByteBuddy().
            with(new SimpleNamingStrategy(naming.getFullName())).
            subclass(Object.class).
            implement(Serializable.class).
            defineProperty(GrpcType.F_RESULT, method.getGenericReturnType());
    return builder.make().load(Thread.currentThread().getContextClassLoader()).getLoaded();
}
 

private DynamicType.Builder<?> createField(DynamicType.Builder<?> builder,
                                           POJOProperty property,
                                           TypeDefinition typeDefinition) {
    return builder.defineField(
            property.getName(),
            typeDefinition,
            Visibility.PROTECTED
    );
}
 

@Override
public <E> DynamicType.Builder<E> processMethod(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    final java.lang.reflect.Parameter[] arguments = method.getParameters();

    if (ReflectionUtility.isGetMethod(method))
        if (arguments == null || arguments.length == 0)
            return this.getNode(builder, method, annotation);
        else
            throw new IllegalStateException(method.getName() + " was annotated with @InVertex but had arguments.");
    else
        throw new IllegalStateException(method.getName() + " was annotated with @InVertex but did not begin with: get");
}
 

private static DynamicType.Builder<?> addFieldWithGetterAndSetter(
		DynamicType.Builder<?> builder,
		Class<?> type,
		String fieldName,
		String getterName,
		String setterName) {
	return builder
			.defineField( fieldName, type, Visibility.PRIVATE, FieldPersistence.TRANSIENT )
					.annotateField( AnnotationDescription.Builder.ofType( Transient.class ).build() )
			.defineMethod( getterName, type, Visibility.PUBLIC )
					.intercept( FieldAccessor.ofField( fieldName ) )
			.defineMethod( setterName, void.class, Visibility.PUBLIC )
					.withParameters( type )
					.intercept( FieldAccessor.ofField( fieldName ) );
}
 

protected DynamicType.Builder createDisabledRetention(Class<?> annotatedClass) {
    return new ByteBuddy().with(AnnotationRetention.DISABLED).rebase(annotatedClass);
}
 

private <E> DynamicType.Builder<E> addVertexByTypeTypedEdge(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(AddVertexByTypeTypedEdgeInterceptor.class));
}
 

private <E> DynamicType.Builder<E> removeVertex(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(RemoveVertexInterceptor.class));
}
 

private Unloaded<?> make(DynamicType.Builder<?> builder) {
	return make( null, builder );
}
 

protected DynamicType.Builder<?> create(Class<?> type) {
    return new ByteBuddy().redefine(type);
}
 

private <E> DynamicType.Builder<E> getEdgeDefault(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(GetEdgeDefaultInterceptor.class));
}
 

public DynamicType.Builder<?> apply(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassFileLocator classFileLocator) {
    return builder.method(named("foo")).intercept(FixedValue.value("qux"));
}
 

private <E> DynamicType.Builder<E> setVertexIterator(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(SetVertexIteratorInterceptor.class));
}
 

protected DynamicType.Builder createDisabledRetention(Class<?> annotatedClass) {
    return new ByteBuddy().with(AnnotationRetention.DISABLED).redefine(annotatedClass);
}
 

public DynamicType.Builder<?> apply(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassFileLocator classFileLocator) {
    throw new RuntimeException();
}
 

private <E> DynamicType.Builder<E> getEdgesSetDefault(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(GetEdgesSetDefaultInterceptor.class));
}
 

private <E> DynamicType.Builder<E> getVertexDefault(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    return builder.method(ElementMatchers.is(method)).intercept(MethodDelegation.to(GetVertexDefaultInterceptor.class));
}
 

/**
 * {@inheritDoc}
 */
public DynamicType.Builder<?> builder(ByteBuddy byteBuddy, TypeDescription typeDescription, ClassFileLocator classFileLocator) {
    return byteBuddy.rebase(typeDescription, classFileLocator);
}
 

protected DynamicType.Builder<?> createPlainWithoutValidation() {
    return new ByteBuddy().with(TypeValidation.DISABLED).subclass(Object.class);
}
 

protected abstract DynamicType.Builder<?> createDisabledRetention(Class<?> annotatedClass);