private Class<T> clazz;

private int slot;

private Class<?>[] parameterTypes;

private Class<?>[] exceptionTypes;

private int modifiers;

// Generics and annotations support

private transient String signature;

// generic info repository; lazily initialized

private transient ConstructorRepository genericInfo;

private byte[] annotations;

private byte[] parameterAnnotations;

// Generics infrastructure

// Accessor for factory

private GenericsFactory getFactory() {

// create scope and factory

return CoreReflectionFactory.make(this, ConstructorScope.make(this));

}

// Accessor for generic info repository

@Override

ConstructorRepository getGenericInfo() {

// lazily initialize repository if necessary

if (genericInfo == null) {

// create and cache generic info repository

genericInfo =

ConstructorRepository.make(getSignature(),

getFactory());

}

return genericInfo; //return cached repository

}

private volatile ConstructorAccessor constructorAccessor;

// For sharing of ConstructorAccessors. This branching structure

// is currently only two levels deep (i.e., one root Constructor

// and potentially many Constructor objects pointing to it.)

private Constructor<T> root;

/**

Constructor(Class<T> declaringClass,

Class<?>[] parameterTypes,

Class<?>[] checkedExceptions,

int modifiers,

int slot,

String signature,

byte[] annotations,

byte[] parameterAnnotations) {

this.clazz = declaringClass;

this.parameterTypes = parameterTypes;

this.exceptionTypes = checkedExceptions;

this.modifiers = modifiers;

this.slot = slot;

this.signature = signature;

this.annotations = annotations;

this.parameterAnnotations = parameterAnnotations;

}

/**

Constructor<T> copy() {

// This routine enables sharing of ConstructorAccessor objects

// among Constructor objects which refer to the same underlying

// method in the VM. (All of this contortion is only necessary

// because of the "accessibility" bit in AccessibleObject,

// which implicitly requires that new java.lang.reflect

// objects be fabricated for each reflective call on Class

// objects.)

Constructor<T> res = new Constructor<>(clazz,

parameterTypes,

exceptionTypes, modifiers, slot,

signature,

annotations,

parameterAnnotations);

res.root = this;

// Might as well eagerly propagate this if already present

res.constructorAccessor = constructorAccessor;

return res;

}

@Override

boolean hasGenericInformation() {

return (getSignature() != null);

}

@Override

byte[] getAnnotationBytes() {

return annotations;

}

/**

@Override

public Class<T> getDeclaringClass() {

return clazz;

}

/**

@Override

public String getName() {

return getDeclaringClass().getName();

}

/**

@Override

public int getModifiers() {

return modifiers;

}

/**

@Override

@SuppressWarnings({"rawtypes", "unchecked"})

public TypeVariable<Constructor<T>>[] getTypeParameters() {

if (getSignature() != null) {

return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();

} else

return (TypeVariable<Constructor<T>>[])new TypeVariable[0];

}

/**

@Override

public Class<?>[] getParameterTypes() {

return parameterTypes.clone();

}

/**

public int getParameterCount() { return parameterTypes.length; }

/**

@Override

public Type[] getGenericParameterTypes() {

return super.getGenericParameterTypes();

}

/**

@Override

public Class<?>[] getExceptionTypes() {

return exceptionTypes.clone();

}

/**

@Override

public Type[] getGenericExceptionTypes() {

return super.getGenericExceptionTypes();

}

/**

public boolean equals(Object obj) {

if (obj != null && obj instanceof Constructor) {

Constructor<?> other = (Constructor<?>)obj;

if (getDeclaringClass() == other.getDeclaringClass()) {

return equalParamTypes(parameterTypes, other.parameterTypes);

}

}

return false;

}

/**

public int hashCode() {

return getDeclaringClass().getName().hashCode();

}

/**

public String toString() {

return sharedToString(Modifier.constructorModifiers(),

false,

parameterTypes,

exceptionTypes);

}

@Override

void specificToStringHeader(StringBuilder sb) {

sb.append(getDeclaringClass().getTypeName());

}

/**

@Override

public String toGenericString() {

return sharedToGenericString(Modifier.constructorModifiers(), false);

}

@Override

void specificToGenericStringHeader(StringBuilder sb) {

specificToStringHeader(sb);

}

/**

@CallerSensitive

public T newInstance(Object ... initargs)

throws InstantiationException, IllegalAccessException,

IllegalArgumentException, InvocationTargetException

{

if (!override) {

if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

Class<?> caller = Reflection.getCallerClass();

checkAccess(caller, clazz, null, modifiers);

}

}

if ((clazz.getModifiers() & Modifier.ENUM) != 0)

throw new IllegalArgumentException("Cannot reflectively create enum objects");

ConstructorAccessor ca = constructorAccessor; // read volatile

if (ca == null) {

ca = acquireConstructorAccessor();

}

@SuppressWarnings("unchecked")

T inst = (T) ca.newInstance(initargs);

return inst;

}

/**

@Override

public boolean isVarArgs() {

return super.isVarArgs();

}

/**

@Override

public boolean isSynthetic() {

return super.isSynthetic();

}

// NOTE that there is no synchronization used here. It is correct

// (though not efficient) to generate more than one

// ConstructorAccessor for a given Constructor. However, avoiding

// synchronization will probably make the implementation more

// scalable.

private ConstructorAccessor acquireConstructorAccessor() {

// First check to see if one has been created yet, and take it

// if so.

ConstructorAccessor tmp = null;

if (root != null) tmp = root.getConstructorAccessor();

if (tmp != null) {

constructorAccessor = tmp;

} else {

// Otherwise fabricate one and propagate it up to the root

tmp = reflectionFactory.newConstructorAccessor(this);

setConstructorAccessor(tmp);

}

return tmp;

}

// Returns ConstructorAccessor for this Constructor object, not

// looking up the chain to the root

ConstructorAccessor getConstructorAccessor() {

return constructorAccessor;

}

// Sets the ConstructorAccessor for this Constructor object and

// (recursively) its root

void setConstructorAccessor(ConstructorAccessor accessor) {

constructorAccessor = accessor;

// Propagate up

if (root != null) {

root.setConstructorAccessor(accessor);

}

}

int getSlot() {

return slot;

}

String getSignature() {

return signature;

}

byte[] getRawAnnotations() {

return annotations;

}

byte[] getRawParameterAnnotations() {

return parameterAnnotations;

}

/**

public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {

return super.getAnnotation(annotationClass);

}

/**

public Annotation[] getDeclaredAnnotations() {

return super.getDeclaredAnnotations();

}

/**

@Override

public Annotation[][] getParameterAnnotations() {

return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);

}

@Override

void handleParameterNumberMismatch(int resultLength, int numParameters) {

Class<?> declaringClass = getDeclaringClass();

if (declaringClass.isEnum() ||

declaringClass.isAnonymousClass() ||

declaringClass.isLocalClass() )

return ; // Can't do reliable parameter counting

else {

if (!declaringClass.isMemberClass() || // top-level

// Check for the enclosing instance parameter for

// non-static member classes

(declaringClass.isMemberClass() &&

((declaringClass.getModifiers() & Modifier.STATIC) == 0) &&

resultLength + 1 != numParameters) ) {

throw new AnnotationFormatError(

"Parameter annotations don't match number of parameters");

}

}

}

/**

@Override

public AnnotatedType getAnnotatedReturnType() {

return getAnnotatedReturnType0(getDeclaringClass());

}

/**

@Override

public AnnotatedType getAnnotatedReceiverType() {

if (getDeclaringClass().getEnclosingClass() == null)

return super.getAnnotatedReceiverType();

return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),

sun.misc.SharedSecrets.getJavaLangAccess().

getConstantPool(getDeclaringClass()),

this,

getDeclaringClass(),

getDeclaringClass().getEnclosingClass(),

TypeAnnotation.TypeAnnotationTarget.METHOD_RECEIVER);

}