Back to index...

	/*
	* Copyright (c) 2001, 2020, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.lang.reflect;

	import jdk.internal.reflect.MethodAccessor;
	import jdk.internal.reflect.ConstructorAccessor;

	/** Package-private class implementing the
	jdk.internal.access.JavaLangReflectAccess interface, allowing the java.lang
	package to instantiate objects in this package. */

	class ReflectAccess implements jdk.internal.access.JavaLangReflectAccess {
	public <T> Constructor<T> newConstructor(Class<T> declaringClass,
	Class<?>[] parameterTypes,
	Class<?>[] checkedExceptions,
	int modifiers,
	int slot,
	String signature,
	byte[] annotations,
	byte[] parameterAnnotations)
	{
	return new Constructor<>(declaringClass,
	parameterTypes,
	checkedExceptions,
	modifiers,
	slot,
	signature,
	annotations,
	parameterAnnotations);
	}

	public MethodAccessor getMethodAccessor(Method m) {
	return m.getMethodAccessor();
	}

	public void setMethodAccessor(Method m, MethodAccessor accessor) {
	m.setMethodAccessor(accessor);
	}

	public ConstructorAccessor getConstructorAccessor(Constructor<?> c) {
	return c.getConstructorAccessor();
	}

	public void setConstructorAccessor(Constructor<?> c,
	ConstructorAccessor accessor)
	{
	c.setConstructorAccessor(accessor);
	}

	public int getConstructorSlot(Constructor<?> c) {
	return c.getSlot();
	}

	public String getConstructorSignature(Constructor<?> c) {
	return c.getSignature();
	}

	public byte[] getConstructorAnnotations(Constructor<?> c) {
	return c.getRawAnnotations();
	}

	public byte[] getConstructorParameterAnnotations(Constructor<?> c) {
	return c.getRawParameterAnnotations();
	}

	public byte[] getExecutableTypeAnnotationBytes(Executable ex) {
	return ex.getTypeAnnotationBytes();
	}

	public Class<?>[] getExecutableSharedParameterTypes(Executable ex) {
	return ex.getSharedParameterTypes();
	}

	//
	// Copying routines, needed to quickly fabricate new Field,
	// Method, and Constructor objects from templates
	//
	public Method copyMethod(Method arg) {
	return arg.copy();
	}
	public Method leafCopyMethod(Method arg) {
	return arg.leafCopy();
	}

	public Field copyField(Field arg) {
	return arg.copy();
	}

	public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
	return arg.copy();
	}

	@SuppressWarnings("unchecked")
	public <T extends AccessibleObject> T getRoot(T obj) {
	return (T) obj.getRoot();
	}

	public boolean isTrustedFinalField(Field f) {
	return f.isTrustedFinal();
	}

	public <T> T newInstance(Constructor<T> ctor, Object[] args, Class<?> caller)
	throws IllegalAccessException, InstantiationException, InvocationTargetException
	{
	return ctor.newInstanceWithCaller(args, true, caller);
	}
	}

Back to index...