Back to index...

	/*
	* Copyright (c) 2003, 2013, 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 sun.reflect.generics.reflectiveObjects;


	import java.lang.reflect.Type;
	import java.lang.reflect.WildcardType;
	import sun.reflect.generics.factory.GenericsFactory;
	import sun.reflect.generics.tree.FieldTypeSignature;
	import sun.reflect.generics.visitor.Reifier;
	import java.util.Arrays;


	/**
	* Implementation of WildcardType interface for core reflection.
	*/
	public class WildcardTypeImpl extends LazyReflectiveObjectGenerator
	implements WildcardType {
	// upper bounds - evaluated lazily
	private Type[] upperBounds;
	// lower bounds - evaluated lazily
	private Type[] lowerBounds;
	// The ASTs for the bounds. We are required to evaluate the bounds
	// lazily, so we store these at least until we are first asked
	// for the bounds. This also neatly solves the
	// problem with F-bounds - you can't reify them before the formal
	// is defined.
	private FieldTypeSignature[] upperBoundASTs;
	private FieldTypeSignature[] lowerBoundASTs;

	// constructor is private to enforce access through static factory
	private WildcardTypeImpl(FieldTypeSignature[] ubs,
	FieldTypeSignature[] lbs,
	GenericsFactory f) {
	super(f);
	upperBoundASTs = ubs;
	lowerBoundASTs = lbs;
	}

	/**
	* Factory method.
	* @param ubs - an array of ASTs representing the upper bounds for the type
	* variable to be created
	* @param lbs - an array of ASTs representing the lower bounds for the type
	* variable to be created
	* @param f - a factory that can be used to manufacture reflective
	* objects that represent the bounds of this wildcard type
	* @return a wild card type with the requested bounds and factory
	*/
	public static WildcardTypeImpl make(FieldTypeSignature[] ubs,
	FieldTypeSignature[] lbs,
	GenericsFactory f) {
	return new WildcardTypeImpl(ubs, lbs, f);
	}

	// Accessors

	// accessor for ASTs for upper bounds. Must not be called after upper
	// bounds have been evaluated, because we might throw the ASTs
	// away (but that is not thread-safe, is it?)
	private FieldTypeSignature[] getUpperBoundASTs() {
	// check that upper bounds were not evaluated yet
	assert(upperBounds == null);
	return upperBoundASTs;
	}
	// accessor for ASTs for lower bounds. Must not be called after lower
	// bounds have been evaluated, because we might throw the ASTs
	// away (but that is not thread-safe, is it?)
	private FieldTypeSignature[] getLowerBoundASTs() {
	// check that lower bounds were not evaluated yet
	assert(lowerBounds == null);
	return lowerBoundASTs;
	}

	/**
	* Returns an array of <tt>Type</tt> objects representing the upper
	* bound(s) of this type variable. Note that if no upper bound is
	* explicitly declared, the upper bound is <tt>Object</tt>.
	*
	* <p>For each upper bound B :
	* <ul>
	* <li>if B is a parameterized type or a type variable, it is created,
	* (see {@link #ParameterizedType} for the details of the creation
	* process for parameterized types).
	* <li>Otherwise, B is resolved.
	* </ul>
	*
	* @return an array of Types representing the upper bound(s) of this
	* type variable
	* @throws <tt>TypeNotPresentException</tt> if any of the
	* bounds refers to a non-existent type declaration
	* @throws <tt>MalformedParameterizedTypeException</tt> if any of the
	* bounds refer to a parameterized type that cannot be instantiated
	* for any reason
	*/
	public Type[] getUpperBounds() {
	// lazily initialize bounds if necessary
	if (upperBounds == null) {
	FieldTypeSignature[] fts = getUpperBoundASTs(); // get AST

	// allocate result array; note that
	// keeping ts and bounds separate helps with threads
	Type[] ts = new Type[fts.length];
	// iterate over bound trees, reifying each in turn
	for ( int j = 0; j < fts.length; j++) {
	Reifier r = getReifier();
	fts[j].accept(r);
	ts[j] = r.getResult();
	}
	// cache result
	upperBounds = ts;
	// could throw away upper bound ASTs here; thread safety?
	}
	return upperBounds.clone(); // return cached bounds
	}

	/**
	* Returns an array of <tt>Type</tt> objects representing the
	* lower bound(s) of this type variable. Note that if no lower bound is
	* explicitly declared, the lower bound is the type of <tt>null</tt>.
	* In this case, a zero length array is returned.
	*
	* <p>For each lower bound B :
	* <ul>
	* <li>if B is a parameterized type or a type variable, it is created,
	* (see {@link #ParameterizedType} for the details of the creation
	* process for parameterized types).
	* <li>Otherwise, B is resolved.
	* </ul>
	*
	* @return an array of Types representing the lower bound(s) of this
	* type variable
	* @throws <tt>TypeNotPresentException</tt> if any of the
	* bounds refers to a non-existent type declaration
	* @throws <tt>MalformedParameterizedTypeException</tt> if any of the
	* bounds refer to a parameterized type that cannot be instantiated
	* for any reason
	*/
	public Type[] getLowerBounds() {
	// lazily initialize bounds if necessary
	if (lowerBounds == null) {
	FieldTypeSignature[] fts = getLowerBoundASTs(); // get AST
	// allocate result array; note that
	// keeping ts and bounds separate helps with threads
	Type[] ts = new Type[fts.length];
	// iterate over bound trees, reifying each in turn
	for ( int j = 0; j < fts.length; j++) {
	Reifier r = getReifier();
	fts[j].accept(r);
	ts[j] = r.getResult();
	}
	// cache result
	lowerBounds = ts;
	// could throw away lower bound ASTs here; thread safety?
	}
	return lowerBounds.clone(); // return cached bounds
	}

	public String toString() {
	Type[] lowerBounds = getLowerBounds();
	Type[] bounds = lowerBounds;
	StringBuilder sb = new StringBuilder();

	if (lowerBounds.length > 0)
	sb.append("? super ");
	else {
	Type[] upperBounds = getUpperBounds();
	if (upperBounds.length > 0 && !upperBounds[0].equals(Object.class) ) {
	bounds = upperBounds;
	sb.append("? extends ");
	} else
	return "?";
	}

	assert bounds.length > 0;

	boolean first = true;
	for(Type bound: bounds) {
	if (!first)
	sb.append(" & ");

	first = false;
	sb.append(bound.getTypeName());
	}
	return sb.toString();
	}

	@Override
	public boolean equals(Object o) {
	if (o instanceof WildcardType) {
	WildcardType that = (WildcardType) o;
	return
	Arrays.equals(this.getLowerBounds(),
	that.getLowerBounds()) &&
	Arrays.equals(this.getUpperBounds(),
	that.getUpperBounds());
	} else
	return false;
	}

	@Override
	public int hashCode() {
	Type [] lowerBounds = getLowerBounds();
	Type [] upperBounds = getUpperBounds();

	return Arrays.hashCode(lowerBounds) ^ Arrays.hashCode(upperBounds);
	}
	}

Back to index...