jdk.internal.dynalink.support.Lookup Java Examples

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

@Override
MethodHandle getTarget(MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

@Override
MethodHandle getTarget(final MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

@Override
MethodHandle getTarget(MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(final AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

/**
 * Unreflects a method handle from a Method or a Constructor using safe (zero-privilege) unreflection. Should be
 * only used for methods and constructors that are not caller sensitive. If a caller sensitive method were
 * unreflected through this mechanism, it would not be a security issue, but would be bound to the zero-privilege
 * unreflector as its caller, and thus completely useless.
 * @param m the method or constructor
 * @return the method handle
 */
private static MethodHandle unreflectSafely(AccessibleObject m) {
    if(m instanceof Method) {
        final Method reflMethod = (Method)m;
        final MethodHandle handle = Lookup.PUBLIC.unreflect(reflMethod);
        if(Modifier.isStatic(reflMethod.getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(handle);
        }
        return handle;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.PUBLIC.unreflectConstructor((Constructor<?>)m));
}
 

private static java.lang.invoke.MethodHandles.Lookup getCurrentLookup() {
    final LinkRequest currentRequest = AccessController.doPrivileged(new PrivilegedAction<LinkRequest>() {
        @Override
        public LinkRequest run() {
            return LinkerServicesImpl.getCurrentLinkRequest();
        }
    });
    return currentRequest == null ? MethodHandles.publicLookup() : currentRequest.getCallSiteDescriptor().getLookup();
}
 

@Override
MethodHandle getTarget(MethodHandles.Lookup lookup) {
    if(target instanceof Method) {
        final MethodHandle mh = Lookup.unreflect(lookup, (Method)target);
        if(Modifier.isStatic(((Member)target).getModifiers())) {
            return StaticClassIntrospector.editStaticMethodHandle(mh);
        }
        return mh;
    }
    return StaticClassIntrospector.editConstructorMethodHandle(Lookup.unreflectConstructor(lookup,
            (Constructor<?>)target));
}
 

MethodHandle unreflectGetter(final Field field) {
    return editMethodHandle(Lookup.PUBLIC.unreflectGetter(field));
}
 

MethodHandle unreflectSetter(Field field) {
    return editMethodHandle(Lookup.PUBLIC.unreflectSetter(field));
}
 

private static MethodHandle findRangeCheck(Class<?> collectionType) {
    return Lookup.findOwnStatic(MethodHandles.lookup(), "rangeCheck", boolean.class, collectionType, Object.class);
}
 

MethodHandle unreflectSetter(final Field field) {
    return editMethodHandle(Lookup.PUBLIC.unreflectSetter(field));
}
 

private static MethodHandle findRangeCheck(Class<?> collectionType) {
    return Lookup.findOwnStatic(MethodHandles.lookup(), "rangeCheck", boolean.class, collectionType, Object.class);
}
 

MethodHandle unreflectSetter(Field field) {
    return editMethodHandle(Lookup.PUBLIC.unreflectSetter(field));
}