com.sun.tools.javac.util
Class Context

java.lang.Object
  com.sun.tools.javac.util.Context

public class Context
extends java.lang.Object

Support for an abstract context, modelled loosely after ThreadLocal but using a user-provided context instead of the current thread.

Within the compiler, a single Context is used for each invocation of the compiler. The context is then used to ensure a single copy of each compiler phase exists per compiler invocation.

The context can be used to assist in extending the compiler by extending its components. To do that, the extended component must be registered before the base component. We break initialization cycles by (1) registering a factory for the component rather than the component itself, and (2) a convention for a pattern of usage in which each base component registers itself by calling an instance method that is overridden in extended components. A base phase supporting extension would look something like this:

 public class Phase {
     protected static final Context.Key phaseKey =
         new Context.Key();

     public static Phase instance(Context context) {
         Phase instance = context.get(phaseKey);
         if (instance == null)
             // the phase has not been overridden
             instance = new Phase(context);
         return instance;
     }

     protected Phase(Context context) {
         context.put(phaseKey, this);
         // other intitialization follows...
     }
 }
 

In the compiler, we simply use Phase.instance(context) to get the reference to the phase. But in extensions of the compiler, we must register extensions of the phases to replace the base phase, and this must be done before any reference to the phase is accessed using Phase.instance(). An extended phase might be declared thus:

 public class NewPhase extends Phase {
     protected NewPhase(Context context) {
         super(context);
     }
     public static void preRegister(final Context context) {
         context.put(phaseKey, new Context.Factory() {
             public Phase make() {
                 return new NewPhase(context);
             }
         });
     }
 }
 

And is registered early in the extended compiler like this

     NewPhase.preRegister(context);
 

This is NOT part of any API supported by Sun Microsystems. If you write code that depends on this, you do so at your own risk. This code and its internal interfaces are subject to change or deletion without notice.

Nested Class Summary

static interface	Context.Factory<T> The client can register a factory for lazy creation of the instance.
static class	Context.Key<T> The client creates an instance of this class for each key.

Field Summary

private java.util.Map<Context.Key<?>,java.lang.Object>	ht The underlying map storing the data.
private java.util.Map<java.lang.Class<?>,Context.Key<?>>	kt

Constructor Summary

Context()

Method Summary

private static void	checkState(java.util.Map<?,?> t)
void	clear()
void	dump()
<T> T	get(java.lang.Class<T> clazz)
<T> T	get(Context.Key<T> key) Get the value for the key in this context.
private <T> Context.Key<T>	key(java.lang.Class<T> clss)
<T> void	put(java.lang.Class<T> clazz, Context.Factory<T> fac)
<T> void	put(java.lang.Class<T> clazz, T data)
<T> void	put(Context.Key<T> key, Context.Factory<T> fac) Set the factory for the key in this context.
<T> void	put(Context.Key<T> key, T data) Set the value for the key in this context.
private static <T> T	uncheckedCast(java.lang.Object o) TODO: This method should be removed and Context should be made type safe.

Methods inherited from class java.lang.Object

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

Field Detail

ht

private java.util.Map<Context.Key<?>,java.lang.Object> ht

The underlying map storing the data. We maintain the invariant that this table contains only mappings of the form Key -> T or Key -> Factory

kt

private java.util.Map<java.lang.Class<?>,Context.Key<?>> kt

Constructor Detail

Context

public Context()

Method Detail

put

public <T> void put(Context.Key<T> key,
                    Context.Factory<T> fac)

Set the factory for the key in this context.

put

public <T> void put(Context.Key<T> key,
                    T data)

Set the value for the key in this context.

get

public <T> T get(Context.Key<T> key)

Get the value for the key in this context.

key

private <T> Context.Key<T> key(java.lang.Class<T> clss)

get

public <T> T get(java.lang.Class<T> clazz)

put

public <T> void put(java.lang.Class<T> clazz,
                    T data)

put

public <T> void put(java.lang.Class<T> clazz,
                    Context.Factory<T> fac)

uncheckedCast

private static <T> T uncheckedCast(java.lang.Object o)

TODO: This method should be removed and Context should be made type safe. This can be accomplished by using class literals as type tokens.

dump

public void dump()

clear

public void clear()

checkState

private static void checkState(java.util.Map<?,?> t)