ClassInfo (Groovy 4.0.15)
Description: declaration: package: org.codehaus.groovy.reflection, class: ClassInfo

Package org.codehaus.groovy.reflection

# Class ClassInfo

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

All Implemented Interfaces:
  `Finalizable`

public class ClassInfo extends Object implements Finalizable
Handle for all information we want to keep about the class

This class handles caching internally and it's 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.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static interface`
  `ClassInfo.ClassInfoAction`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `final int`
  `hash`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static void`
  `clearModifiedExpandos()`
  `void`
  `finalizeReference()`
  `static int`
  `fullSize()`
  `static Collection<ClassInfo>`
  `getAllClassInfo()`
  `ClassLoaderForClassArtifacts`
  `getArtifactClassLoader()`
  `CachedClass`
  `getCachedClass()`
  `static ClassInfo`
  `getClassInfo(Class cls)`
  `final MetaClass`
  `getMetaClass()`
  Returns the `MetaClass` for the `Class` associated with this `ClassInfo`.
  `MetaClass`
  `getMetaClass(Object obj)`
  `MetaClass`
  `getMetaClassForClass()`
  `ExpandoMetaClass`
  `getModifiedExpando()`
  `MetaClass`
  `getPerInstanceMetaClass(Object obj)`
  `MetaClass`
  `getStrongMetaClass()`
  `final 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(Class<?> cls)`
  Removes a `ClassInfo` from the cache.
  `void`
  `setPerInstanceMetaClass(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 Details

  - ### hash

    public final int hash
    See Also:
      - Constant Field Values

- ## Method Details

  - ### getVersion

    public int getVersion()

  - ### incVersion

    public void incVersion()

  - ### getModifiedExpando

    public ExpandoMetaClass getModifiedExpando()

  - ### clearModifiedExpandos

    public static void clearModifiedExpandos()

  - ### getTheClass

    public final 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(Class cls)

  - ### remove

    public static void remove(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 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 always 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(Object obj)

  - ### size

    public static int size()

  - ### fullSize

    public static int fullSize()

  - ### lock

    public void lock()

  - ### unlock

    public void unlock()

  - ### getPerInstanceMetaClass

    public MetaClass getPerInstanceMetaClass(Object obj)

  - ### setPerInstanceMetaClass

    public void setPerInstanceMetaClass(Object obj, MetaClass metaClass)

  - ### hasPerInstanceMetaClasses

    public boolean hasPerInstanceMetaClasses()

  - ### finalizeReference

    public void finalizeReference()
    Specified by:
      `finalizeReference` in interface `Finalizable`