public int compare(Document doc1, Document doc2) { return XmlHelper.getLoadOrder(doc1).compareTo(XmlHelper.getLoadOrder(doc2)); } });
/** * Looks up the Interceptor Class from the interceptor-ref name and creates an instance, which is added to the * provided List, or, if this is a ref to a stack, it adds the Interceptor instances from the List to this stack. * * @param interceptorRefElement Element to pull interceptor ref data from * @param context The PackageConfig to lookup the interceptor from * @return A list of Interceptor objects */ private List<InterceptorMapping> lookupInterceptorReference(PackageConfig.Builder context, Element interceptorRefElement) throws ConfigurationException { String refName = interceptorRefElement.getAttribute("name"); Map<String, String> refParams = XmlHelper.getParams(interceptorRefElement); Location loc = LocationUtils.getLocation(interceptorRefElement); return InterceptorBuilder.constructInterceptorReference(context, refName, refParams, loc, objectFactory); }
public boolean containsCycle() { for (T v : graph) { if (!marks.containsKey(v)) { if (mark(v)) { // return true; } } } // return false; return !verticesInCycles.isEmpty(); }
public Object getObject() throws Exception { ConfigurationManager confManager = new ConfigurationManager(); confManager.addContainerProvider(new XWorkConfigurationProvider()); SpringContainer springContainer = new SpringContainer(); springContainer.setApplicationContext(_context); confManager.addContainerProvider(springContainer); for (String xmlConfigurationSource : _xmlConfigurationSources) { XmlConfigurationProvider xml = new XmlConfigurationProvider( xmlConfigurationSource, true); xml.setThrowExceptionOnDuplicateBeans(false); confManager.addContainerProvider(xml); } return confManager.getConfiguration(); }
private void verifyPackageStructure() { DirectedGraph<String> graph = new DirectedGraph<String>(); String packageName = child.getAttribute("name"); declaredPackages.put(packageName, child); graph.addNode(packageName); graph.addNode(parent); graph.addEdge(packageName, parent); CycleDetector<String> detector = new CycleDetector<String>(graph); if (detector.containsCycle()) { StringBuilder builder = new StringBuilder("The following packages participate in cycles:"); for (String packageName : detector.getVerticesInCycles()) { builder.append(" "); builder.append(packageName);
/** * Get the current list of ConfigurationProviders. If no custom ConfigurationProviders have been added, this method * will return a list containing only the default ConfigurationProvider, XMLConfigurationProvider. if a custom * ConfigurationProvider has been added, then the XmlConfigurationProvider must be added by hand. * </p> * <p/> * TODO: the lazy instantiation of XmlConfigurationProvider should be refactored to be elsewhere. the behavior described above seems unintuitive. * * @return the list of registered ConfigurationProvider objects * @see ConfigurationProvider */ public List<ContainerProvider> getContainerProviders() { providerLock.lock(); try { if (containerProviders.size() == 0) { containerProviders.add(new XWorkConfigurationProvider()); containerProviders.add(new XmlConfigurationProvider("xwork.xml", false)); } return containerProviders; } finally { providerLock.unlock(); } }
configurationManager.addContainerProvider(new XWorkConfigurationProvider()); for (ConfigurationProvider prov : providers) { if (prov instanceof XmlConfigurationProvider) { ((XmlConfigurationProvider)prov).setThrowExceptionOnDuplicateBeans(false);
public void selfRegister() { //this cannot be done in the constructor, as it causes an infinite loop builder.factory(Configuration.class, MockConfiguration.class, Scope.SINGLETON); LocatableProperties props = new LocatableProperties(); new XWorkConfigurationProvider().register(builder, props); builder.constant(XWorkConstants.DEV_MODE, "false"); builder.constant(XWorkConstants.RELOAD_XML_CONFIGURATION, "true"); builder.constant(XWorkConstants.ENABLE_OGNL_EXPRESSION_CACHE, "true"); container = builder.create(true); }
private boolean mark(T vertex) { /* * return statements commented out for fail slow behavior detect all nodes in cycles instead of just the first one */ List<T> localCycles = new ArrayList<T>(); marks.put(vertex, marked); for (T u : graph.edgesFrom(vertex)) { if (marks.containsKey(u) && marks.get(u).equals(marked)) { localCycles.add(vertex); // return true; } else if (!marks.containsKey(u)) { if (mark(u)) { localCycles.add(vertex); // return true; } } } marks.put(vertex, complete); // return false; verticesInCycles.addAll(localCycles); return !localCycles.isEmpty(); }
protected void loadInterceptors(PackageConfig.Builder context, Element element) throws ConfigurationException { NodeList interceptorList = element.getElementsByTagName("interceptor"); for (int i = 0; i < interceptorList.getLength(); i++) { Element interceptorElement = (Element) interceptorList.item(i); String name = interceptorElement.getAttribute("name"); String className = interceptorElement.getAttribute("class"); Map<String, String> params = XmlHelper.getParams(interceptorElement); InterceptorConfig config = new InterceptorConfig.Builder(name, className) .addParams(params) .location(DomHelper.getLocationObject(interceptorElement)) .build(); context.addInterceptorConfig(config); } loadInterceptorStacks(element, context); }
Class clazz = verifyResultType(className, loc); if (clazz != null) { String paramName = null; .location(DomHelper.getLocationObject(resultTypeElement)); Map<String, String> params = XmlHelper.getParams(resultTypeElement);
protected List<InterceptorMapping> buildInterceptorList(PackageConfig.Builder builder, InterceptorRef ref, Map params) { return InterceptorBuilder.constructInterceptorReference(builder, ref.value(), params, builder.build().getLocation(), configuration.getContainer().getInstance(ObjectFactory.class)); }
protected List<InterceptorMapping> buildInterceptorList(Element element, PackageConfig.Builder context) throws ConfigurationException { List<InterceptorMapping> interceptorList = new ArrayList<InterceptorMapping>(); NodeList interceptorRefList = element.getElementsByTagName("interceptor-ref"); for (int i = 0; i < interceptorRefList.getLength(); i++) { Element interceptorRefElement = (Element) interceptorRefList.item(i); if (interceptorRefElement.getParentNode().equals(element) || interceptorRefElement.getParentNode().getNodeName().equals(element.getNodeName())) { List<InterceptorMapping> interceptors = lookupInterceptorReference(context, interceptorRefElement); interceptorList.addAll(interceptors); } } return interceptorList; }
public XmlConfigurationProvider(String filename, boolean errorIfMissing) { this.configFileName = filename; this.errorIfMissing = errorIfMissing; Map<String, String> mappings = new HashMap<String, String>(); mappings.put("-//Apache Struts//XWork 2.3//EN", "xwork-2.3.dtd"); mappings.put("-//Apache Struts//XWork 2.1.3//EN", "xwork-2.1.3.dtd"); mappings.put("-//Apache Struts//XWork 2.1//EN", "xwork-2.1.dtd"); mappings.put("-//Apache Struts//XWork 2.0//EN", "xwork-2.0.dtd"); mappings.put("-//Apache Struts//XWork 1.1.1//EN", "xwork-1.1.1.dtd"); mappings.put("-//Apache Struts//XWork 1.1//EN", "xwork-1.1.dtd"); mappings.put("-//Apache Struts//XWork 1.0//EN", "xwork-1.0.dtd"); setDtdMappings(mappings); }
public void init(Configuration configuration) { this.configuration = configuration; this.includedFileNames = configuration.getLoadedFileNames(); loadDocuments(configFileName); }
private void loadDocuments(String configFileName) { try { loadedFileUrls.clear(); documents = loadConfigurationFiles(configFileName, null); } catch (ConfigurationException e) { throw e; } catch (Exception e) { throw new ConfigurationException("Error loading configuration file " + configFileName, e); } }
/** * Load all of the global results for this package from the XML element. */ protected void loadGlobalResults(PackageConfig.Builder packageContext, Element packageElement) { NodeList globalResultList = packageElement.getElementsByTagName("global-results"); if (globalResultList.getLength() > 0) { Element globalResultElement = (Element) globalResultList.item(0); Map<String, ResultConfig> results = buildResults(globalResultElement, packageContext); packageContext.addGlobalResultConfigs(results); } }
/** * Load all of the global results for this package from the XML element. */ protected void loadGobalExceptionMappings(PackageConfig.Builder packageContext, Element packageElement) { NodeList globalExceptionMappingList = packageElement.getElementsByTagName("global-exception-mappings"); if (globalExceptionMappingList.getLength() > 0) { Element globalExceptionMappingElement = (Element) globalExceptionMappingList.item(0); List<ExceptionMappingConfig> exceptionMappings = buildExceptionMappings(globalExceptionMappingElement, packageContext); packageContext.addGlobalExceptionMappingConfigs(exceptionMappings); } }
protected void loadInterceptorStacks(Element element, PackageConfig.Builder context) throws ConfigurationException { NodeList interceptorStackList = element.getElementsByTagName("interceptor-stack"); for (int i = 0; i < interceptorStackList.getLength(); i++) { Element interceptorStackElement = (Element) interceptorStackList.item(i); InterceptorStackConfig config = loadInterceptorStack(interceptorStackElement, context); context.addInterceptorStackConfig(config); } }
protected InterceptorStackConfig loadInterceptorStack(Element element, PackageConfig.Builder context) throws ConfigurationException { String name = element.getAttribute("name"); InterceptorStackConfig.Builder config = new InterceptorStackConfig.Builder(name) .location(DomHelper.getLocationObject(element)); NodeList interceptorRefList = element.getElementsByTagName("interceptor-ref"); for (int j = 0; j < interceptorRefList.getLength(); j++) { Element interceptorRefElement = (Element) interceptorRefList.item(j); List<InterceptorMapping> interceptors = lookupInterceptorReference(context, interceptorRefElement); config.addInterceptors(interceptors); } return config.build(); }