Commits

Anonymous committed 750b4ea

Added the Guice DI container into XWork to wire together key pieces and constants, started
the merge of the tiger project into core, removed the external reference resolver feature
as there are better ways to do it.
XW-433 WX-434 XW-435

git-svn-id: http://svn.opensymphony.com/svn/xwork/trunk@1187e221344d-f017-0410-9bd5-d282ab1896d7

Comments (0)

Files changed (237)

                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-javadoc-plugin</artifactId>
                     <executions>
+                        <!--
                         <execution>
                             <id>attach-javadoc</id>
                             <goals>
                                 <goal>jar</goal>
                             </goals>
                         </execution>
+                        -->
                     </executions>
                 </plugin>
                 <plugin>

src/java/com/opensymphony/xwork2/ActionChainResult.java

 package com.opensymphony.xwork2;
 
 import com.opensymphony.xwork2.config.Configuration;
+import com.opensymphony.xwork2.inject.Inject;
 import com.opensymphony.xwork2.util.TextParseUtil;
 import com.opensymphony.xwork2.util.ValueStack;
 
     private String namespace;
     
     private String methodName;
+    private ActionProxyFactory actionProxyFactory;
     
     public ActionChainResult() {
     	super();
     	this.methodName = methodName;
     }
 
+    
+
+    /**
+     * @param actionProxyFactory the actionProxyFactory to set
+     */
+    @Inject
+    public void setActionProxyFactory(ActionProxyFactory actionProxyFactory) {
+        this.actionProxyFactory = actionProxyFactory;
+    }
 
     public void setActionName(String actionName) {
         this.actionName = actionName;
         if (invocation != null) {
             config = invocation.getProxy().getConfiguration();
         }
-        proxy = ActionProxyFactory.getFactory().createActionProxy(config,
+        proxy = actionProxyFactory.createActionProxy(config,
                 finalNamespace, finalActionName, extraContext);
         if (null != finalMethodName) {
             proxy.setMethod(finalMethodName);

src/java/com/opensymphony/xwork2/ActionContext.java

      * This mode provides more feedback that is useful for developers but probably
      * too verbose/error prone for production.
      */
-    public static final String DEV_MODE = "__devMode";
+    //public static final String DEV_MODE = "__devMode";
 
     /**
      * Constant for the name of the action being executed.

src/java/com/opensymphony/xwork2/ActionProxyFactory.java

  *         Created Jun 15, 2003 5:18:30 PM
  * @see DefaultActionProxyFactory
  */
-public abstract class ActionProxyFactory {
-
-    static ActionProxyFactory factory = new DefaultActionProxyFactory();
-
-    /**
-     * Set the ActionProxyFactory implementation to use. If no instance is set, a new DefaultActionProxyFactory is used.
-     *
-     * @param factory
-     */
-    public static void setFactory(ActionProxyFactory factory) {
-        ActionProxyFactory.factory = factory;
-    }
-
-    public static ActionProxyFactory getFactory() {
-        return factory;
-    }
-    
-    /**
-     * Used by an ActionProxy or ActionProxyFactory to create an ActionInvocation to associate with an ActionProxy
-     * as part of creating an ActionProxy. Client code should not need to call the createActionInvocation methods.
-     *
-     * @param actionProxy
-     * @param extraContext
-     * @return ActionInvocation
-     * @throws Exception
-     */
-    public abstract ActionInvocation createActionInvocation(ActionProxy actionProxy, Map extraContext) throws Exception;
-
-    /**
-     * Used by an ActionProxy or ActionProxyFactory to create an ActionInvocation to associate with an ActionProxy
-     * as part of creating an ActionProxy. Client code should not need to call the createActionInvocation methods.
-     *
-     * @param actionProxy
-     * @return ActionInvocation
-     * @throws Exception
-     */
-    public abstract ActionInvocation createActionInvocation(ActionProxy actionProxy) throws Exception;
-
-    /**
-     * Used by an ActionProxy or ActionProxyFactory to create an ActionInvocation to associate with an ActionProxy
-     * as part of creating an ActionProxy. Client code should not need to call the createActionInvocation methods.
-     *
-     * @param actionProxy
-     * @param extraContext
-     * @param pushAction   tells whether the Action should be pushed onto the ValueStack
-     * @return ActionInvocation
-     * @throws Exception
-     */
-    public abstract ActionInvocation createActionInvocation(ActionProxy actionProxy, Map extraContext, boolean pushAction) throws Exception;
+public interface ActionProxyFactory {
 
     /**
      * Creates an ActionProxy for the given namespace and action name by looking up the configuration. The ActionProxy
      * @return ActionProxy
      * @throws Exception
      */
-    public abstract ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext) throws Exception;
+    public ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext) throws Exception;
 
     /**
      * Creates an ActionProxy for the given namespace and action name by looking up the configuration. The ActionProxy
      * @return ActionProxy
      * @throws Exception
      */
-    public abstract ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception;
+    public ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception;
 }

src/java/com/opensymphony/xwork2/DefaultActionInvocation.java

 import com.opensymphony.xwork2.config.entities.ActionConfig;
 import com.opensymphony.xwork2.config.entities.InterceptorMapping;
 import com.opensymphony.xwork2.config.entities.ResultConfig;
+import com.opensymphony.xwork2.inject.Inject;
 import com.opensymphony.xwork2.interceptor.PreResultListener;
 import com.opensymphony.xwork2.util.ValueStack;
 import com.opensymphony.xwork2.util.ValueStackFactory;
 
 	public static ContinuationHandler continuationHandler;
 
-    static {
-        if (ObjectFactory.getContinuationPackage() != null) {
-            continuationHandler = new ContinuationHandler();
-        }
-    }
+    //static {
+    //    if (ObjectFactory.getContinuationPackage() != null) {
+    //        continuationHandler = new ContinuationHandler();
+    //    }
+    //}
     private static final Log LOG = LogFactory.getLog(DefaultActionInvocation.class);
 
     protected Object action;
     protected String resultCode;
     protected boolean executed = false;
     protected boolean pushAction = true;
+    protected ObjectFactory objectFactory;
 
-    protected DefaultActionInvocation(ActionProxy proxy) throws Exception {
-        this(proxy, null);
-    }
-
-    protected DefaultActionInvocation(ActionProxy proxy, Map extraContext) throws Exception {
-        this(proxy, extraContext, true);
+    protected DefaultActionInvocation(ObjectFactory objectFactory, ActionProxy proxy, Map extraContext) throws Exception {
+        this(objectFactory, proxy, extraContext, true);
     }
 
-    protected DefaultActionInvocation(final ActionProxy proxy, final Map extraContext, final boolean pushAction) throws Exception {
+    protected DefaultActionInvocation(final ObjectFactory objectFactory, final ActionProxy proxy, final Map extraContext, final boolean pushAction) throws Exception {
     	UtilTimerStack.profile("create DefaultActionInvocation: ", 
     			new UtilTimerStack.ProfilingBlock<Object>() {
 					public Object doProfiling() throws Exception {
 						DefaultActionInvocation.this.proxy = proxy;
+                        DefaultActionInvocation.this.objectFactory = objectFactory;
 				        DefaultActionInvocation.this.extraContext = extraContext;
 				        DefaultActionInvocation.this.pushAction = pushAction;
 				        init();
 
         if (resultConfig != null) {
             try {
-                Result result = ObjectFactory.getObjectFactory().buildResult(resultConfig, invocationContext.getContextMap());
+                Result result = objectFactory.buildResult(resultConfig, invocationContext.getContextMap());
                 return result;
             } catch (Exception e) {
                 LOG.error("There was an exception while instantiating the result of type " + resultConfig.getClassName(), e);
         String timerKey = "actionCreate: "+proxy.getActionName();
         try {
             UtilTimerStack.push(timerKey);
-            action = ObjectFactory.getObjectFactory().buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
+            action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
         } catch (InstantiationException e) {
             throw new XWorkException("Unable to intantiate Action!", e, proxy.getConfig());
         } catch (IllegalAccessException e) {

src/java/com/opensymphony/xwork2/DefaultActionProxy.java

 import com.opensymphony.xwork2.config.Configuration;
 import com.opensymphony.xwork2.config.ConfigurationException;
 import com.opensymphony.xwork2.config.entities.ActionConfig;
+import com.opensymphony.xwork2.inject.Inject;
 import com.opensymphony.xwork2.util.LocalizedTextUtil;
 import com.opensymphony.xwork2.util.profiling.UtilTimerStack;
 
     protected boolean executeResult;
     protected boolean cleanupContext;
 
+    protected ObjectFactory objectFactory;
+
     /**
      * This constructor is private so the builder methods (create*) should be used to create an DefaultActionProxy.
      * <p/>
      * The reason for the builder methods is so that you can use a subclass to create your own DefaultActionProxy instance
      * (like a RMIActionProxy).
      */
-    protected DefaultActionProxy(Configuration cfg, String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception {
-    	String profileKey = "create DefaultActionProxy: ";
+    protected DefaultActionProxy(ObjectFactory objectFactory, Configuration cfg, String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception {
+    	this.objectFactory = objectFactory;
+        String profileKey = "create DefaultActionProxy: ";
     	try {
     		UtilTimerStack.push(profileKey);
     		
     public ActionConfig getConfig() {
         return config;
     }
-
+    
     public void setExecuteResult(boolean executeResult) {
         this.executeResult = executeResult;
     }
     }
 
     protected void prepare() throws Exception {
-        invocation = ActionProxyFactory.getFactory().createActionInvocation(this, extraContext);
+        invocation = new DefaultActionInvocation(objectFactory, this, extraContext);
         resolveMethod();
     }
     

src/java/com/opensymphony/xwork2/DefaultActionProxyFactory.java

 import java.util.Map;
 
 import com.opensymphony.xwork2.config.Configuration;
+import com.opensymphony.xwork2.inject.Container;
+import com.opensymphony.xwork2.inject.Inject;
 
 
 /**
  * @author Jason Carreira
  *         Created Jun 15, 2003 5:19:13 PM
  */
-public class DefaultActionProxyFactory extends ActionProxyFactory {
+public class DefaultActionProxyFactory implements ActionProxyFactory {
 
+    protected Container container;
+    protected ObjectFactory objectFactory;
+    
     public DefaultActionProxyFactory() {
         super();
     }
-
-
-    public ActionInvocation createActionInvocation(ActionProxy actionProxy) throws Exception {
-        return new DefaultActionInvocation(actionProxy);
+    
+    @Inject
+    public void setContainer(Container container) {
+        this.container = container;
     }
-
-    public ActionInvocation createActionInvocation(ActionProxy actionProxy, Map extraContext) throws Exception {
-        return new DefaultActionInvocation(actionProxy, extraContext);
-    }
-
-    public ActionInvocation createActionInvocation(ActionProxy actionProxy, Map extraContext, boolean pushAction) throws Exception {
-        return new DefaultActionInvocation(actionProxy, extraContext, pushAction);
+    
+    @Inject
+    public void setObjectFactory(ObjectFactory factory) {
+        this.objectFactory = factory;
     }
 
     /**
      * Use this method to build an DefaultActionProxy instance.
      */
     public ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext) throws Exception {
-        return new DefaultActionProxy(config, namespace, actionName, extraContext, true, true);
+        ActionProxy proxy = new DefaultActionProxy(objectFactory, config, namespace, actionName, extraContext, true, true);
+        container.inject(proxy);
+        return proxy;
     }
 
     /**
      * Use this method to build an DefaultActionProxy instance.
      */
     public ActionProxy createActionProxy(Configuration config, String namespace, String actionName, Map extraContext, boolean executeResult, boolean cleanupContext) throws Exception {
-        return new DefaultActionProxy(config, namespace, actionName, extraContext, executeResult, cleanupContext);
+        ActionProxy proxy = new DefaultActionProxy(objectFactory, config, namespace, actionName, extraContext, executeResult, cleanupContext);
+        container.inject(proxy);
+        return proxy;
     }
 }

src/java/com/opensymphony/xwork2/InvalidMetadataException.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2;
+
+/**
+ * <code>InvalidMetadataException</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public class InvalidMetadataException extends RuntimeException {
+
+    /**
+	 * Create a new <code>InvalidMetadataException</code> with the supplied error message.
+     * 
+	 * @param msg the error message
+	 */
+	public InvalidMetadataException(String msg) {
+		super(msg);
+	}
+}

src/java/com/opensymphony/xwork2/ObjectFactory.java

 import com.opensymphony.xwork2.config.entities.ActionConfig;
 import com.opensymphony.xwork2.config.entities.InterceptorConfig;
 import com.opensymphony.xwork2.config.entities.ResultConfig;
+import com.opensymphony.xwork2.inject.Container;
+import com.opensymphony.xwork2.inject.Inject;
 import com.opensymphony.xwork2.interceptor.Interceptor;
 import com.opensymphony.xwork2.util.OgnlUtil;
 import com.opensymphony.xwork2.util.XWorkContinuationConfig;
     private static final Log LOG = LogFactory.getLog(ObjectFactory.class);
 
     private static ClassLoader ccl;
-    private static ObjectFactory FACTORY = new ObjectFactory();
+    private static ObjectFactory self = new ObjectFactory();
     private static String continuationPackage;
+    private Container container;
 
     public static void setContinuationPackage(String continuationPackage) {
         
         return continuationPackage;
     }
 
-    protected ObjectFactory() {
+    public ObjectFactory() {
+    }
+    
+    @Inject
+    public void setContainer(Container container) {
+        this.container = container;
+        self = container.getInstance(ObjectFactory.class);
     }
 
     public static void setObjectFactory(ObjectFactory factory) {
-        FACTORY = factory;
+        self = factory;
     }
 
     public static ObjectFactory getObjectFactory() {
-        return FACTORY;
+        return self;
     }
 
     /**
     }
 
     /**
+     * @param obj
+     */
+    protected Object injectInternalBeans(Object obj) {
+        if (obj != null && container != null) {
+            container.inject(obj);
+        }
+        return obj;
+    }
+
+    /**
      * Build a generic Java object of the given type.
      *
      * @param className the type of Object to build
      * @param extraContext a Map of extra context which uses the same keys as the {@link com.opensymphony.xwork2.ActionContext}
      */
     public Object buildBean(String className, Map extraContext) throws Exception {
+        return buildBean(className, extraContext, true);
+    }
+    
+    /**
+     * Build a generic Java object of the given type.
+     *
+     * @param className the type of Object to build
+     * @param extraContext a Map of extra context which uses the same keys as the {@link com.opensymphony.xwork2.ActionContext}
+     */
+    public Object buildBean(String className, Map extraContext, boolean injectInternal) throws Exception {
         Class clazz = getClassInstance(className);
-
-        return buildBean(clazz, extraContext);
+        Object obj = buildBean(clazz, extraContext);
+        if (injectInternal) {
+            injectInternalBeans(obj);
+        }
+        return obj;
     }
 
     /**

src/java/com/opensymphony/xwork2/XWorkTestCase.java

 
 package com.opensymphony.xwork2;
 
+import com.opensymphony.xwork2.config.Configuration;
 import com.opensymphony.xwork2.config.ConfigurationManager;
+import com.opensymphony.xwork2.config.impl.MockConfiguration;
+import com.opensymphony.xwork2.inject.Container;
 import com.opensymphony.xwork2.util.LocalizedTextUtil;
 import com.opensymphony.xwork2.util.OgnlValueStack;
 import com.opensymphony.xwork2.util.ValueStack;
  */
 public abstract class XWorkTestCase extends TestCase {
 
-    protected ConfigurationManager configurationManager = new ConfigurationManager();
+    protected ConfigurationManager configurationManager;
+    protected Configuration configuration;
+    protected Container container;
     
     protected void setUp() throws Exception {
+        configurationManager = new ConfigurationManager();
+        
         // Reset the value stack
         ValueStack stack = new OgnlValueStack();
         ActionContext.setContext(new ActionContext(stack.getContext()));
 
-        //  clear out configuration
-        configurationManager.destroyConfiguration();
-
         // clear out localization
         LocalizedTextUtil.reset();
 
 
         // reset ognl
         OgnlValueStack.reset();
+        
+        configuration = new MockConfiguration();
+        container = configuration.getContainer();
+        ObjectFactory.setObjectFactory(new ObjectFactory());
     }
 
     protected void tearDown() throws Exception {
         // reset the old object factory
-        ObjectFactory.setObjectFactory(new ObjectFactory());
+        ObjectFactory.setObjectFactory(null);
 
         //  clear out configuration
-        configurationManager.destroyConfiguration();
+        if (configurationManager != null) {
+            configurationManager.destroyConfiguration();
+            configurationManager = null;
+        }
+        configuration = null;
+        container = null;
+        ActionContext.setContext(null);
     }
 }

src/java/com/opensymphony/xwork2/apt/AbstractProcessor.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.apt;
+
+import com.sun.mirror.apt.AnnotationProcessor;
+import com.sun.mirror.apt.AnnotationProcessorEnvironment;
+import com.sun.mirror.apt.Filer;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+/**
+ * <code>AbstractProcessor</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public abstract class AbstractProcessor implements AnnotationProcessor {
+
+    protected Log log = null;
+
+    protected AnnotationProcessorEnvironment env;
+
+
+    public AbstractProcessor() {
+        log = LogFactory.getLog(this.getClass());
+    }
+
+
+    /**
+     * Sets the AnnotationProcessorEnvironment.
+     *
+     * @param env the AnnotationProcessorEnvironment.
+     */
+    public void setEnv(AnnotationProcessorEnvironment env) {
+        this.env = env;
+    }
+
+    /**
+     * Initializes all annotations types required for processing.
+     */
+    public void init() {
+    }
+
+    /**
+     * Process all program elements supported by this annotations processor.
+     */
+    public abstract void process();
+
+
+    /**
+     * Returns a PrintWriter that writes to META-INF directory within the Filer.Location.SOURCE_TREE.
+     *
+     * @param filename The filename of the file to be written.
+     * @return PrintWriter that writes to META-INF directory within the Filer.Location.SOURCE_TREE.
+     * @throws IOException
+     */
+    protected PrintWriter getSourceMetaInfWriter(String filename) throws IOException {
+        return env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "", new File("META-INF" + File.separator + filename), "UTF-8");
+    }
+
+    /**
+     * Returns a PrintWriter that writes to META-INF directory within the Filer.Location.CLASS_TREE.
+     *
+     * @param filename The filename of the file to be written.
+     * @return PrintWriter that writes to META-INF directory within the Filer.Location.CLASS_TREE.
+     * @throws IOException
+     */
+    protected PrintWriter getClassesMetaInfWriter(String filename) throws IOException {
+        return env.getFiler().createTextFile(Filer.Location.CLASS_TREE, "", new File("META-INF" + File.separator + filename), "UTF-8");
+    }
+
+    /**
+     * Returns a PrintWriter that writes to WEB-INF directory within the Filer.Location.SOURCE_TREE.
+     *
+     * @param filename The filename of the file to be written.
+     * @return PrintWriter that writes to WEB-INF directory within the Filer.Location.SOURCE_TREE.
+     * @throws IOException
+     */
+    protected PrintWriter getWebInfWriter(String filename) throws IOException {
+        return env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "", new File("WEB-INF" + File.separator + filename), "UTF-8");
+    }
+}

src/java/com/opensymphony/xwork2/apt/ConversionGenerator.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.apt;
+
+import com.opensymphony.xwork2.conversion.metadata.ConversionDescription;
+import com.sun.mirror.apt.Filer;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <code>ConversionGenerator</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public class ConversionGenerator extends Generator {
+
+    Map<String, List<ConversionDescription>> conversionsByType = null;
+
+    public ConversionGenerator(Map<String, List<ConversionDescription>> conversionsByType) {
+        this.conversionsByType = conversionsByType;
+
+    }
+
+    /**
+     * Generate the configuration file.
+     * Concrete implementations must override this method.
+     */
+    public void generate(Filer filer) {
+        if (conversionsByType == null) {
+            return;
+        }
+
+        // write property files
+        for (Map.Entry<String, List<ConversionDescription>> descriptionMapping : conversionsByType.entrySet()) {
+
+            String key = descriptionMapping.getKey();
+            String fileName;
+            if (key.equals("")) {
+                fileName = "xwork-conversion.properties";
+            } else {
+                fileName = key.replace('.', File.separatorChar) + "-conversion.properties";
+
+            }
+            final PrintWriter writer;
+            try {
+                writer = filer.createTextFile(Filer.Location.SOURCE_TREE, "", new File(fileName), null);
+                writer.println("# Generated automatically. Do not edit!");
+
+                for (ConversionDescription component : descriptionMapping.getValue()) {
+                    writer.println(component.asProperty());
+                }
+                writer.flush();
+                writer.close();
+
+            } catch (IOException ioe) {
+                throw new RuntimeException("could not generate conversion.properties: " + ioe, ioe);
+            }
+        }
+    }
+}

src/java/com/opensymphony/xwork2/apt/ConversionProcessor.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.apt;
+
+import com.opensymphony.xwork2.conversion.annotations.Conversion;
+import com.opensymphony.xwork2.conversion.annotations.ConversionType;
+import com.opensymphony.xwork2.conversion.annotations.TypeConversion;
+import com.opensymphony.xwork2.conversion.metadata.ConversionDescription;
+import com.opensymphony.xwork2.util.AnnotationUtils;
+import com.sun.mirror.declaration.*;
+import com.sun.mirror.type.ClassType;
+import com.sun.mirror.type.InterfaceType;
+
+import java.util.*;
+
+/**
+ * <code>ConversionProcessor</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public class ConversionProcessor extends AbstractProcessor {
+
+    private AnnotationTypeDeclaration conversionAnnotation;
+    private AnnotationTypeDeclaration typeConversionAnnotation;
+
+    /**
+     * Initializes all annotations types required for processing.
+     */
+    public void init() {
+        super.init();
+        this.conversionAnnotation = (AnnotationTypeDeclaration) env.getTypeDeclaration(Conversion.class.getName());
+        this.typeConversionAnnotation = (AnnotationTypeDeclaration) env.getTypeDeclaration(TypeConversion.class.getName());
+    }
+
+
+    /**
+     * Process all program elements supported by this annotations processor.
+     */
+    public void process() {
+
+        final Map<String, List<ConversionDescription>> conversionsByType = new Hashtable<String, List<ConversionDescription>>();
+
+        for (Declaration compDecl : env.getDeclarationsAnnotatedWith(conversionAnnotation)) {
+
+            /*
+            * Get all fields with TypeConversion-Annotation of component
+            */
+            List<ConversionDescription> applicationFields = new ArrayList<ConversionDescription>();
+            List<ConversionDescription> classFields = new ArrayList<ConversionDescription>();
+
+            if ( compDecl instanceof InterfaceDeclaration) {
+
+                final InterfaceDeclaration component = (InterfaceDeclaration) compDecl;
+
+                addConversionFields(component, applicationFields, classFields);
+
+                conversionsByType.put("", applicationFields);
+                conversionsByType.put(component.getQualifiedName(), classFields);
+            } else if ( compDecl instanceof ClassDeclaration) {
+                final ClassDeclaration component = (ClassDeclaration) compDecl;
+
+                addConversionFields(component, applicationFields, classFields);
+
+                conversionsByType.put("", applicationFields);
+                conversionsByType.put(component.getQualifiedName(), classFields);
+
+            }
+
+        }
+
+        /**
+         * Holds all components without usage (="default usage")
+         */
+        List<ConversionDescription> defaultDescriptions = conversionsByType.get("");
+
+        // Add components with default usage to specific components
+        /*
+        for (Map.Entry<String, List<ConversionDescription>> descriptionMapping : conversionsByType.entrySet()) {
+            if (!"".equals(descriptionMapping.getKey())) {
+                addDefaultConversions(defaultDescriptions, descriptionMapping.getValue());
+            }
+        }
+        */
+
+        new ConversionGenerator(conversionsByType).generate(env.getFiler());
+    }
+
+    private void addDefaultConversions(List<ConversionDescription> defaultComponents, List<ConversionDescription> specialComponents) {
+        for (ConversionDescription description : defaultComponents) {
+            if (!specialComponents.contains(description)) {
+                specialComponents.add(description);
+            }
+        }
+    }
+
+    private ConversionDescription createConversionDescription(MethodDeclaration method, AnnotationMirror annotation) {
+
+        Map<AnnotationTypeElementDeclaration, AnnotationValue> values = annotation.getElementValues();
+
+        final ConversionDescription result;
+
+        String property = AnnotationUtils.resolvePropertyName(method);
+
+        if (typeConversionAnnotation.equals(annotation.getAnnotationType().getDeclaration())) {
+
+
+            result = new ConversionDescription(property);
+
+            for (AnnotationTypeElementDeclaration element : typeConversionAnnotation.getMethods()) {
+                AnnotationValue value = values.get(element);
+                if (value == null) {
+                    value = element.getDefaultValue();
+                }
+
+                String name = element.getSimpleName();
+                if ("rule".equals(name)) {
+                    result.setRule(value.getValue().toString());
+                } else if ("converter".equals(name)) {
+                    result.setTypeConverter(value.getValue().toString());
+                } else if ("message".equals(name)) {
+                    result.setValue(value.getValue().toString());
+                } else if ("key".equals(name)) {
+                    String s = value.getValue().toString();
+                    if ( s != null && s.length() > 0 ) {
+                        result.setProperty(s);
+                    }
+                } else if ("type".equals(name)) {
+                    result.setType(value.getValue().toString());
+                }
+            }
+            return result;
+        }
+        return null;
+    }
+
+    /**
+     * Adds all fields with TypeConversion Annotation of class clazz and
+     * its superclasses to allFields
+     */
+    private void addConversionFields(ClassDeclaration clazz, List<ConversionDescription> allApplicationFields, List<ConversionDescription> allClassFields) {
+        if (clazz == null) {
+            return;
+        }
+
+        processConversionFields(clazz, allApplicationFields, allClassFields);
+
+        ClassType superClazz = clazz.getSuperclass();
+        if (superClazz != null) {
+            addConversionFields(superClazz.getDeclaration(), allApplicationFields, allClassFields);
+        }
+    }
+
+    /**
+     * Adds all fields with TypeConversion Annotation of class clazz and
+     * its superclasses to allFields
+     */
+    private void addConversionFields(InterfaceDeclaration clazz, List<ConversionDescription> allApplicationFields, List<ConversionDescription> allClassFields) {
+        if (clazz == null) {
+            return;
+        }
+
+        processConversionFields(clazz, allApplicationFields, allClassFields);
+        Collection<InterfaceType> ifaces = clazz.getSuperinterfaces();
+
+        if ( ifaces != null ) {
+            for ( InterfaceType it : ifaces) {
+                addConversionFields(it.getDeclaration(), allApplicationFields, allClassFields);
+            }
+        }
+    }
+
+    private void processConversionFields(TypeDeclaration clazz, List<ConversionDescription> allApplicationFields, List<ConversionDescription> allClassFields) {
+        Collection<? extends MethodDeclaration> methods = clazz.getMethods();
+
+        for (MethodDeclaration method : methods) {
+
+            Collection<AnnotationMirror> annos = method.getAnnotationMirrors();
+            for (AnnotationMirror am : annos) {
+
+                Map<AnnotationTypeElementDeclaration, AnnotationValue> values = am.getElementValues();
+                for ( AnnotationTypeElementDeclaration element : typeConversionAnnotation.getMethods()) {
+                    AnnotationValue value = values.get(element);
+                    if (value == null) {
+                        value = element.getDefaultValue();
+                    }
+                    if ( "type".equals(element.getSimpleName()) ) {
+                        ConversionDescription desc = createConversionDescription(method, am);
+                        if ( desc != null ) {
+                            if ( value.getValue().toString().equals(ConversionType.APPLICATION.toString())) {
+                                allApplicationFields.add(desc);
+                            } else {
+                                allClassFields.add(desc);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/java/com/opensymphony/xwork2/apt/Generator.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.apt;
+
+import com.sun.mirror.apt.AnnotationProcessorEnvironment;
+import com.sun.mirror.apt.Filer;
+
+/**
+ * <code>Generator</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public abstract class Generator {
+
+
+    protected AnnotationProcessorEnvironment env;
+
+
+    /**
+     * Sets the AnnotationProcessorEnvironment.
+     *
+     * @param env the AnnotationProcessorEnvironment.
+     */
+    public void setEnv(AnnotationProcessorEnvironment env) {
+        this.env = env;
+    }
+
+    /**
+     * Generate the configuration file.
+     * Concrete implementations must override this method.
+     */
+    public abstract void generate(Filer filer);
+
+}

src/java/com/opensymphony/xwork2/apt/XWorkProcessorFactory.java

+/*
+ * Copyright (c) 2002-2006 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.apt;
+
+import com.opensymphony.xwork2.conversion.annotations.Conversion;
+import com.opensymphony.xwork2.validator.annotations.Validation;
+import com.sun.mirror.apt.AnnotationProcessor;
+import com.sun.mirror.apt.AnnotationProcessorEnvironment;
+import com.sun.mirror.apt.AnnotationProcessorFactory;
+import com.sun.mirror.apt.AnnotationProcessors;
+import com.sun.mirror.declaration.AnnotationTypeDeclaration;
+
+import java.util.*;
+import java.util.prefs.Preferences;
+
+/**
+ * <code>XWorkProcessorFactory</code>
+ *
+ * @author Rainer Hermanns
+ * @version $Id$
+ */
+public class XWorkProcessorFactory implements AnnotationProcessorFactory {
+
+    private static Preferences preferences = Preferences.userNodeForPackage(XWorkProcessorFactory.class);
+
+
+    /**
+     * Returns the options recognized by this factory or by any of the processors it may create.
+     *
+     * @return the options recognized by this factory or by any of the processors it may create,
+     *         or an empty collection if none.
+     */
+    public Collection<String> supportedOptions() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * Returns the names of the annotations types supported by this factory.
+     *
+     * @return the names of the annotations types supported by this factory.
+     */
+    public Collection<String> supportedAnnotationTypes() {
+        return createCollection(
+                "com.opensymphony.xwork2.conversion.annotations.*" //,
+                //"com.opensymphony.xwork2.validator.annotations.*"
+        );
+    }
+
+
+    /**
+     * Returns an annotations processor for a set of annotations types.
+     *
+     * @param declarations The type declarations for the annotations types to be processed.
+     * @param env          The environment to use during processing.
+     * @return an annotations processor for the given annotations types, or <tt>null</tt>
+     *         if the types are not supported or the processor cannot be created.
+     */
+    public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> declarations, AnnotationProcessorEnvironment env) {
+        List<AnnotationProcessor> processors = new LinkedList<AnnotationProcessor>();
+
+        AnnotationTypeDeclaration conversionType = (AnnotationTypeDeclaration) env.getTypeDeclaration(Conversion.class.getName());
+        //AnnotationTypeDeclaration validationType = (AnnotationTypeDeclaration) env.getTypeDeclaration(Validation.class.getName());
+
+        if (declarations.contains(conversionType)) {
+            ConversionProcessor conversion = new ConversionProcessor();
+
+            conversion.setEnv(env);
+            conversion.init();
+            processors.add(conversion);
+        }
+
+        // TODO: Temporary disabled...
+        /*
+        if (declarations.contains(validationType)) {
+            ValidationProcessor validation = new ValidationProcessor();
+            validation.setEnv(env);
+            validation.init();
+            processors.add(validation);
+        }
+        */
+
+        if (processors.isEmpty()) {
+            return AnnotationProcessors.NO_OP;
+        }
+
+        if (processors.size() == 1) {
+            return processors.get(0);
+        }
+
+        return AnnotationProcessors.getCompositeAnnotationProcessor(processors);
+    }
+
+    public static <T> Collection<T> createCollection(T... args) {
+        return Arrays.asList(args);
+    }
+}

src/java/com/opensymphony/xwork2/config/Configuration.java

 package com.opensymphony.xwork2.config;
 
 import com.opensymphony.xwork2.config.entities.PackageConfig;
+import com.opensymphony.xwork2.inject.Container;
 
 import java.util.List;
 import java.util.Map;
  * @author Mike
  */
 public interface Configuration {
-
+    
     public void rebuildRuntimeConfiguration();
 
     PackageConfig getPackageConfig(String name);
     void reload(List<ConfigurationProvider> providers) throws ConfigurationException;
 
     void removePackageConfig(String name);
+
+    /**
+     * @return the container
+     */
+    public Container getContainer();
+
+    public Set<String> getLoadedFileNames();
 }

src/java/com/opensymphony/xwork2/config/ConfigurationManager.java

     protected Configuration configuration;
     protected Lock providerLock = new ReentrantLock();
     private List<ConfigurationProvider> configurationProviders = new CopyOnWriteArrayList<ConfigurationProvider>();
+    protected String defaultFrameworkBeanName;
 
     public ConfigurationManager() {
+        this("xwork");
+    }
+    
+    public ConfigurationManager(String name) {
+        this.defaultFrameworkBeanName = name;
     }
 
     /**
      */
     public synchronized Configuration getConfiguration() {
         if (configuration == null) {
-            setConfiguration(new DefaultConfiguration());
+            setConfiguration(new DefaultConfiguration(defaultFrameworkBeanName));
             try {
                 configuration.reload(getConfigurationProviders());
             } catch (ConfigurationException e) {
         providerLock.lock();
         try {
             if (configurationProviders.size() == 0) {
-                configurationProviders.add(new XmlConfigurationProvider());
+                configurationProviders.add(new XmlConfigurationProvider("xwork.xml", true));
             }
 
             return configurationProviders;
             configurationProviders.add(provider);
         }
     }
+    
+    /**
+     * clears the registered ConfigurationProviders.  this method will call destroy() on each of the registered
+     * ConfigurationProviders
+     *
+     * @see com.opensymphony.xwork2.config.ConfigurationProvider#destroy
+     */
+    public void clearConfigurationProviders() {
+        for (ConfigurationProvider configurationProvider : configurationProviders) {
+            configurationProvider.destroy();
+        }
+
+        configurationProviders.clear();
+    }
+
+    public synchronized void destroyConfiguration() {
+        clearConfigurationProviders(); // let's destroy the ConfigurationProvider first
+        setConfigurationProviders(new CopyOnWriteArrayList<ConfigurationProvider>());
+        if (configuration != null)
+            configuration.destroy(); // let's destroy it first, before nulling it.
+        configuration = null;
+    }
 
 
     /**
             List<ConfigurationProvider> providers = getConfigurationProviders();
             for (ConfigurationProvider provider : providers) {
                 if (provider.needsReload()) {
+                    if (LOG.isInfoEnabled()) {
+                        LOG.info("Detected configuration provider "+provider+" needs to be reloaded.  Reloading all providers.");
+                    }
                     reload = true;
 
                     break;
     public synchronized void reload() {
         getConfiguration().reload(getConfigurationProviders());
     }
-
-    /**
-     * clears the registered ConfigurationProviders.  this method will call destroy() on each of the registered
-     * ConfigurationProviders
-     *
-     * @see com.opensymphony.xwork2.config.ConfigurationProvider#destroy
-     */
-    public void clearConfigurationProviders() {
-        for (ConfigurationProvider configurationProvider : configurationProviders) {
-            configurationProvider.destroy();
-        }
-
-        configurationProviders.clear();
-    }
-
-    public synchronized void destroyConfiguration() {
-        clearConfigurationProviders(); // let's destroy the ConfigurationProvider first
-        setConfigurationProviders(new CopyOnWriteArrayList<ConfigurationProvider>());
-        if (configuration != null)
-            configuration.destroy(); // let's destroy it first, before nulling it.
-        configuration = null;
-    }
 }

src/java/com/opensymphony/xwork2/config/ConfigurationProvider.java

  */
 package com.opensymphony.xwork2.config;
 
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Properties;
+
+import com.opensymphony.xwork2.inject.Container;
+import com.opensymphony.xwork2.inject.ContainerBuilder;
+
 
 /**
  * Interface to be implemented by all forms of XWork configuration classes.
 public interface ConfigurationProvider {
 
     public void destroy();
-
-    /**
-     * Initializes the configuration object.
-     */
+    
     public void init(Configuration configuration) throws ConfigurationException;
-
+    
+    public void register(ContainerBuilder builder, Properties props) throws ConfigurationException;
+    
+    public void loadPackages() throws ConfigurationException;
+    
     /**
      * Tells whether the ConfigurationProvider should reload its configuration
      *
      * @return <tt>true</tt>, whether the ConfigurationProvider should reload its configuration, <tt>false</tt>otherwise.
      */
     public boolean needsReload();
+    
 }

src/java/com/opensymphony/xwork2/config/ExternalReferenceResolver.java

-/*
- * Copyright (c) 2002-2006 by OpenSymphony
- * All rights reserved.
- */
-package com.opensymphony.xwork2.config;
-
-import com.opensymphony.xwork2.ActionInvocation;
-
-
-/**
- * Resolves references declared in the action configuration from an external source
- */
-public interface ExternalReferenceResolver {
-
-    public void resolveReferences(ActionInvocation invocation) throws ReferenceResolverException;
-}

src/java/com/opensymphony/xwork2/config/entities/InterceptorConfig.java

  */
 package com.opensymphony.xwork2.config.entities;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.LinkedHashMap;
 import java.io.Serializable;
         this.className = className;
         this.params = params;
     }
+    
+    public InterceptorConfig(InterceptorConfig parent, Map params) {
+        this.name = parent.getName();
+        this.className = parent.getClassName();
+        this.params = new HashMap(parent.getParams());
+        this.params.putAll(params);
+    }
 
 
     public void setClassName(String className) {

src/java/com/opensymphony/xwork2/config/entities/PackageConfig.java

 package com.opensymphony.xwork2.config.entities;
 
 import com.opensymphony.xwork2.util.TextUtils;
-import com.opensymphony.xwork2.config.ExternalReferenceResolver;
 import com.opensymphony.xwork2.util.location.Located;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
     private static final Log LOG = LogFactory.getLog(PackageConfig.class);
 
 
-    private ExternalReferenceResolver externalRefResolver = null;
     private Map<String, ActionConfig> actionConfigs = new LinkedHashMap<String, ActionConfig>();
     private Map<String, ResultConfig> globalResultConfigs = new LinkedHashMap<String, ResultConfig>();
     private Map interceptorConfigs = new LinkedHashMap();
         this.name = name;
     }
 
-    public PackageConfig(String name, String namespace, boolean isAbstract, ExternalReferenceResolver externalRefResolver) {
+    public PackageConfig(String name, String namespace, boolean isAbstract) {
         this(name);
         this.namespace = TextUtils.noNull(namespace);
         this.isAbstract = isAbstract;
-        this.externalRefResolver = externalRefResolver;
     }
 
-    public PackageConfig(String name, String namespace, boolean isAbstract, ExternalReferenceResolver externalRefResolver, List parents) {
-        this(name, namespace, isAbstract, externalRefResolver);
+    public PackageConfig(String name, String namespace, boolean isAbstract, List parents) {
+        this(name, namespace, isAbstract);
 
-        for (Iterator iterator = parents.iterator(); iterator.hasNext();) {
-            PackageConfig parent = (PackageConfig) iterator.next();
-            addParent(parent);
+        if (parents != null) {
+            for (Iterator iterator = parents.iterator(); iterator.hasNext();) {
+                PackageConfig parent = (PackageConfig) iterator.next();
+                addParent(parent);
+            }
         }
     }
 
     }
 
     /**
-     * @param externalRefResolver The externalRefResolver to set.
-     */
-    public void setExternalRefResolver(ExternalReferenceResolver externalRefResolver) {
-        this.externalRefResolver = externalRefResolver;
-    }
-
-    /**
-     * Gets the Reference resolver for this package.  If the resolver for this package is
-     * not specified, the method will try and find one on one of the parent packages
-     *
-     * @return Returns the externalRefResolver.
-     */
-    public ExternalReferenceResolver getExternalRefResolver() {
-        //If this resolver is null, lets look to see if our parents have one
-        if (externalRefResolver == null) {
-            PackageConfig packageConfig;
-
-            for (Iterator<PackageConfig> iter = getParents().iterator(); iter.hasNext();) {
-                packageConfig = iter.next();
-
-                if (packageConfig.getExternalRefResolver() != null) {
-                    externalRefResolver = packageConfig.getExternalRefResolver();
-
-                    break;
-                }
-            }
-        }
-
-        return externalRefResolver;
-    }
-
-    /**
      * gets the default interceptor-ref name. If this is not set on this PackageConfig, it searches the parent
      * PackageConfigs in order until it finds one.
      */

src/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java

  */
 package com.opensymphony.xwork2.config.impl;
 
+import com.opensymphony.xwork2.ObjectFactory;
 import com.opensymphony.xwork2.config.Configuration;
 import com.opensymphony.xwork2.config.ConfigurationException;
 import com.opensymphony.xwork2.config.ConfigurationProvider;
 import com.opensymphony.xwork2.config.RuntimeConfiguration;
 import com.opensymphony.xwork2.config.entities.*;
 import com.opensymphony.xwork2.config.providers.InterceptorBuilder;
+import com.opensymphony.xwork2.inject.Container;
+import com.opensymphony.xwork2.inject.ContainerBuilder;
+import com.opensymphony.xwork2.inject.Context;
+import com.opensymphony.xwork2.inject.Factory;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 
 
     // Programmatic Action Conifigurations
-    private Map<String, PackageConfig> packageContexts = new LinkedHashMap<String, PackageConfig>();
+    protected Map<String, PackageConfig> packageContexts = new LinkedHashMap<String, PackageConfig>();
     protected RuntimeConfiguration runtimeConfiguration;
+    protected Container container;
+    protected String defaultFrameworkBeanName;
+    protected Set<String> loadedFileNames = new TreeSet<String>();
+
 
+    ObjectFactory objectFactory;
 
     public DefaultConfiguration() {
+        this("xwork");
+    }
+    
+    public DefaultConfiguration(String defaultBeanName) {
+        this.defaultFrameworkBeanName = defaultBeanName;
     }
 
 
     public Map getPackageConfigs() {
         return packageContexts;
     }
+    
+    public Set<String> getLoadedFileNames() {
+        return loadedFileNames;
+    }
 
     public RuntimeConfiguration getRuntimeConfiguration() {
         return runtimeConfiguration;
     }
+    
+    /**
+     * @return the container
+     */
+    public Container getContainer() {
+        return container;
+    }
 
     public void addPackageConfig(String name, PackageConfig packageContext) {
         PackageConfig check = packageContexts.get(name);
      */
     public synchronized void reload(List<ConfigurationProvider> providers) throws ConfigurationException {
         packageContexts.clear();
+        loadedFileNames.clear();
 
+        ContainerProperties props = new ContainerProperties();
+        ContainerBuilder builder = new ContainerBuilder();
         for (ConfigurationProvider configurationProvider : providers)
         {
             configurationProvider.init(this);
+            configurationProvider.register(builder, props);
+        }
+        props.setConstants(builder);
+        
+        builder.factory(Configuration.class, new Factory() {
+            public Object create(Context context) throws Exception {
+                return DefaultConfiguration.this;
+            }
+            
+        });
+        
+        container = builder.create(false);
+        objectFactory = container.getInstance(ObjectFactory.class);
+        
+        for (ConfigurationProvider configurationProvider : providers)
+        {
+            container.inject(configurationProvider);
+            configurationProvider.loadPackages();
         }
 
         rebuildRuntimeConfiguration();
 
             if (defaultInterceptorRefName != null) {
                 interceptors.addAll(InterceptorBuilder.constructInterceptorReference(packageContext, defaultInterceptorRefName, 
-                        new LinkedHashMap(), packageContext.getLocation()));
+                        new LinkedHashMap(), packageContext.getLocation(), objectFactory));
             }
         }
 
             return buff.toString();
         }
     }
+    
+    class ContainerProperties extends Properties {
+        public Object setProperty(String key, String value) {
+            String oldValue = getProperty(key);
+            if (oldValue != null && !oldValue.equals(value) && !defaultFrameworkBeanName.equals(oldValue)) {
+                LOG.info("Overriding property "+key+" - old value: "+oldValue+" new value: "+value);
+            }
+            return super.setProperty(key, value);
+        }
+
+        public void setConstants(ContainerBuilder builder) {
+            for (Object key : keySet()) {
+                builder.constant((String)key, getProperty((String)key));
+            }
+        }
+    }
 }

src/java/com/opensymphony/xwork2/config/impl/MockConfiguration.java

+/*
+ * Copyright (c) 2002-2003 by OpenSymphony
+ * All rights reserved.
+ */
+package com.opensymphony.xwork2.config.impl;
+
+import com.opensymphony.xwork2.ActionProxyFactory;
+import com.opensymphony.xwork2.DefaultActionProxyFactory;
+import com.opensymphony.xwork2.ObjectFactory;
+import com.opensymphony.xwork2.config.Configuration;
+import com.opensymphony.xwork2.config.ConfigurationException;
+import com.opensymphony.xwork2.config.ConfigurationProvider;
+import com.opensymphony.xwork2.config.RuntimeConfiguration;
+import com.opensymphony.xwork2.config.entities.PackageConfig;
+import com.opensymphony.xwork2.inject.Container;
+import com.opensymphony.xwork2.inject.ContainerBuilder;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+
+/**
+ * Simple configuration used for unit testing
+ */
+public class MockConfiguration implements Configuration {
+
+    private Map packages = new HashMap();
+    private Set loadedFiles = new HashSet();
+    private Container container;
+    
+    public MockConfiguration() {
+        container = new ContainerBuilder()
+            .factory(ObjectFactory.class)
+            .factory(ActionProxyFactory.class, DefaultActionProxyFactory.class)
+            .create(true);
+    }
+
+    public PackageConfig getPackageConfig(String name) {
+        return (PackageConfig) packages.get(name);
+    }
+
+    public Set getPackageConfigNames() {
+        return packages.keySet();
+    }
+
+    public Map getPackageConfigs() {
+        return packages;
+    }
+
+    public RuntimeConfiguration getRuntimeConfiguration() {
+        throw new UnsupportedOperationException();
+    }
+
+    public void addPackageConfig(String name, PackageConfig packageContext) {
+        packages.put(name, packageContext);
+    }
+
+    public void buildRuntimeConfiguration() {
+        throw new UnsupportedOperationException();
+    }
+
+    public void destroy() {
+        throw new UnsupportedOperationException();
+    }
+
+    public void rebuildRuntimeConfiguration() {
+        throw new UnsupportedOperationException();
+    }
+
+    public void reload(List<ConfigurationProvider> providers) throws ConfigurationException {
+        throw new UnsupportedOperationException();
+    }
+
+    public void removePackageConfig(String name) {