• Home
• org.graalvm.polyglot
• polyglot
• 23.1.3
• source code
• ModuleToUnnamedAccessGen.java

×

Project download

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.ModuleToUnnamedAccessGen 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.util.List;
import java.util.Objects;
import org.graalvm.polyglot.impl.ModuleToUnnamedBridge.ModuleToUnnamedAccess;

/**
 * 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 ModuleToUnnamedAccessGen extends ModuleToUnnamedAccess {

    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 ModuleToUnnamedAccessGen(Object receiver) {
        this.receiver = Objects.requireNonNull(receiver);
    }

    @Override
    public Object fromByteSequence(Object value_) {
        try {
            Object result = HANDLES.fromByteSequence_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromContextDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromContextDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromEngineDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromEngineDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromExceptionDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromExceptionDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromExecutionEventDispatch(Object value_) {
        try {
            Object result = HANDLES.fromExecutionEventDispatch_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromExecutionListenerDispatch(Object value_) {
        try {
            Object result = HANDLES.fromExecutionListenerDispatch_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromFileSystem(Object value_) {
        try {
            Object result = HANDLES.fromFileSystem_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromInstrumentDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromInstrumentDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromLanguageDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromLanguageDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromMessageEndpoint(Object value_) {
        try {
            Object result = HANDLES.fromMessageEndpoint_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public int[] fromMutableTargetMappingArray(Object value_) {
        try {
            int[] result = (int[]) HANDLES.fromMutableTargetMappingArray_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object[] fromOptionDescriptor(Object value_) {
        try {
            Object[] result = (Object[]) HANDLES.fromOptionDescriptor_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromProcessCommand(Object value_) {
        try {
            Object result = HANDLES.fromProcessCommand_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromSourceDispatch(Object receiver_) {
        try {
            Object result = HANDLES.fromSourceDispatch_.invoke(receiver, receiver_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromSourceSectionDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromSourceSectionDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromStackFrameImpl(Object dispatch_) {
        try {
            Object result = HANDLES.fromStackFrameImpl_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object fromValueDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.fromValueDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toByteSequence(Object value_) {
        try {
            Object result = HANDLES.toByteSequence_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toContextDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toContextDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toEngineDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toEngineDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toExceptionDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toExceptionDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toExecutionEventDispatch(Object value_) {
        try {
            Object result = HANDLES.toExecutionEventDispatch_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toExecutionListenerDispatch(Object value_) {
        try {
            Object result = HANDLES.toExecutionListenerDispatch_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toFileSystem(Object value_) {
        try {
            Object result = HANDLES.toFileSystem_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toInstrumentDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toInstrumentDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toLanguageDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toLanguageDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toMessageEndpoint(Object value_) {
        try {
            Object result = HANDLES.toMessageEndpoint_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toProcessCommand(Object[] value_) {
        try {
            Object result = HANDLES.toProcessCommand_.invoke(receiver, value_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toSourceDispatch(Object receiver_) {
        try {
            Object result = HANDLES.toSourceDispatch_.invoke(receiver, receiver_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toSourceSectionDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toSourceSectionDispatch_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toStackFrameImpl(Object dispatch_) {
        try {
            Object result = HANDLES.toStackFrameImpl_.invoke(receiver, dispatch_);
            return result;
        } catch (Throwable t) {
            throw handleException_(t);
        }
    }

    @Override
    public Object toValueDispatch(Object dispatch_) {
        try {
            Object result = HANDLES.toValueDispatch_.invoke(receiver, dispatch_);
            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 fromByteSequence_;
        private final MethodHandle fromContextDispatch_;
        private final MethodHandle fromEngineDispatch_;
        private final MethodHandle fromExceptionDispatch_;
        private final MethodHandle fromExecutionEventDispatch_;
        private final MethodHandle fromExecutionListenerDispatch_;
        private final MethodHandle fromFileSystem_;
        private final MethodHandle fromInstrumentDispatch_;
        private final MethodHandle fromLanguageDispatch_;
        private final MethodHandle fromMessageEndpoint_;
        private final MethodHandle fromMutableTargetMappingArray_;
        private final MethodHandle fromOptionDescriptor_;
        private final MethodHandle fromProcessCommand_;
        private final MethodHandle fromSourceDispatch_;
        private final MethodHandle fromSourceSectionDispatch_;
        private final MethodHandle fromStackFrameImpl_;
        private final MethodHandle fromValueDispatch_;
        private final MethodHandle toByteSequence_;
        private final MethodHandle toContextDispatch_;
        private final MethodHandle toEngineDispatch_;
        private final MethodHandle toExceptionDispatch_;
        private final MethodHandle toExecutionEventDispatch_;
        private final MethodHandle toExecutionListenerDispatch_;
        private final MethodHandle toFileSystem_;
        private final MethodHandle toInstrumentDispatch_;
        private final MethodHandle toLanguageDispatch_;
        private final MethodHandle toMessageEndpoint_;
        private final MethodHandle toProcessCommand_;
        private final MethodHandle toSourceDispatch_;
        private final MethodHandle toSourceSectionDispatch_;
        private final MethodHandle toStackFrameImpl_;
        private final MethodHandle toValueDispatch_;

        Handles(Lookup lookup) throws ReflectiveOperationException {
            Class typeUnnamedAccess = lookup.findClass(UnnamedAccess.class.getName());
            this.fromByteSequence_ = lookup.findVirtual(typeUnnamedAccess, "fromByteSequence", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromContextDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromContextDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromEngineDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromEngineDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromExceptionDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromExceptionDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromExecutionEventDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromExecutionEventDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromExecutionListenerDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromExecutionListenerDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromFileSystem_ = lookup.findVirtual(typeUnnamedAccess, "fromFileSystem", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromInstrumentDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromInstrumentDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromLanguageDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromLanguageDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromMessageEndpoint_ = lookup.findVirtual(typeUnnamedAccess, "fromMessageEndpoint", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromMutableTargetMappingArray_ = lookup.findVirtual(typeUnnamedAccess, "fromMutableTargetMappingArray", MethodType.methodType(int[].class, List.of(Object.class)));
            this.fromOptionDescriptor_ = lookup.findVirtual(typeUnnamedAccess, "fromOptionDescriptor", MethodType.methodType(Object[].class, List.of(Object.class)));
            this.fromProcessCommand_ = lookup.findVirtual(typeUnnamedAccess, "fromProcessCommand", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromSourceDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromSourceDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromSourceSectionDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromSourceSectionDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromStackFrameImpl_ = lookup.findVirtual(typeUnnamedAccess, "fromStackFrameImpl", MethodType.methodType(Object.class, List.of(Object.class)));
            this.fromValueDispatch_ = lookup.findVirtual(typeUnnamedAccess, "fromValueDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toByteSequence_ = lookup.findVirtual(typeUnnamedAccess, "toByteSequence", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toContextDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toContextDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toEngineDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toEngineDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toExceptionDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toExceptionDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toExecutionEventDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toExecutionEventDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toExecutionListenerDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toExecutionListenerDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toFileSystem_ = lookup.findVirtual(typeUnnamedAccess, "toFileSystem", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toInstrumentDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toInstrumentDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toLanguageDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toLanguageDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toMessageEndpoint_ = lookup.findVirtual(typeUnnamedAccess, "toMessageEndpoint", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toProcessCommand_ = lookup.findVirtual(typeUnnamedAccess, "toProcessCommand", MethodType.methodType(Object.class, List.of(Object[].class)));
            this.toSourceDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toSourceDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toSourceSectionDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toSourceSectionDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toStackFrameImpl_ = lookup.findVirtual(typeUnnamedAccess, "toStackFrameImpl", MethodType.methodType(Object.class, List.of(Object.class)));
            this.toValueDispatch_ = lookup.findVirtual(typeUnnamedAccess, "toValueDispatch", MethodType.methodType(Object.class, List.of(Object.class)));
        }
    }

}