Class ContextProcessor

code/src/java/pcgen/cdom/processor/ContextProcessor.java:38–155

A ContextProcessor is a Processor that has the ability to wrap another Processor in order to conditionally apply the underlying Processor only in a given context. @param The class of object this ContextProcessor acts upon. @param The class of objects which provide the

 *            ContextProcessor acts
 */
public class ContextProcessor<T, R extends PrereqObject> implements Processor<T>
{
	/**
	 * The underlying Processor that this ContextModifer will apply when the
	 * given context is matched.
	 */
	private final Processor<T> processor;

	/**
	 * A Reference which contains the objects in the context in which the
	 * underlying Processor should be applied.
	 */
	private final CDOMReference<R> contextItems;

	/**
	 * Constructs a new ContextProcessor that will conditionally apply the given
	 * Processor only when objects in the given CDOMReference are provided as the
	 * context of the modification.
	 * 
	 * @param mod
	 *            The underlying Processor that this ContextModifer will apply
	 *            when the given context is matched.
	 * @param contextRef
	 *            The CDOMReference which contains the objects for which the
	 *            underlying Processor should be applied.
	 * @throws IllegalArgumentException
	 *             if the given Processor or the given CDOMReference is null
	 */
	public ContextProcessor(Processor<T> mod, CDOMReference<R> contextRef)
	{
		Objects.requireNonNull(mod, "Processor in ContextProcessor cannot be null");
		Objects.requireNonNull(contextRef, "Context in ContextProcessor cannot be null");
		processor = mod;
		contextItems = contextRef;
	}

	/**
	 * Conditionally applies the underlying Processor to the given input. Will
	 * only be applied if the object given as the context object is contained
	 * within the CDOMReference provided during construction of this
	 * ContextProcessor.
	 * 
	 * Note this method may return the object passed in as the input object. The
	 * behavior of ContextProcessor will depend on the behavior of the underlying
	 * Processor. Therefore, if the input object is mutable, the caller of the
	 * applyProcessor method should be aware of that behavior, and should treat
	 * the returned object appropriately.
	 * 
	 * @param obj
	 *            The input object this ContextProcessor will act upon
	 * @param context
	 *            The context of this ContextProcessor, to establish whether this
	 *            Processor should act upon the input object
	 * @return The modified object, of the same class as the input object.
	 */
	@Override
	public T applyProcessor(T obj, Object context)
	{