Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.graalvm.polyglot.impl.ModuleToUnnamedAPIAccessGen Maven / Gradle / Ivy
package org.graalvm.polyglot.impl;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Executable;
import java.lang.reflect.Type;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.graalvm.polyglot.HostAccess.MutableTargetMapping;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.APIAccess;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractContextDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractEngineDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractExceptionDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractInstrumentDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractLanguageDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractSourceDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractSourceSectionDispatch;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractStackFrameImpl;
import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractValueDispatch;
import org.graalvm.polyglot.impl.ModuleToUnnamedBridge.ModuleToUnnamedAPIAccess;
import org.graalvm.polyglot.io.ByteSequence;
/**
* Generated code used for Truffle unnamed to named module bridge.
* This code allows polyglot on the classpath to delegate to polyglot on the module-path.
* This code is generated by the polyglot annotation processor.asdf
*/
final class ModuleToUnnamedAPIAccessGen extends ModuleToUnnamedAPIAccess {
private static final Handles HANDLES;
static {
Lookup lookup = methodHandleLookup();
if (lookup != null) {
try {
HANDLES = new Handles(lookup);
} catch (ReflectiveOperationException e) {
throw new InternalError("Failed to initialize method handles for module bridge.", e);
}
} else {
HANDLES = null;
}
}
final Object receiver;
public ModuleToUnnamedAPIAccessGen(Object receiver) {
this.receiver = Objects.requireNonNull(receiver);
}
@Override
public boolean allowsAccess(Object hostAccess_, AnnotatedElement element_) {
try {
boolean result = (boolean) HANDLES.allowsAccess_.invoke(receiver, hostAccess_, element_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean allowsAccessInheritance(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.allowsAccessInheritance_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean allowsImplementation(Object hostAccess_, Class type_) {
try {
boolean result = (boolean) HANDLES.allowsImplementation_.invoke(receiver, hostAccess_, type_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean allowsPublicAccess(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.allowsPublicAccess_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public ByteSequence asByteSequence(Object origin_) {
try {
Object result = HANDLES.asByteSequence_.invoke(receiver, origin_);
return ModuleToUnnamedAPIAccess.fromByteSequence(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callContextAsValue(Object current_, Object classOverrides_) {
try {
Object result = HANDLES.callContextAsValue_.invoke(receiver, current_, classOverrides_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callContextGetCurrent() {
try {
Object result = HANDLES.callContextGetCurrent_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyArrayGet(Object proxy_, long index_) {
try {
Object result = HANDLES.callProxyArrayGet_.invoke(receiver, proxy_, index_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean callProxyArrayRemove(Object proxy_, long index_) {
try {
boolean result = (boolean) HANDLES.callProxyArrayRemove_.invoke(receiver, proxy_, index_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void callProxyArraySet(Object proxy_, long index_, Object value_) {
try {
HANDLES.callProxyArraySet_.invoke(receiver, proxy_, index_, value_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyArraySize(Object proxy_) {
try {
Object result = HANDLES.callProxyArraySize_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public LocalDate callProxyDateAsDate(Object proxy_) {
try {
LocalDate result = (LocalDate) HANDLES.callProxyDateAsDate_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Duration callProxyDurationAsDuration(Object proxy_) {
try {
Duration result = (Duration) HANDLES.callProxyDurationAsDuration_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyExecutableExecute(Object proxy_, Object[] objects_) {
try {
Object result = HANDLES.callProxyExecutableExecute_.invoke(receiver, proxy_, objects_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyHashMapGetEntriesIterator(Object proxy_) {
try {
Object result = HANDLES.callProxyHashMapGetEntriesIterator_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyHashMapGetHashSize(Object proxy_) {
try {
Object result = HANDLES.callProxyHashMapGetHashSize_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyHashMapGetHashValue(Object proxy_, Object object_) {
try {
Object result = HANDLES.callProxyHashMapGetHashValue_.invoke(receiver, proxy_, object_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyHashMapHasHashEntry(Object proxy_, Object object_) {
try {
Object result = HANDLES.callProxyHashMapHasHashEntry_.invoke(receiver, proxy_, object_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void callProxyHashMapPutHashEntry(Object proxy_, Object object_, Object object2_) {
try {
HANDLES.callProxyHashMapPutHashEntry_.invoke(receiver, proxy_, object_, object2_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyHashMapRemoveHashEntry(Object proxy_, Object object_) {
try {
Object result = HANDLES.callProxyHashMapRemoveHashEntry_.invoke(receiver, proxy_, object_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Instant callProxyInstantAsInstant(Object proxy_) {
try {
Instant result = (Instant) HANDLES.callProxyInstantAsInstant_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyInstantiableNewInstance(Object proxy_, Object[] objects_) {
try {
Object result = HANDLES.callProxyInstantiableNewInstance_.invoke(receiver, proxy_, objects_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyIterableGetIterator(Object proxy_) {
try {
Object result = HANDLES.callProxyIterableGetIterator_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyIteratorGetNext(Object proxy_) {
try {
Object result = HANDLES.callProxyIteratorGetNext_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyIteratorHasNext(Object proxy_) {
try {
Object result = HANDLES.callProxyIteratorHasNext_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyNativeObjectAsPointer(Object proxy_) {
try {
Object result = HANDLES.callProxyNativeObjectAsPointer_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyObjectGetMember(Object proxy_, String member_) {
try {
Object result = HANDLES.callProxyObjectGetMember_.invoke(receiver, proxy_, member_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyObjectHasMember(Object proxy_, String string_) {
try {
Object result = HANDLES.callProxyObjectHasMember_.invoke(receiver, proxy_, string_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callProxyObjectMemberKeys(Object proxy_) {
try {
Object result = HANDLES.callProxyObjectMemberKeys_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void callProxyObjectPutMember(Object proxy_, String member_, Object value_) {
try {
HANDLES.callProxyObjectPutMember_.invoke(receiver, proxy_, member_, value_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean callProxyObjectRemoveMember(Object proxy_, String member_) {
try {
boolean result = (boolean) HANDLES.callProxyObjectRemoveMember_.invoke(receiver, proxy_, member_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public LocalTime callProxyTimeAsTime(Object proxy_) {
try {
LocalTime result = (LocalTime) HANDLES.callProxyTimeAsTime_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public ZoneId callProxyTimeZoneAsTimeZone(Object proxy_) {
try {
ZoneId result = (ZoneId) HANDLES.callProxyTimeZoneAsTimeZone_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public T callValueAs(Object delegateBindings_, Class targetType_) {
try {
T result = (T) HANDLES.callValueAs_.invoke(receiver, delegateBindings_, targetType_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public T callValueAs(Object delegateBindings_, Class rawType_, Type type_) {
try {
T result = (T) HANDLES.callValueAs1_.invoke(receiver, delegateBindings_, rawType_, type_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public String callValueAsString(Object arrayElement_) {
try {
String result = (String) HANDLES.callValueAsString_.invoke(receiver, arrayElement_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callValueGetArrayElement(Object keys_, int i_) {
try {
Object result = HANDLES.callValueGetArrayElement_.invoke(receiver, keys_, i_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public long callValueGetArraySize(Object keys_) {
try {
long result = (long) HANDLES.callValueGetArraySize_.invoke(receiver, keys_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object callValueGetMetaObject(Object delegateBindings_) {
try {
Object result = HANDLES.callValueGetMetaObject_.invoke(receiver, delegateBindings_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean callValueIsString(Object arrayElement_) {
try {
boolean result = (boolean) HANDLES.callValueIsString_.invoke(receiver, arrayElement_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object contextAsValue(Object localContext_, Object hostValue_) {
try {
Object result = HANDLES.contextAsValue_.invoke(receiver, localContext_, hostValue_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void contextClose(Object localContext_, boolean cancelIfClosing_) {
try {
HANDLES.contextClose_.invoke(receiver, localContext_, cancelIfClosing_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void contextEnter(Object localContext_) {
try {
HANDLES.contextEnter_.invoke(receiver, localContext_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void contextLeave(Object localContext_) {
try {
HANDLES.contextLeave_.invoke(receiver, localContext_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object createPolyglotAccess(Set bindingsAccess_, Map> evalAccess_) {
try {
Object result = HANDLES.createPolyglotAccess_.invoke(receiver, bindingsAccess_, evalAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void engineClosed(Object engine_) {
try {
HANDLES.engineClosed_.invoke(receiver, engine_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Set getBindingsAccess(Object polyglotAccess_) {
try {
Set result = (Set) HANDLES.getBindingsAccess_.invoke(receiver, polyglotAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractContextDispatch getContextDispatch(Object context_) {
try {
Object result = HANDLES.getContextDispatch_.invoke(receiver, context_);
return ModuleToUnnamedAPIAccess.fromAbstractContextDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getContextEngine(Object context_) {
try {
Object result = HANDLES.getContextEngine_.invoke(receiver, context_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getContextReceiver(Object context_) {
try {
Object result = HANDLES.getContextReceiver_.invoke(receiver, context_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractEngineDispatch getEngineDispatch(Object engine_) {
try {
Object result = HANDLES.getEngineDispatch_.invoke(receiver, engine_);
return ModuleToUnnamedAPIAccess.fromAbstractEngineDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getEngineReceiver(Object engine_) {
try {
Object result = HANDLES.getEngineReceiver_.invoke(receiver, engine_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getEnvironmentAccessInherit() {
try {
Object result = HANDLES.getEnvironmentAccessInherit_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getEnvironmentAccessNone() {
try {
Object result = HANDLES.getEnvironmentAccessNone_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Map> getEvalAccess(Object polyglotAccess_) {
try {
Map> result = (Map>) HANDLES.getEvalAccess_.invoke(receiver, polyglotAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Set getEvalAccess(Object polyglotAccess_, String language_) {
try {
Set result = (Set) HANDLES.getEvalAccess1_.invoke(receiver, polyglotAccess_, language_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getHostAccessImpl(Object hostAccess_) {
try {
Object result = HANDLES.getHostAccessImpl_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getHostAccessNone() {
try {
Object result = HANDLES.getHostAccessNone_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getIOAccessAll() {
try {
Object result = HANDLES.getIOAccessAll_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getIOAccessNone() {
try {
Object result = HANDLES.getIOAccessNone_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractInstrumentDispatch getInstrumentDispatch(Object value_) {
try {
Object result = HANDLES.getInstrumentDispatch_.invoke(receiver, value_);
return ModuleToUnnamedAPIAccess.fromAbstractInstrumentDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getInstrumentReceiver(Object instrument_) {
try {
Object result = HANDLES.getInstrumentReceiver_.invoke(receiver, instrument_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractLanguageDispatch getLanguageDispatch(Object value_) {
try {
Object result = HANDLES.getLanguageDispatch_.invoke(receiver, value_);
return ModuleToUnnamedAPIAccess.fromAbstractLanguageDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getLanguageReceiver(Object language_) {
try {
Object result = HANDLES.getLanguageReceiver_.invoke(receiver, language_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Lookup getMethodLookup(Object hostAccess_) {
try {
Lookup result = (Lookup) HANDLES.getMethodLookup_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public MutableTargetMapping[] getMutableTargetMappings(Object access_) {
try {
Object result = HANDLES.getMutableTargetMappings_.invoke(receiver, access_);
return ModuleToUnnamedAPIAccess.fromMutableTargetMappingArray(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getPolyglotAccessAll() {
try {
Object result = HANDLES.getPolyglotAccessAll_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getPolyglotAccessNone() {
try {
Object result = HANDLES.getPolyglotAccessNone_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getPolyglotExceptionClass() {
try {
Class result = (Class) HANDLES.getPolyglotExceptionClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getPolyglotExceptionReceiver(RuntimeException exception_) {
try {
Object result = HANDLES.getPolyglotExceptionReceiver_.invoke(receiver, exception_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyArrayClass() {
try {
Class result = (Class) HANDLES.getProxyArrayClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyClass() {
try {
Class result = (Class) HANDLES.getProxyClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyDateClass() {
try {
Class result = (Class) HANDLES.getProxyDateClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyDurationClass() {
try {
Class result = (Class) HANDLES.getProxyDurationClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyExecutableClass() {
try {
Class result = (Class) HANDLES.getProxyExecutableClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyHashMapClass() {
try {
Class result = (Class) HANDLES.getProxyHashMapClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyInstantClass() {
try {
Class result = (Class) HANDLES.getProxyInstantClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyInstantiableClass() {
try {
Class result = (Class) HANDLES.getProxyInstantiableClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyIterableClass() {
try {
Class result = (Class) HANDLES.getProxyIterableClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyIteratorClass() {
try {
Class result = (Class) HANDLES.getProxyIteratorClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyNativeObjectClass() {
try {
Class result = (Class) HANDLES.getProxyNativeObjectClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyObjectClass() {
try {
Class result = (Class) HANDLES.getProxyObjectClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyTimeClass() {
try {
Class result = (Class) HANDLES.getProxyTimeClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getProxyTimeZoneClass() {
try {
Class result = (Class) HANDLES.getProxyTimeZoneClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getResourceLimitsReceiver(Object value_) {
try {
Object result = HANDLES.getResourceLimitsReceiver_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractSourceDispatch getSourceDispatch(Object source_) {
try {
Object result = HANDLES.getSourceDispatch_.invoke(receiver, source_);
return ModuleToUnnamedAPIAccess.fromAbstractSourceDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getSourceReceiver(Object source_) {
try {
Object result = HANDLES.getSourceReceiver_.invoke(receiver, source_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractSourceSectionDispatch getSourceSectionDispatch(Object sourceSection_) {
try {
Object result = HANDLES.getSourceSectionDispatch_.invoke(receiver, sourceSection_);
return ModuleToUnnamedAPIAccess.fromAbstractSourceSectionDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getSourceSectionReceiver(Object sourceSection_) {
try {
Object result = HANDLES.getSourceSectionReceiver_.invoke(receiver, sourceSection_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getSourceSectionSource(Object sourceSection_) {
try {
Object result = HANDLES.getSourceSectionSource_.invoke(receiver, sourceSection_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractStackFrameImpl getStackFrameDispatch(Object value_) {
try {
Object result = HANDLES.getStackFrameDispatch_.invoke(receiver, value_);
return ModuleToUnnamedAPIAccess.fromAbstractStackFrameImpl(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractStackFrameImpl getStackFrameReceiver(Object value_) {
try {
Object result = HANDLES.getStackFrameReceiver_.invoke(receiver, value_);
return ModuleToUnnamedAPIAccess.fromAbstractStackFrameImpl(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public List getTargetMappings(Object hostAccess_) {
try {
List result = (List) HANDLES.getTargetMappings_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Class getValueClass() {
try {
Class result = (Class) HANDLES.getValueClass_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getValueContext(Object value_) {
try {
Object result = HANDLES.getValueContext_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public AbstractValueDispatch getValueDispatch(Object value_) {
try {
Object result = HANDLES.getValueDispatch_.invoke(receiver, value_);
return ModuleToUnnamedAPIAccess.fromAbstractValueDispatch(result);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object getValueReceiver(Object value_) {
try {
Object result = HANDLES.getValueReceiver_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isArrayAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isArrayAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isBigIntegerAccessibleAsNumber(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isBigIntegerAccessibleAsNumber_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isBufferAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isBufferAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isByteSequence(Object origin_) {
try {
boolean result = (boolean) HANDLES.isByteSequence_.invoke(receiver, origin_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isContext(Object context_) {
try {
boolean result = (boolean) HANDLES.isContext_.invoke(receiver, context_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isEngine(Object engine_) {
try {
boolean result = (boolean) HANDLES.isEngine_.invoke(receiver, engine_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isInstrument(Object instrument_) {
try {
boolean result = (boolean) HANDLES.isInstrument_.invoke(receiver, instrument_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isIterableAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isIterableAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isIteratorAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isIteratorAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isLanguage(Object language_) {
try {
boolean result = (boolean) HANDLES.isLanguage_.invoke(receiver, language_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isListAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isListAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isMapAccessible(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isMapAccessible_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isMethodScoped(Object hostAccess_, Executable e_) {
try {
boolean result = (boolean) HANDLES.isMethodScoped_.invoke(receiver, hostAccess_, e_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isMethodScopingEnabled(Object hostAccess_) {
try {
boolean result = (boolean) HANDLES.isMethodScopingEnabled_.invoke(receiver, hostAccess_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isPolyglotException(Object exception_) {
try {
boolean result = (boolean) HANDLES.isPolyglotException_.invoke(receiver, exception_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxy(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxy_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyArray(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyArray_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyDate(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyDate_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyDuration(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyDuration_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyExecutable(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyExecutable_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyHashMap(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyHashMap_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyInstant(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyInstant_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyInstantiable(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyInstantiable_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyIterable(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyIterable_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyIterator(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyIterator_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyNativeObject(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyNativeObject_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyObject(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyObject_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyTime(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyTime_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isProxyTimeZone(Object proxy_) {
try {
boolean result = (boolean) HANDLES.isProxyTimeZone_.invoke(receiver, proxy_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isSource(Object value_) {
try {
boolean result = (boolean) HANDLES.isSource_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isSourceSection(Object value_) {
try {
boolean result = (boolean) HANDLES.isSourceSection_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public boolean isValue(Object value_) {
try {
boolean result = (boolean) HANDLES.isValue_.invoke(receiver, value_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newContext(AbstractContextDispatch dispatch_, Object receiver_, Object engine_) {
try {
Object result = HANDLES.newContext_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractContextDispatch(dispatch_), receiver_, engine_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newEngine(AbstractEngineDispatch dispatch_, Object receiver_, boolean registerInActiveEngines_) {
try {
Object result = HANDLES.newEngine_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractEngineDispatch(dispatch_), receiver_, registerInActiveEngines_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newInstrument(AbstractInstrumentDispatch dispatch_, Object receiver_) {
try {
Object result = HANDLES.newInstrument_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractInstrumentDispatch(dispatch_), receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newLanguage(AbstractLanguageDispatch dispatch_, Object receiver_) {
try {
Object result = HANDLES.newLanguage_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractLanguageDispatch(dispatch_), receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public RuntimeException newLanguageException(String message_, AbstractExceptionDispatch dispatch_, Object receiver_) {
try {
RuntimeException result = (RuntimeException) HANDLES.newLanguageException_.invoke(receiver, message_, ModuleToUnnamedAPIAccess.toAbstractExceptionDispatch(dispatch_), receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newPolyglotStackTraceElement(AbstractStackFrameImpl dispatch_, RuntimeException polyglotException_) {
try {
Object result = HANDLES.newPolyglotStackTraceElement_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractStackFrameImpl(dispatch_), polyglotException_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newResourceLimitsEvent(Object context_) {
try {
Object result = HANDLES.newResourceLimitsEvent_.invoke(receiver, context_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newSource(AbstractSourceDispatch dispatch_, Object receiver_) {
try {
Object result = HANDLES.newSource_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractSourceDispatch(dispatch_), receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newSourceSection(Object source_, AbstractSourceSectionDispatch dispatch_, Object receiver_) {
try {
Object result = HANDLES.newSourceSection_.invoke(receiver, source_, ModuleToUnnamedAPIAccess.toAbstractSourceSectionDispatch(dispatch_), receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object newValue(AbstractValueDispatch dispatch_, Object context_, Object receiver_) {
try {
Object result = HANDLES.newValue_.invoke(receiver, ModuleToUnnamedAPIAccess.toAbstractValueDispatch(dispatch_), context_, receiver_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Object[] newValueArray(int size_) {
try {
Object[] result = (Object[]) HANDLES.newValueArray_.invoke(receiver, size_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public Map readOptionsFromSystemProperties() {
try {
Map result = (Map) HANDLES.readOptionsFromSystemProperties_.invoke(receiver);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public void setHostAccessImpl(Object hostAccess_, Object impl_) {
try {
HANDLES.setHostAccessImpl_.invoke(receiver, hostAccess_, impl_);
} catch (Throwable t) {
throw handleException_(t);
}
}
@Override
public String validatePolyglotAccess(Object polyglotAccess_, Set language_) {
try {
String result = (String) HANDLES.validatePolyglotAccess_.invoke(receiver, polyglotAccess_, language_);
return result;
} catch (Throwable t) {
throw handleException_(t);
}
}
@SuppressWarnings("unchecked")
private static RuntimeException handleException_(Throwable t) throws T {
throw (T)t;
}
static final class Handles extends Object {
private final MethodHandle allowsAccess_;
private final MethodHandle allowsAccessInheritance_;
private final MethodHandle allowsImplementation_;
private final MethodHandle allowsPublicAccess_;
private final MethodHandle asByteSequence_;
private final MethodHandle callContextAsValue_;
private final MethodHandle callContextGetCurrent_;
private final MethodHandle callProxyArrayGet_;
private final MethodHandle callProxyArrayRemove_;
private final MethodHandle callProxyArraySet_;
private final MethodHandle callProxyArraySize_;
private final MethodHandle callProxyDateAsDate_;
private final MethodHandle callProxyDurationAsDuration_;
private final MethodHandle callProxyExecutableExecute_;
private final MethodHandle callProxyHashMapGetEntriesIterator_;
private final MethodHandle callProxyHashMapGetHashSize_;
private final MethodHandle callProxyHashMapGetHashValue_;
private final MethodHandle callProxyHashMapHasHashEntry_;
private final MethodHandle callProxyHashMapPutHashEntry_;
private final MethodHandle callProxyHashMapRemoveHashEntry_;
private final MethodHandle callProxyInstantAsInstant_;
private final MethodHandle callProxyInstantiableNewInstance_;
private final MethodHandle callProxyIterableGetIterator_;
private final MethodHandle callProxyIteratorGetNext_;
private final MethodHandle callProxyIteratorHasNext_;
private final MethodHandle callProxyNativeObjectAsPointer_;
private final MethodHandle callProxyObjectGetMember_;
private final MethodHandle callProxyObjectHasMember_;
private final MethodHandle callProxyObjectMemberKeys_;
private final MethodHandle callProxyObjectPutMember_;
private final MethodHandle callProxyObjectRemoveMember_;
private final MethodHandle callProxyTimeAsTime_;
private final MethodHandle callProxyTimeZoneAsTimeZone_;
private final MethodHandle callValueAs_;
private final MethodHandle callValueAs1_;
private final MethodHandle callValueAsString_;
private final MethodHandle callValueGetArrayElement_;
private final MethodHandle callValueGetArraySize_;
private final MethodHandle callValueGetMetaObject_;
private final MethodHandle callValueIsString_;
private final MethodHandle contextAsValue_;
private final MethodHandle contextClose_;
private final MethodHandle contextEnter_;
private final MethodHandle contextLeave_;
private final MethodHandle createPolyglotAccess_;
private final MethodHandle engineClosed_;
private final MethodHandle getBindingsAccess_;
private final MethodHandle getContextDispatch_;
private final MethodHandle getContextEngine_;
private final MethodHandle getContextReceiver_;
private final MethodHandle getEngineDispatch_;
private final MethodHandle getEngineReceiver_;
private final MethodHandle getEnvironmentAccessInherit_;
private final MethodHandle getEnvironmentAccessNone_;
private final MethodHandle getEvalAccess_;
private final MethodHandle getEvalAccess1_;
private final MethodHandle getHostAccessImpl_;
private final MethodHandle getHostAccessNone_;
private final MethodHandle getIOAccessAll_;
private final MethodHandle getIOAccessNone_;
private final MethodHandle getInstrumentDispatch_;
private final MethodHandle getInstrumentReceiver_;
private final MethodHandle getLanguageDispatch_;
private final MethodHandle getLanguageReceiver_;
private final MethodHandle getMethodLookup_;
private final MethodHandle getMutableTargetMappings_;
private final MethodHandle getPolyglotAccessAll_;
private final MethodHandle getPolyglotAccessNone_;
private final MethodHandle getPolyglotExceptionClass_;
private final MethodHandle getPolyglotExceptionReceiver_;
private final MethodHandle getProxyArrayClass_;
private final MethodHandle getProxyClass_;
private final MethodHandle getProxyDateClass_;
private final MethodHandle getProxyDurationClass_;
private final MethodHandle getProxyExecutableClass_;
private final MethodHandle getProxyHashMapClass_;
private final MethodHandle getProxyInstantClass_;
private final MethodHandle getProxyInstantiableClass_;
private final MethodHandle getProxyIterableClass_;
private final MethodHandle getProxyIteratorClass_;
private final MethodHandle getProxyNativeObjectClass_;
private final MethodHandle getProxyObjectClass_;
private final MethodHandle getProxyTimeClass_;
private final MethodHandle getProxyTimeZoneClass_;
private final MethodHandle getResourceLimitsReceiver_;
private final MethodHandle getSourceDispatch_;
private final MethodHandle getSourceReceiver_;
private final MethodHandle getSourceSectionDispatch_;
private final MethodHandle getSourceSectionReceiver_;
private final MethodHandle getSourceSectionSource_;
private final MethodHandle getStackFrameDispatch_;
private final MethodHandle getStackFrameReceiver_;
private final MethodHandle getTargetMappings_;
private final MethodHandle getValueClass_;
private final MethodHandle getValueContext_;
private final MethodHandle getValueDispatch_;
private final MethodHandle getValueReceiver_;
private final MethodHandle isArrayAccessible_;
private final MethodHandle isBigIntegerAccessibleAsNumber_;
private final MethodHandle isBufferAccessible_;
private final MethodHandle isByteSequence_;
private final MethodHandle isContext_;
private final MethodHandle isEngine_;
private final MethodHandle isInstrument_;
private final MethodHandle isIterableAccessible_;
private final MethodHandle isIteratorAccessible_;
private final MethodHandle isLanguage_;
private final MethodHandle isListAccessible_;
private final MethodHandle isMapAccessible_;
private final MethodHandle isMethodScoped_;
private final MethodHandle isMethodScopingEnabled_;
private final MethodHandle isPolyglotException_;
private final MethodHandle isProxy_;
private final MethodHandle isProxyArray_;
private final MethodHandle isProxyDate_;
private final MethodHandle isProxyDuration_;
private final MethodHandle isProxyExecutable_;
private final MethodHandle isProxyHashMap_;
private final MethodHandle isProxyInstant_;
private final MethodHandle isProxyInstantiable_;
private final MethodHandle isProxyIterable_;
private final MethodHandle isProxyIterator_;
private final MethodHandle isProxyNativeObject_;
private final MethodHandle isProxyObject_;
private final MethodHandle isProxyTime_;
private final MethodHandle isProxyTimeZone_;
private final MethodHandle isSource_;
private final MethodHandle isSourceSection_;
private final MethodHandle isValue_;
private final MethodHandle newContext_;
private final MethodHandle newEngine_;
private final MethodHandle newInstrument_;
private final MethodHandle newLanguage_;
private final MethodHandle newLanguageException_;
private final MethodHandle newPolyglotStackTraceElement_;
private final MethodHandle newResourceLimitsEvent_;
private final MethodHandle newSource_;
private final MethodHandle newSourceSection_;
private final MethodHandle newValue_;
private final MethodHandle newValueArray_;
private final MethodHandle readOptionsFromSystemProperties_;
private final MethodHandle setHostAccessImpl_;
private final MethodHandle validatePolyglotAccess_;
Handles(Lookup lookup) throws ReflectiveOperationException {
Class typeByteSequence_ = lookup.findClass(ByteSequence.class.getName());
Class typeAbstractContextDispatch_ = lookup.findClass(AbstractContextDispatch.class.getName());
Class typeAbstractEngineDispatch_ = lookup.findClass(AbstractEngineDispatch.class.getName());
Class typeAbstractInstrumentDispatch_ = lookup.findClass(AbstractInstrumentDispatch.class.getName());
Class typeAbstractLanguageDispatch_ = lookup.findClass(AbstractLanguageDispatch.class.getName());
Class typeMutableTargetMappingArray_ = lookup.findClass(MutableTargetMapping[].class.getName());
Class typeAbstractSourceDispatch_ = lookup.findClass(AbstractSourceDispatch.class.getName());
Class typeAbstractSourceSectionDispatch_ = lookup.findClass(AbstractSourceSectionDispatch.class.getName());
Class typeAbstractStackFrameImpl_ = lookup.findClass(AbstractStackFrameImpl.class.getName());
Class typeAbstractValueDispatch_ = lookup.findClass(AbstractValueDispatch.class.getName());
Class typeAbstractExceptionDispatch_ = lookup.findClass(AbstractExceptionDispatch.class.getName());
Class typeAPIAccess = lookup.findClass(APIAccess.class.getName());
this.allowsAccess_ = lookup.findVirtual(typeAPIAccess, "allowsAccess", MethodType.methodType(boolean.class, List.of(Object.class, AnnotatedElement.class)));
this.allowsAccessInheritance_ = lookup.findVirtual(typeAPIAccess, "allowsAccessInheritance", MethodType.methodType(boolean.class, List.of(Object.class)));
this.allowsImplementation_ = lookup.findVirtual(typeAPIAccess, "allowsImplementation", MethodType.methodType(boolean.class, List.of(Object.class, Class.class)));
this.allowsPublicAccess_ = lookup.findVirtual(typeAPIAccess, "allowsPublicAccess", MethodType.methodType(boolean.class, List.of(Object.class)));
this.asByteSequence_ = lookup.findVirtual(typeAPIAccess, "asByteSequence", MethodType.methodType(typeByteSequence_, List.of(Object.class)));
this.callContextAsValue_ = lookup.findVirtual(typeAPIAccess, "callContextAsValue", MethodType.methodType(Object.class, List.of(Object.class, Object.class)));
this.callContextGetCurrent_ = lookup.findVirtual(typeAPIAccess, "callContextGetCurrent", MethodType.methodType(Object.class, List.of()));
this.callProxyArrayGet_ = lookup.findVirtual(typeAPIAccess, "callProxyArrayGet", MethodType.methodType(Object.class, List.of(Object.class, long.class)));
this.callProxyArrayRemove_ = lookup.findVirtual(typeAPIAccess, "callProxyArrayRemove", MethodType.methodType(boolean.class, List.of(Object.class, long.class)));
this.callProxyArraySet_ = lookup.findVirtual(typeAPIAccess, "callProxyArraySet", MethodType.methodType(void.class, List.of(Object.class, long.class, Object.class)));
this.callProxyArraySize_ = lookup.findVirtual(typeAPIAccess, "callProxyArraySize", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyDateAsDate_ = lookup.findVirtual(typeAPIAccess, "callProxyDateAsDate", MethodType.methodType(LocalDate.class, List.of(Object.class)));
this.callProxyDurationAsDuration_ = lookup.findVirtual(typeAPIAccess, "callProxyDurationAsDuration", MethodType.methodType(Duration.class, List.of(Object.class)));
this.callProxyExecutableExecute_ = lookup.findVirtual(typeAPIAccess, "callProxyExecutableExecute", MethodType.methodType(Object.class, List.of(Object.class, Object[].class)));
this.callProxyHashMapGetEntriesIterator_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapGetEntriesIterator", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyHashMapGetHashSize_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapGetHashSize", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyHashMapGetHashValue_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapGetHashValue", MethodType.methodType(Object.class, List.of(Object.class, Object.class)));
this.callProxyHashMapHasHashEntry_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapHasHashEntry", MethodType.methodType(Object.class, List.of(Object.class, Object.class)));
this.callProxyHashMapPutHashEntry_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapPutHashEntry", MethodType.methodType(void.class, List.of(Object.class, Object.class, Object.class)));
this.callProxyHashMapRemoveHashEntry_ = lookup.findVirtual(typeAPIAccess, "callProxyHashMapRemoveHashEntry", MethodType.methodType(Object.class, List.of(Object.class, Object.class)));
this.callProxyInstantAsInstant_ = lookup.findVirtual(typeAPIAccess, "callProxyInstantAsInstant", MethodType.methodType(Instant.class, List.of(Object.class)));
this.callProxyInstantiableNewInstance_ = lookup.findVirtual(typeAPIAccess, "callProxyInstantiableNewInstance", MethodType.methodType(Object.class, List.of(Object.class, Object[].class)));
this.callProxyIterableGetIterator_ = lookup.findVirtual(typeAPIAccess, "callProxyIterableGetIterator", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyIteratorGetNext_ = lookup.findVirtual(typeAPIAccess, "callProxyIteratorGetNext", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyIteratorHasNext_ = lookup.findVirtual(typeAPIAccess, "callProxyIteratorHasNext", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyNativeObjectAsPointer_ = lookup.findVirtual(typeAPIAccess, "callProxyNativeObjectAsPointer", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyObjectGetMember_ = lookup.findVirtual(typeAPIAccess, "callProxyObjectGetMember", MethodType.methodType(Object.class, List.of(Object.class, String.class)));
this.callProxyObjectHasMember_ = lookup.findVirtual(typeAPIAccess, "callProxyObjectHasMember", MethodType.methodType(Object.class, List.of(Object.class, String.class)));
this.callProxyObjectMemberKeys_ = lookup.findVirtual(typeAPIAccess, "callProxyObjectMemberKeys", MethodType.methodType(Object.class, List.of(Object.class)));
this.callProxyObjectPutMember_ = lookup.findVirtual(typeAPIAccess, "callProxyObjectPutMember", MethodType.methodType(void.class, List.of(Object.class, String.class, Object.class)));
this.callProxyObjectRemoveMember_ = lookup.findVirtual(typeAPIAccess, "callProxyObjectRemoveMember", MethodType.methodType(boolean.class, List.of(Object.class, String.class)));
this.callProxyTimeAsTime_ = lookup.findVirtual(typeAPIAccess, "callProxyTimeAsTime", MethodType.methodType(LocalTime.class, List.of(Object.class)));
this.callProxyTimeZoneAsTimeZone_ = lookup.findVirtual(typeAPIAccess, "callProxyTimeZoneAsTimeZone", MethodType.methodType(ZoneId.class, List.of(Object.class)));
this.callValueAs_ = lookup.findVirtual(typeAPIAccess, "callValueAs", MethodType.methodType(Object.class, List.of(Object.class, Class.class)));
this.callValueAs1_ = lookup.findVirtual(typeAPIAccess, "callValueAs", MethodType.methodType(Object.class, List.of(Object.class, Class.class, Type.class)));
this.callValueAsString_ = lookup.findVirtual(typeAPIAccess, "callValueAsString", MethodType.methodType(String.class, List.of(Object.class)));
this.callValueGetArrayElement_ = lookup.findVirtual(typeAPIAccess, "callValueGetArrayElement", MethodType.methodType(Object.class, List.of(Object.class, int.class)));
this.callValueGetArraySize_ = lookup.findVirtual(typeAPIAccess, "callValueGetArraySize", MethodType.methodType(long.class, List.of(Object.class)));
this.callValueGetMetaObject_ = lookup.findVirtual(typeAPIAccess, "callValueGetMetaObject", MethodType.methodType(Object.class, List.of(Object.class)));
this.callValueIsString_ = lookup.findVirtual(typeAPIAccess, "callValueIsString", MethodType.methodType(boolean.class, List.of(Object.class)));
this.contextAsValue_ = lookup.findVirtual(typeAPIAccess, "contextAsValue", MethodType.methodType(Object.class, List.of(Object.class, Object.class)));
this.contextClose_ = lookup.findVirtual(typeAPIAccess, "contextClose", MethodType.methodType(void.class, List.of(Object.class, boolean.class)));
this.contextEnter_ = lookup.findVirtual(typeAPIAccess, "contextEnter", MethodType.methodType(void.class, List.of(Object.class)));
this.contextLeave_ = lookup.findVirtual(typeAPIAccess, "contextLeave", MethodType.methodType(void.class, List.of(Object.class)));
this.createPolyglotAccess_ = lookup.findVirtual(typeAPIAccess, "createPolyglotAccess", MethodType.methodType(Object.class, List.of(Set.class, Map.class)));
this.engineClosed_ = lookup.findVirtual(typeAPIAccess, "engineClosed", MethodType.methodType(void.class, List.of(Object.class)));
this.getBindingsAccess_ = lookup.findVirtual(typeAPIAccess, "getBindingsAccess", MethodType.methodType(Set.class, List.of(Object.class)));
this.getContextDispatch_ = lookup.findVirtual(typeAPIAccess, "getContextDispatch", MethodType.methodType(typeAbstractContextDispatch_, List.of(Object.class)));
this.getContextEngine_ = lookup.findVirtual(typeAPIAccess, "getContextEngine", MethodType.methodType(Object.class, List.of(Object.class)));
this.getContextReceiver_ = lookup.findVirtual(typeAPIAccess, "getContextReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getEngineDispatch_ = lookup.findVirtual(typeAPIAccess, "getEngineDispatch", MethodType.methodType(typeAbstractEngineDispatch_, List.of(Object.class)));
this.getEngineReceiver_ = lookup.findVirtual(typeAPIAccess, "getEngineReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getEnvironmentAccessInherit_ = lookup.findVirtual(typeAPIAccess, "getEnvironmentAccessInherit", MethodType.methodType(Object.class, List.of()));
this.getEnvironmentAccessNone_ = lookup.findVirtual(typeAPIAccess, "getEnvironmentAccessNone", MethodType.methodType(Object.class, List.of()));
this.getEvalAccess_ = lookup.findVirtual(typeAPIAccess, "getEvalAccess", MethodType.methodType(Map.class, List.of(Object.class)));
this.getEvalAccess1_ = lookup.findVirtual(typeAPIAccess, "getEvalAccess", MethodType.methodType(Set.class, List.of(Object.class, String.class)));
this.getHostAccessImpl_ = lookup.findVirtual(typeAPIAccess, "getHostAccessImpl", MethodType.methodType(Object.class, List.of(Object.class)));
this.getHostAccessNone_ = lookup.findVirtual(typeAPIAccess, "getHostAccessNone", MethodType.methodType(Object.class, List.of()));
this.getIOAccessAll_ = lookup.findVirtual(typeAPIAccess, "getIOAccessAll", MethodType.methodType(Object.class, List.of()));
this.getIOAccessNone_ = lookup.findVirtual(typeAPIAccess, "getIOAccessNone", MethodType.methodType(Object.class, List.of()));
this.getInstrumentDispatch_ = lookup.findVirtual(typeAPIAccess, "getInstrumentDispatch", MethodType.methodType(typeAbstractInstrumentDispatch_, List.of(Object.class)));
this.getInstrumentReceiver_ = lookup.findVirtual(typeAPIAccess, "getInstrumentReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getLanguageDispatch_ = lookup.findVirtual(typeAPIAccess, "getLanguageDispatch", MethodType.methodType(typeAbstractLanguageDispatch_, List.of(Object.class)));
this.getLanguageReceiver_ = lookup.findVirtual(typeAPIAccess, "getLanguageReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getMethodLookup_ = lookup.findVirtual(typeAPIAccess, "getMethodLookup", MethodType.methodType(Lookup.class, List.of(Object.class)));
this.getMutableTargetMappings_ = lookup.findVirtual(typeAPIAccess, "getMutableTargetMappings", MethodType.methodType(typeMutableTargetMappingArray_, List.of(Object.class)));
this.getPolyglotAccessAll_ = lookup.findVirtual(typeAPIAccess, "getPolyglotAccessAll", MethodType.methodType(Object.class, List.of()));
this.getPolyglotAccessNone_ = lookup.findVirtual(typeAPIAccess, "getPolyglotAccessNone", MethodType.methodType(Object.class, List.of()));
this.getPolyglotExceptionClass_ = lookup.findVirtual(typeAPIAccess, "getPolyglotExceptionClass", MethodType.methodType(Class.class, List.of()));
this.getPolyglotExceptionReceiver_ = lookup.findVirtual(typeAPIAccess, "getPolyglotExceptionReceiver", MethodType.methodType(Object.class, List.of(RuntimeException.class)));
this.getProxyArrayClass_ = lookup.findVirtual(typeAPIAccess, "getProxyArrayClass", MethodType.methodType(Class.class, List.of()));
this.getProxyClass_ = lookup.findVirtual(typeAPIAccess, "getProxyClass", MethodType.methodType(Class.class, List.of()));
this.getProxyDateClass_ = lookup.findVirtual(typeAPIAccess, "getProxyDateClass", MethodType.methodType(Class.class, List.of()));
this.getProxyDurationClass_ = lookup.findVirtual(typeAPIAccess, "getProxyDurationClass", MethodType.methodType(Class.class, List.of()));
this.getProxyExecutableClass_ = lookup.findVirtual(typeAPIAccess, "getProxyExecutableClass", MethodType.methodType(Class.class, List.of()));
this.getProxyHashMapClass_ = lookup.findVirtual(typeAPIAccess, "getProxyHashMapClass", MethodType.methodType(Class.class, List.of()));
this.getProxyInstantClass_ = lookup.findVirtual(typeAPIAccess, "getProxyInstantClass", MethodType.methodType(Class.class, List.of()));
this.getProxyInstantiableClass_ = lookup.findVirtual(typeAPIAccess, "getProxyInstantiableClass", MethodType.methodType(Class.class, List.of()));
this.getProxyIterableClass_ = lookup.findVirtual(typeAPIAccess, "getProxyIterableClass", MethodType.methodType(Class.class, List.of()));
this.getProxyIteratorClass_ = lookup.findVirtual(typeAPIAccess, "getProxyIteratorClass", MethodType.methodType(Class.class, List.of()));
this.getProxyNativeObjectClass_ = lookup.findVirtual(typeAPIAccess, "getProxyNativeObjectClass", MethodType.methodType(Class.class, List.of()));
this.getProxyObjectClass_ = lookup.findVirtual(typeAPIAccess, "getProxyObjectClass", MethodType.methodType(Class.class, List.of()));
this.getProxyTimeClass_ = lookup.findVirtual(typeAPIAccess, "getProxyTimeClass", MethodType.methodType(Class.class, List.of()));
this.getProxyTimeZoneClass_ = lookup.findVirtual(typeAPIAccess, "getProxyTimeZoneClass", MethodType.methodType(Class.class, List.of()));
this.getResourceLimitsReceiver_ = lookup.findVirtual(typeAPIAccess, "getResourceLimitsReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getSourceDispatch_ = lookup.findVirtual(typeAPIAccess, "getSourceDispatch", MethodType.methodType(typeAbstractSourceDispatch_, List.of(Object.class)));
this.getSourceReceiver_ = lookup.findVirtual(typeAPIAccess, "getSourceReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getSourceSectionDispatch_ = lookup.findVirtual(typeAPIAccess, "getSourceSectionDispatch", MethodType.methodType(typeAbstractSourceSectionDispatch_, List.of(Object.class)));
this.getSourceSectionReceiver_ = lookup.findVirtual(typeAPIAccess, "getSourceSectionReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.getSourceSectionSource_ = lookup.findVirtual(typeAPIAccess, "getSourceSectionSource", MethodType.methodType(Object.class, List.of(Object.class)));
this.getStackFrameDispatch_ = lookup.findVirtual(typeAPIAccess, "getStackFrameDispatch", MethodType.methodType(typeAbstractStackFrameImpl_, List.of(Object.class)));
this.getStackFrameReceiver_ = lookup.findVirtual(typeAPIAccess, "getStackFrameReceiver", MethodType.methodType(typeAbstractStackFrameImpl_, List.of(Object.class)));
this.getTargetMappings_ = lookup.findVirtual(typeAPIAccess, "getTargetMappings", MethodType.methodType(List.class, List.of(Object.class)));
this.getValueClass_ = lookup.findVirtual(typeAPIAccess, "getValueClass", MethodType.methodType(Class.class, List.of()));
this.getValueContext_ = lookup.findVirtual(typeAPIAccess, "getValueContext", MethodType.methodType(Object.class, List.of(Object.class)));
this.getValueDispatch_ = lookup.findVirtual(typeAPIAccess, "getValueDispatch", MethodType.methodType(typeAbstractValueDispatch_, List.of(Object.class)));
this.getValueReceiver_ = lookup.findVirtual(typeAPIAccess, "getValueReceiver", MethodType.methodType(Object.class, List.of(Object.class)));
this.isArrayAccessible_ = lookup.findVirtual(typeAPIAccess, "isArrayAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isBigIntegerAccessibleAsNumber_ = lookup.findVirtual(typeAPIAccess, "isBigIntegerAccessibleAsNumber", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isBufferAccessible_ = lookup.findVirtual(typeAPIAccess, "isBufferAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isByteSequence_ = lookup.findVirtual(typeAPIAccess, "isByteSequence", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isContext_ = lookup.findVirtual(typeAPIAccess, "isContext", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isEngine_ = lookup.findVirtual(typeAPIAccess, "isEngine", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isInstrument_ = lookup.findVirtual(typeAPIAccess, "isInstrument", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isIterableAccessible_ = lookup.findVirtual(typeAPIAccess, "isIterableAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isIteratorAccessible_ = lookup.findVirtual(typeAPIAccess, "isIteratorAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isLanguage_ = lookup.findVirtual(typeAPIAccess, "isLanguage", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isListAccessible_ = lookup.findVirtual(typeAPIAccess, "isListAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isMapAccessible_ = lookup.findVirtual(typeAPIAccess, "isMapAccessible", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isMethodScoped_ = lookup.findVirtual(typeAPIAccess, "isMethodScoped", MethodType.methodType(boolean.class, List.of(Object.class, Executable.class)));
this.isMethodScopingEnabled_ = lookup.findVirtual(typeAPIAccess, "isMethodScopingEnabled", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isPolyglotException_ = lookup.findVirtual(typeAPIAccess, "isPolyglotException", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxy_ = lookup.findVirtual(typeAPIAccess, "isProxy", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyArray_ = lookup.findVirtual(typeAPIAccess, "isProxyArray", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyDate_ = lookup.findVirtual(typeAPIAccess, "isProxyDate", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyDuration_ = lookup.findVirtual(typeAPIAccess, "isProxyDuration", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyExecutable_ = lookup.findVirtual(typeAPIAccess, "isProxyExecutable", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyHashMap_ = lookup.findVirtual(typeAPIAccess, "isProxyHashMap", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyInstant_ = lookup.findVirtual(typeAPIAccess, "isProxyInstant", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyInstantiable_ = lookup.findVirtual(typeAPIAccess, "isProxyInstantiable", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyIterable_ = lookup.findVirtual(typeAPIAccess, "isProxyIterable", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyIterator_ = lookup.findVirtual(typeAPIAccess, "isProxyIterator", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyNativeObject_ = lookup.findVirtual(typeAPIAccess, "isProxyNativeObject", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyObject_ = lookup.findVirtual(typeAPIAccess, "isProxyObject", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyTime_ = lookup.findVirtual(typeAPIAccess, "isProxyTime", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isProxyTimeZone_ = lookup.findVirtual(typeAPIAccess, "isProxyTimeZone", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isSource_ = lookup.findVirtual(typeAPIAccess, "isSource", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isSourceSection_ = lookup.findVirtual(typeAPIAccess, "isSourceSection", MethodType.methodType(boolean.class, List.of(Object.class)));
this.isValue_ = lookup.findVirtual(typeAPIAccess, "isValue", MethodType.methodType(boolean.class, List.of(Object.class)));
this.newContext_ = lookup.findVirtual(typeAPIAccess, "newContext", MethodType.methodType(Object.class, List.of(typeAbstractContextDispatch_, Object.class, Object.class)));
this.newEngine_ = lookup.findVirtual(typeAPIAccess, "newEngine", MethodType.methodType(Object.class, List.of(typeAbstractEngineDispatch_, Object.class, boolean.class)));
this.newInstrument_ = lookup.findVirtual(typeAPIAccess, "newInstrument", MethodType.methodType(Object.class, List.of(typeAbstractInstrumentDispatch_, Object.class)));
this.newLanguage_ = lookup.findVirtual(typeAPIAccess, "newLanguage", MethodType.methodType(Object.class, List.of(typeAbstractLanguageDispatch_, Object.class)));
this.newLanguageException_ = lookup.findVirtual(typeAPIAccess, "newLanguageException", MethodType.methodType(RuntimeException.class, List.of(String.class, typeAbstractExceptionDispatch_, Object.class)));
this.newPolyglotStackTraceElement_ = lookup.findVirtual(typeAPIAccess, "newPolyglotStackTraceElement", MethodType.methodType(Object.class, List.of(typeAbstractStackFrameImpl_, RuntimeException.class)));
this.newResourceLimitsEvent_ = lookup.findVirtual(typeAPIAccess, "newResourceLimitsEvent", MethodType.methodType(Object.class, List.of(Object.class)));
this.newSource_ = lookup.findVirtual(typeAPIAccess, "newSource", MethodType.methodType(Object.class, List.of(typeAbstractSourceDispatch_, Object.class)));
this.newSourceSection_ = lookup.findVirtual(typeAPIAccess, "newSourceSection", MethodType.methodType(Object.class, List.of(Object.class, typeAbstractSourceSectionDispatch_, Object.class)));
this.newValue_ = lookup.findVirtual(typeAPIAccess, "newValue", MethodType.methodType(Object.class, List.of(typeAbstractValueDispatch_, Object.class, Object.class)));
this.newValueArray_ = lookup.findVirtual(typeAPIAccess, "newValueArray", MethodType.methodType(Object[].class, List.of(int.class)));
this.readOptionsFromSystemProperties_ = lookup.findVirtual(typeAPIAccess, "readOptionsFromSystemProperties", MethodType.methodType(Map.class, List.of()));
this.setHostAccessImpl_ = lookup.findVirtual(typeAPIAccess, "setHostAccessImpl", MethodType.methodType(void.class, List.of(Object.class, Object.class)));
this.validatePolyglotAccess_ = lookup.findVirtual(typeAPIAccess, "validatePolyglotAccess", MethodType.methodType(String.class, List.of(Object.class, Set.class)));
}
}
}
