- * During construction of the call site, the {@code createTargetHook} is invoked to - * produce the actual target, as if by a call of the form - * {@code (MethodHandle) createTargetHook.invoke(this)}. - *
- * Note that user code cannot perform such an action directly in a subclass constructor, - * since the target must be fixed before the {@code ConstantCallSite} constructor returns. - *
- * The hook is said to bind the call site to a target method handle, - * and a typical action would be {@code someTarget.bindTo(this)}. - * However, the hook is free to take any action whatever, - * including ignoring the call site and returning a constant target. - *
- * The result returned by the hook must be a method handle of exactly - * the same type as the call site. - *
- * While the hook is being called, the new {@code ConstantCallSite} - * object is in a partially constructed state. - * In this state, - * a call to {@code getTarget}, or any other attempt to use the target, - * will result in an {@code IllegalStateException}. - * It is legal at all times to obtain the call site's type using the {@code type} method. - * - * @param targetType the type of the method handle to be permanently associated with this call site - * @param createTargetHook a method handle to invoke (on the call site) to produce the call site's target - * @throws WrongMethodTypeException if the hook cannot be invoked on the required arguments, - * or if the target returned by the hook is not of the given {@code targetType} - * @throws NullPointerException if the hook returns a null value - * @throws ClassCastException if the hook returns something other than a {@code MethodHandle} - * @throws Throwable anything else thrown by the hook function - */ - protected ConstantCallSite(MethodType targetType, MethodHandle createTargetHook) throws Throwable { - super(targetType, createTargetHook); - isFrozen = true; - } - - /** - * Returns the target method of the call site, which behaves - * like a {@code final} field of the {@code ConstantCallSite}. - * That is, the target is always the original value passed - * to the constructor call which created this instance. - * - * @return the immutable linkage state of this call site, a constant method handle - * @throws IllegalStateException if the {@code ConstantCallSite} constructor has not completed - */ - @Override public final MethodHandle getTarget() { - if (!isFrozen) throw new IllegalStateException(); - return target; - } - - /** - * Always throws an {@link UnsupportedOperationException}. - * This kind of call site cannot change its target. - * @param ignore a new target proposed for the call site, which is ignored - * @throws UnsupportedOperationException because this kind of call site cannot change its target - */ - @Override public final void setTarget(MethodHandle ignore) { - throw new UnsupportedOperationException(); - } - - /** - * Returns this call site's permanent target. - * Since that target will never change, this is a correct implementation - * of {@link CallSite#dynamicInvoker CallSite.dynamicInvoker}. - * @return the immutable linkage state of this call site, a constant method handle - * @throws IllegalStateException if the {@code ConstantCallSite} constructor has not completed - */ - @Override - public final MethodHandle dynamicInvoker() { - return getTarget(); - } -}