Home » openjdk-7 » com.sun.tools » javac » util » [javadoc | source]
com.sun.tools.javac.util
public class: Context [javadoc | source]
java.lang.Object
   com.sun.tools.javac.util.Context
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 supported API. 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:
public static class  Context.Key  The client creates an instance of this class for each key. 
public static interface  Context.Factory  The client can register a factory for lazy creation of the instance. 
Constructor:
 public Context() 
 public Context(Context prev) 
Method from com.sun.tools.javac.util.Context Summary:
clear,   dump,   get,   get,   put,   put,   put,   put
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from com.sun.tools.javac.util.Context Detail:
 public  void clear() 
 public  void dump() 
 public T get(Key<T> key) 
    Get the value for the key in this context.
 public T get(Class<T> clazz) 
 public  void put(Key<T> key,
    Factory<T> fac) 
    Set the factory for the key in this context.
 public  void put(Key<T> key,
    T data) 
    Set the value for the key in this context.
 public  void put(Class<T> clazz,
    T data) 
 public  void put(Class<T> clazz,
    Factory<T> fac)