org.codehaus.groovy.reflection

## Class ClassInfo

- java.lang.Object
- - org.codehaus.groovy.reflection.ClassInfo

All Implemented Interfaces:
  Finalizable

    public class ClassInfo
    extends java.lang.Object
    implements Finalizable

Handle for all information we want to keep about the class

This class handles caching internally and its advisable to not store references directly to objects of this class. The static factory method `getClassInfo(Class)` should be used to retrieve an instance from the cache. Internally the `Class` associated with a `ClassInfo` instance is kept as `WeakReference`, so it not safe to reference and instance without the Class being either strongly or softly reachable.

Author:
  Alex.Tkachman

### Nested Class Summary

Nested Classes
`static interface` `ClassInfo.ClassInfoAction`

### Field Summary

Fields
`int` `hash`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`static void` `clearModifiedExpandos()`
`void` `finalizeReference()`
`static int` `fullSize()`
`static java.util.Collection<ClassInfo>` `getAllClassInfo()`
`ClassLoaderForClassArtifacts` `getArtifactClassLoader()`
`CachedClass` `getCachedClass()`
`static ClassInfo` `getClassInfo(java.lang.Class cls)`
`MetaClass` `getMetaClass()` Returns the `MetaClass` for the `Class` associated with this `ClassInfo`.
`MetaClass` `getMetaClass(java.lang.Object obj)`
`MetaClass` `getMetaClassForClass()`
`ExpandoMetaClass` `getModifiedExpando()`
`MetaClass` `getPerInstanceMetaClass(java.lang.Object obj)`
`MetaClass` `getStrongMetaClass()`
`java.lang.Class<?>` `getTheClass()` Returns the `Class` associated with this `ClassInfo`.
`int` `getVersion()`
`MetaClass` `getWeakMetaClass()`
`boolean` `hasPerInstanceMetaClasses()`
`void` `incVersion()`
`void` `lock()`
`static void` `onAllClassInfo(ClassInfo.ClassInfoAction action)`
`static void` `remove(java.lang.Class<?> cls)` Removes a `ClassInfo` from the cache.
`void` `setPerInstanceMetaClass(java.lang.Object obj, MetaClass metaClass)`
`void` `setStrongMetaClass(MetaClass answer)`
`void` `setWeakMetaClass(MetaClass answer)`
`static int` `size()`
`void` `unlock()`

### Methods inherited from class java.lang.Object

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

### Field Detail

#### hash

    public final int hash

See Also:
  Constant Field Values

### Method Detail

#### getVersion

    public int getVersion()

#### incVersion

    public void incVersion()

#### getModifiedExpando

    public ExpandoMetaClass getModifiedExpando()

#### clearModifiedExpandos

    public static void clearModifiedExpandos()

#### getTheClass

    public final java.lang.Class<?> getTheClass()

Returns the `Class` associated with this `ClassInfo`.

This method can return `null` if the `Class` is no longer reachable through any strong or soft references. A non-null return value indicates that this `ClassInfo` is valid.

Returns:
  the `Class` associated with this `ClassInfo`, else `null`

#### getCachedClass

    public CachedClass getCachedClass()

#### getArtifactClassLoader

    public ClassLoaderForClassArtifacts getArtifactClassLoader()

#### getClassInfo

    public static ClassInfo getClassInfo(java.lang.Class cls)

#### remove

    public static void remove(java.lang.Class<?> cls)

Removes a `ClassInfo` from the cache. This is useful in cases where the Class is parsed from a script, such as when using GroovyClassLoader#parseClass, and is executed for its result but the Class is not retained or cached. Removing the `ClassInfo` associated with the Class will make the Class and its ClassLoader eligible for garbage collection sooner that it would otherwise.

Parameters:
  `cls` - the Class associated with the ClassInfo to remove from cache

#### getAllClassInfo

    public static java.util.Collection<ClassInfo> getAllClassInfo()

#### onAllClassInfo

    public static void onAllClassInfo(ClassInfo.ClassInfoAction action)

#### getStrongMetaClass

    public MetaClass getStrongMetaClass()

#### setStrongMetaClass

    public void setStrongMetaClass(MetaClass answer)

#### getWeakMetaClass

    public MetaClass getWeakMetaClass()

#### setWeakMetaClass

    public void setWeakMetaClass(MetaClass answer)

#### getMetaClassForClass

    public MetaClass getMetaClassForClass()

#### getMetaClass

    public final MetaClass getMetaClass()

Returns the `MetaClass` for the `Class` associated with this `ClassInfo`. If no `MetaClass` exists one will be created.

It is not safe to call this method without a `Class` associated with this `ClassInfo`. It is advisable to aways retrieve a ClassInfo instance from the cache by using the static factory method `getClassInfo(Class)` to ensure the referenced Class is strongly reachable.

Returns:
  a `MetaClass` instance

#### getMetaClass

    public MetaClass getMetaClass(java.lang.Object obj)

#### size

    public static int size()

#### fullSize

    public static int fullSize()

#### lock

    public void lock()

#### unlock

    public void unlock()

#### getPerInstanceMetaClass

    public MetaClass getPerInstanceMetaClass(java.lang.Object obj)

#### setPerInstanceMetaClass

    public void setPerInstanceMetaClass(java.lang.Object obj,
                                        MetaClass metaClass)

#### hasPerInstanceMetaClasses

    public boolean hasPerInstanceMetaClasses()

#### finalizeReference

    public void finalizeReference()

Specified by:
  `finalizeReference` in interface `Finalizable`