com.helger.jcodemodel

Class AbstractJClass

java.lang.Object

com.helger.jcodemodel.AbstractJType

com.helger.jcodemodel.AbstractJClass

All Implemented Interfaces:

IJGenerable, IJOwned

Direct Known Subclasses:

AbstractJClassContainer, JArrayClass, JErrorClass, JNarrowedClass, JNullType, JTypeVar, JTypeWildcard

public abstract class AbstractJClass
extends AbstractJType

Represents a Java reference type, such as a class, an interface, an enum, an array type, a parameterized type.

To be exact, this object represents an "use" of a reference type, not necessarily a declaration of it, which is modeled as JDefinedClass.

Field Summary

Fields

Modifier and Type	Field and Description
static JTypeVar[]	EMPTY_ARRAY Sometimes useful reusable empty array.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractJClass(JCodeModel aOwner)

Method Summary

Methods

Modifier and Type	Method and Description
abstract AbstractJClass	_extends() Gets the super class of this class.
abstract Iterator<AbstractJClass>	_implements() Iterates all super interfaces directly implemented by this class/interface.
abstract JPackage	_package() Gets the package to which this class belongs.
JArrayClass	array() Create an array type of this type.
AbstractJClass	boxify() Deprecated. calling this method from AbstractJClass would be meaningless, since it's always guaranteed to return this.
IJExpression	dotclass()
AbstractJClass	erasure()
void	generate(JFormatter f)
AbstractJClass	getBaseClass(AbstractJClass baseType) Gets the parameterization of the given base type.
AbstractJClass	getBaseClass(Class<?> baseType)
JPrimitiveType	getPrimitiveType()
List<? extends AbstractJClass>	getTypeParameters()
abstract boolean	isAbstract()
abstract boolean	isInterface()
boolean	isParameterized()
abstract String	name() Gets the name of this class.
AbstractJClass	narrow(AbstractJClass... clazz)
JNarrowedClass	narrow(AbstractJClass clazz) "Narrows" a generic class to a concrete class by specifying a type argument.
JNarrowedClass	narrow(AbstractJType type)
AbstractJClass	narrow(Class<?>... clazz)
JNarrowedClass	narrow(Class<?> clazz) "Narrows" a generic class to a concrete class by specifying a type argument.
AbstractJClass	narrow(List<? extends AbstractJClass> clazz)
AbstractJClass	outer()
JCodeModel	owner() Gets the owner code model object.
JInvocation	staticInvoke(JMethod aMethod) Generates a static method invocation.
JInvocation	staticInvoke(String sMethod) Generates a static method invocation.
JFieldRef	staticRef(JVar aField) Static field reference.
JFieldRef	staticRef(String sField) Static field reference.
protected abstract AbstractJClass	substituteParams(JTypeVar[] variables, List<? extends AbstractJClass> bindings) Substitutes the type variables with their actual arguments.
String	toString()
JTypeVar[]	typeParams() Iterates all the type parameters of this class/interface.
AbstractJType	unboxify() If this class is a wrapper type for a primitive, return the primitive type.
JTypeWildcard	wildcard() Create "?
JTypeWildcard	wildcard(JTypeWildcard.EBoundMode eMode) Create "?
JTypeWildcard	wildcardSuper() Create "?

Methods inherited from class com.helger.jcodemodel.AbstractJType

binaryName, elementType, fullName, isArray, isAssignableFrom, isAssignableFrom, isError, isPrimitive, isReference, parse

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

EMPTY_ARRAY

public static final JTypeVar[] EMPTY_ARRAY

Sometimes useful reusable empty array.

Constructor Detail

AbstractJClass

protected AbstractJClass(@Nonnull
              JCodeModel aOwner)

Method Detail

name

public abstract String name()

Gets the name of this class.

Specified by:

name in class AbstractJType

Returns:

name of this class, without any qualification. For example, this method returns "String" for java.lang.String.

_package

public abstract JPackage _package()

Gets the package to which this class belongs. TODO: shall we move move this down?

Returns:

The JPackage this class belongs to. Is usually not null except for the JTypeVar and the JTypeWildcard implementation.

outer

@Nullable
public AbstractJClass outer()

Returns:

the class in which this class is nested, or null if this is a top-level class.

owner

@Nonnull
public final JCodeModel owner()

Description copied from interface: IJOwned

Gets the owner code model object.

Returns:

The owner and never null.

_extends

@Nullable
public abstract AbstractJClass _extends()

Gets the super class of this class.

Returns:

Returns the AbstractJClass representing the superclass of the entity (class or interface) represented by this AbstractJClass. Even if no super class is given explicitly or this AbstractJClass is not a class, this method still returns AbstractJClass for Object. If this AbstractJClass represents Object, return null.

_implements

@Nonnull
public abstract Iterator<AbstractJClass> _implements()

Iterates all super interfaces directly implemented by this class/interface.

Returns:

A non-null valid iterator that iterates all AbstractJClass objects that represents those interfaces implemented by this object.

isInterface

public abstract boolean isInterface()

Returns:

true if this object represents an interface.

isAbstract

public abstract boolean isAbstract()

Returns:

true if this class is an abstract class.

getPrimitiveType

@Nullable
public JPrimitiveType getPrimitiveType()

Returns:

If this class represents one of the wrapper classes defined in the java.lang package, return the corresponding primitive type. Otherwise null.

boxify

@Deprecated
public AbstractJClass boxify()

Deprecated. calling this method from AbstractJClass would be meaningless, since it's always guaranteed to return this.

Description copied from class: AbstractJType

If this class is a primitive type, return the boxed class. Otherwise return this.

For example, for "int", this method returns "java.lang.Integer".

Specified by:

boxify in class AbstractJType

Returns:

Never null

unboxify

@Nonnull
public AbstractJType unboxify()

Description copied from class: AbstractJType

If this class is a wrapper type for a primitive, return the primitive type. Otherwise return this.

For example, for "java.lang.Integer", this method returns "int".

Specified by:

unboxify in class AbstractJType

Returns:

Never null

erasure

@Nonnull
public AbstractJClass erasure()

Overrides:

erasure in class AbstractJType

Returns:

the erasure of this type. This is only relevant for narrowed classes like List<Integer> in which case this method returns the reference to List without any generic type parameters.

getBaseClass

@Nullable
public final AbstractJClass getBaseClass(@Nonnull
                                   AbstractJClass baseType)

Gets the parameterization of the given base type.

For example, given the following

 
 interface Foo<T> extends List<List<T>> {}
 interface Bar extends Foo<String> {}
 
 

This method works like this:

 
 getBaseClass( Bar, List ) = List<List<String>
 getBaseClass( Bar, Foo  ) = Foo<String>
 getBaseClass( Foo<? extends Number>, Collection ) = Collection<List<? extends Number>>
 getBaseClass( ArrayList<? extends BigInteger>, List ) = List<? extends BigInteger>
 
 

Parameters:

baseType - The class whose parameterization we are interested in.

Returns:

The use of baseType in this type. or null if the type is not assignable to the base type.

getBaseClass

@Nullable
public final AbstractJClass getBaseClass(@Nonnull
                                   Class<?> baseType)

array

@Nonnull
public JArrayClass array()

Description copied from class: AbstractJType

Create an array type of this type. This method is undefined for primitive void type, which doesn't have any corresponding array representation.

Specified by:

array in class AbstractJType

Returns:

A JArrayClass representing the array type whose element type is this type

narrow

@Nonnull
public JNarrowedClass narrow(@Nonnull
                            Class<?> clazz)

"Narrows" a generic class to a concrete class by specifying a type argument.
.narrow(X) builds Set<X> from Set.

Parameters:

clazz - class to narrow with

Returns:

Never null. Narrowed class.

narrow

@Nonnull
public AbstractJClass narrow(@Nonnull
                            Class<?>... clazz)

narrow

@Nonnull
public JNarrowedClass narrow(AbstractJClass clazz)

"Narrows" a generic class to a concrete class by specifying a type argument.
.narrow(X) builds Set<X> from Set.

Parameters:

clazz - class to narrow with

Returns:

Never null. Narrowed class.

narrow

@Nonnull
public JNarrowedClass narrow(@Nonnull
                            AbstractJType type)

narrow

@Nonnull
public AbstractJClass narrow(@Nonnull
                            AbstractJClass... clazz)

narrow

@Nonnull
public AbstractJClass narrow(@Nonnull
                            List<? extends AbstractJClass> clazz)

getTypeParameters

@Nonnull
public List<? extends AbstractJClass> getTypeParameters()

Returns:

If this class is parameterized, the type parameters of the given index.

typeParams

@Nonnull
public JTypeVar[] typeParams()

Iterates all the type parameters of this class/interface.
For example, if this AbstractJClass represents Set<T>, this method returns an array that contains single JTypeVar for 'T'.

Returns:

All type parameters as array.

isParameterized

public final boolean isParameterized()

Returns:

true if this class is a parameterized class.

wildcard

@Nonnull
public final JTypeWildcard wildcard()

Create "? extends T" from T.

Returns:

never null

wildcardSuper

@Nonnull
public final JTypeWildcard wildcardSuper()

Create "? super T" from T.

Returns:

never null

wildcard

@Nonnull
public final JTypeWildcard wildcard(@Nonnull
                             JTypeWildcard.EBoundMode eMode)

Create "? extends T" from T or "? super T" from T.

Parameters:

eMode - "extends" or "super"

Returns:

never null

substituteParams

@Nonnull
protected abstract AbstractJClass substituteParams(@Nonnull
                                      JTypeVar[] variables,
                                      @Nonnull
                                      List<? extends AbstractJClass> bindings)

Substitutes the type variables with their actual arguments.
For example, when this class is Map<String,Map<V>>, (where V then doing substituteParams( V, Integer ) returns a AbstractJClass for Map<String,Map<Integer>>.
This method needs to work recursively.

Parameters:

variables - Type variables

bindings - Bindings

Returns:

Never null.

dotclass

@Nonnull
public final IJExpression dotclass()

Returns:

name.class

staticInvoke

@Nonnull
public final JInvocation staticInvoke(@Nonnull
                               JMethod aMethod)

Generates a static method invocation.

Parameters:

aMethod - Method to be invoked

Returns:

Newly created JInvocation

staticInvoke

@Nonnull
public final JInvocation staticInvoke(@Nonnull
                               String sMethod)

Generates a static method invocation.

Parameters:

sMethod - Method to be invoked

Returns:

Newly created JInvocation

staticRef

@Nonnull
public final JFieldRef staticRef(String sField)

Static field reference.

Parameters:

sField - Field to be referenced

Returns:

Newly created JFieldRef

staticRef

@Nonnull
public final JFieldRef staticRef(JVar aField)

Static field reference.

Parameters:

aField - Field to be referenced

Returns:

Newly created JFieldRef

generate

public void generate(@Nonnull
            JFormatter f)

toString

public String toString()

Overrides:

toString in class AbstractJType