/** * Implement the decorator pattern for the factory implementation. * * <p> * * <p>If <code>previousImpl</code> is non-<code>null</code> and the class named by the argument * <code>implName</code> has a one arg contstructor of type <code>factoryName</code>, instantiate * it, passing previousImpl to the constructor. * * <p> * * <p>Otherwise, we just instantiate and return <code>implName</code>. * * @param classLoader the ClassLoader from which to load the class * @param factoryName the fully qualified class name of the factory. * @param implName the fully qualified class name of a class that implements the factory. * @param previousImpl if non-<code>null</code>, the factory instance to be passed to the * constructor of the new factory. */ private static Object getImplGivenPreviousImpl( ClassLoader classLoader, String factoryName, String implName, Object previousImpl) { Class clazz; Class factoryClass = null; Class[] getCtorArg; Object[] newInstanceArgs = new Object[1]; Constructor ctor; Object result = null; InjectionProvider provider = null; // if we have a previousImpl and the appropriate one arg ctor. if ((null != previousImpl) && (null != (factoryClass = getFactoryClass(factoryName)))) { try { clazz = Class.forName(implName, false, classLoader); getCtorArg = new Class[1]; getCtorArg[0] = factoryClass; ctor = clazz.getConstructor(getCtorArg); newInstanceArgs[0] = previousImpl; result = ctor.newInstance(newInstanceArgs); FactoryManager fm = FACTORIES_CACHE.getApplicationFactoryManager(classLoader); provider = fm.getInjectionProvider(); if (null != provider) { provider.inject(result); provider.invokePostConstruct(result); } else { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log( Level.SEVERE, "Unable to inject {0} because no InjectionProvider can be found. Does this container implement the Mojarra Injection SPI?", result); } } } catch (NoSuchMethodException nsme) { // fall through to "zero-arg-ctor" case factoryClass = null; } catch (Exception e) { throw new FacesException(implName, e); } } if (null == previousImpl || null == factoryClass) { // we have either no previousImpl or no appropriate one arg // ctor. try { clazz = Class.forName(implName, false, classLoader); // since this is the hard coded implementation default, // there is no preceding implementation, so don't bother // with a non-zero-arg ctor. result = clazz.newInstance(); } catch (Exception e) { throw new FacesException(implName, e); } } return result; }
/** * This method will store the argument <code>factoryName/implName</code> mapping in such a way * that {@link #getFactory} will find this mapping when searching for a match. * * <p> * * <p>This method has no effect if <code>getFactory()</code> has already been called looking for a * factory for this <code>factoryName</code>. * * <p> * * <p>This method can be used by implementations to store a factory mapping while parsing the * Faces configuration file * * @throws IllegalArgumentException if <code>factoryName</code> does not identify a standard * JavaServer Faces factory name * @throws NullPointerException if <code>factoryname</code> is null */ public static void setFactory(String factoryName, String implName) { validateFactoryName(factoryName); // Identify the web application class loader ClassLoader classLoader = getClassLoader(); FactoryManager manager = FACTORIES_CACHE.getApplicationFactoryManager(classLoader); manager.addFactory(factoryName, implName); }
/** * <span class="changed_modified_2_0">Create</span> (if necessary) and return a * per-web-application instance of the appropriate implementation class for the specified * JavaServer Faces factory class, based on the discovery algorithm described in the class * description. * * <p class="changed_added_2_0">The standard factories and wrappers in JSF all implement the * interface {@link FacesWrapper}. If the returned <code>Object</code> is an implementation of one * of the standard factories, it must be legal to cast it to an instance of <code>FacesWrapper * </code> and call {@link FacesWrapper#getWrapped} on the instance. * * @param factoryName Fully qualified name of the JavaServer Faces factory for which an * implementation instance is requested * @throws FacesException if the web application class loader cannot be identified * @throws FacesException if an instance of the configured factory implementation class cannot be * loaded * @throws FacesException if an instance of the configured factory implementation class cannot be * instantiated * @throws IllegalArgumentException if <code>factoryName</code> does not identify a standard * JavaServer Faces factory name * @throws IllegalStateException if there is no configured factory implementation class for the * specified factory name * @throws NullPointerException if <code>factoryname</code> is null */ public static Object getFactory(String factoryName) throws FacesException { validateFactoryName(factoryName); // Identify the web application class loader ClassLoader classLoader = getClassLoader(); FactoryManager manager = FACTORIES_CACHE.getApplicationFactoryManager(classLoader); return manager.getFactory(classLoader, factoryName); }
FactoryManagerGUI(FactoryManager parent, int pWidth, int pHeight) { this.parent = parent; this.PAGE_WIDTH = pWidth; this.PAGE_HEIGHT = pHeight; // initialize class variables activeKitsContainer = new JPanel(); activeKitsPanel = new JPanel(); kitDataPanel = new JPanel(); kits = new TreeMap<Integer, Kits>(); buildInfo = new ArrayList<Kits>(); images = parent.getImageArray(); greyLine = BorderFactory.createLineBorder(Color.DARK_GRAY); // build Active Kits Container activeKitsContainer.setLayout(new BoxLayout(activeKitsContainer, BoxLayout.X_AXIS)); setComponentSize(activeKitsContainer, PAGE_WIDTH, PAGE_HEIGHT); setComponentSize(kitDataPanel, 450, PAGE_HEIGHT); buildActiveKits(activeKitsPanel); activeKitsContainer.add(activeKitsPanel); activeKitsContainer.add(kitDataPanel); // add master containers to frame this.add(activeKitsContainer); }
public void removeApplicationFactoryManager(ClassLoader cl) { FactoryManager fm = this.getApplicationFactoryManager(cl, false); if (null != fm) { fm.clearInjectionProvider(); } FacesContext facesContext = FacesContext.getCurrentInstance(); boolean isSpecialInitializationCase = detectSpecialInitializationCase(facesContext); FactoryManagerCacheKey key = new FactoryManagerCacheKey(facesContext, cl, applicationMap); applicationMap.remove(key); if (isSpecialInitializationCase) { logNullFacesContext.set(false); logNonNullFacesContext.set(false); } }
/** * <span class="changed_modified_2_0">Release</span> any references to factory instances * associated with the class loader for the calling web application. <span * class="changed_modified_2_0">This method must be called during of web application * shutdown.</span> * * @throws FacesException if the web application class loader cannot be identified */ public static void releaseFactories() throws FacesException { // Identify the web application class loader ClassLoader cl = getClassLoader(); if (!FACTORIES_CACHE.applicationMap.isEmpty()) { FactoryManager fm = FACTORIES_CACHE.getApplicationFactoryManager(cl); InjectionProvider provider = fm.getInjectionProvider(); if (null != provider) { Collection factories = null; for (Map.Entry<FactoryManagerCacheKey, FactoryManager> entry : FACTORIES_CACHE.applicationMap.entrySet()) { factories = entry.getValue().getFactories(); for (Object curFactory : factories) { try { provider.invokePreDestroy(curFactory); } catch (Exception ex) { if (LOGGER.isLoggable(Level.SEVERE)) { String message = MessageFormat.format( "Unable to invoke @PreDestroy annotated methods on {0}.", curFactory); LOGGER.log(Level.SEVERE, message, ex); } } } } } else { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log( Level.SEVERE, "Unable to call @PreDestroy annotated methods because no InjectionProvider can be found. Does this container implement the Mojarra Injection SPI?"); } } } FACTORIES_CACHE.removeApplicationFactoryManager(cl); }
public void actionPerformed(ActionEvent ae) { try { String sbuildQuantity = buildQuantity.getText(); System.out.println(sbuildQuantity); int buildNumber = Integer.parseInt(sbuildQuantity); if (buildNumber <= 0) { System.out.println("Invalid kit build amount"); } else { Kits selectedKit = (Kits) kitList.getSelectedValue(); selectedKit.setBuildNumber(buildNumber); buildInfo.add(selectedKit); parent.syncBuildInfo(buildInfo); } } catch (Exception e) { System.out.println("Invalid kit build amount"); } }
public static void loadPagesAndDrawers( Workspace workspace, Element root, FactoryManager manager) { List<Page> pageList = new ArrayList<Page>(); // pagesToAdd is needed so that we can add pages all at once // to the page bar once all the the pages been loaded // Before adding all the pages, this method makes a check // if there is only one page with an empty name - if so, it will just // add the page to the workspace/block canvas but not add it to this // LinkedHashMap<Page, PageBlockDrawer> pagesToAdd = new LinkedHashMap<Page, PageBlockDrawer>(); LinkedHashMap<String, ArrayList<RenderableBlock>> blocksForDrawers = new LinkedHashMap<String, ArrayList<RenderableBlock>>(); LinkedHashMap<Page, ArrayList<RenderableBlock>> blocksForPages = new LinkedHashMap<Page, ArrayList<RenderableBlock>>(); NodeList pagesRoot = root.getElementsByTagName("Pages"); if (pagesRoot != null) { // isBlankPage denotes if the page being loaded is a default blank page // in other words, the project did not specify any pages for their environment. // EvoBeaker does this boolean isBlankPage = false; Node pagesNode = pagesRoot.item(0); if (pagesNode == null) { return; // short-circuit exit if there's nothing to load } Node opt_item = pagesNode.getAttributes().getNamedItem("drawer-with-page"); if (opt_item != null) { Matcher nameMatcher = attrExtractor.matcher(opt_item.toString()); if (nameMatcher.find()) // will be true { Workspace.everyPageHasDrawer = nameMatcher.group(1).equals("yes") ? true : false; } } opt_item = pagesNode.getAttributes().getNamedItem("is-blank-page"); if (opt_item != null) { Matcher nameMatcher = attrExtractor.matcher(opt_item.toString()); if (nameMatcher.find()) // will be true { isBlankPage = nameMatcher.group(1).equals("yes") ? true : false; } } // whether pages should show a control to collapse them or not boolean collapsiblePages = getBooleanValue(pagesNode, "collapsible-pages"); Page page; NodeList pages = pagesNode.getChildNodes(); Node pageNode; String pageName = ""; String pageDrawer = null; Color pageColor = null; boolean pageInFullView = true; int pageWidth = -1; String pageId = null; for (int i = 0; i < pages.getLength(); i++) { // find them pageNode = pages.item(i); if (pageNode.getNodeName().equals("Page")) { // a page entry pageName = getNodeValue(pageNode, "page-name"); pageColor = getColorValue(pageNode, "page-color"); pageWidth = getIntValue(pageNode, "page-width"); pageDrawer = getNodeValue(pageNode, "page-drawer"); pageInFullView = getBooleanValue(pageNode, "page-infullview"); pageId = getNodeValue(pageNode, "page-id"); page = new Page( workspace, pageName, pageWidth, 0, pageDrawer, pageInFullView, pageColor, collapsiblePages); page.setPageId(pageId); NodeList pageNodes = pageNode.getChildNodes(); String drawer = null; if (Workspace.everyPageHasDrawer) { // create drawer instance manager.addDynamicDrawer(page.getPageDrawer()); ArrayList<RenderableBlock> drawerBlocks = new ArrayList<RenderableBlock>(); for (int k = 0; k < pageNodes.getLength(); k++) { Node drawerNode = pageNodes.item(k); if (drawerNode.getNodeName().equals("PageDrawer")) { NodeList genusMembers = drawerNode.getChildNodes(); String genusName; for (int j = 0; j < genusMembers.getLength(); j++) { Node genusMember = genusMembers.item(j); if (genusMember.getNodeName().equals("BlockGenusMember")) { genusName = genusMember.getTextContent(); assert BlockGenus.getGenusWithName(genusName) != null : "Unknown BlockGenus: " + genusName; Block block = new Block(workspace, genusName); drawerBlocks.add( new FactoryRenderableBlock(workspace, manager, block.getBlockID())); } } blocksForDrawers.put(drawer, drawerBlocks); break; // there can only be one drawer for this page } } } if (isBlankPage) { // place a blank page as the first page workspace.putPage(page, 0); // if the system uses blank pages, then we expect only one page break; // we anticipate only one page } else { // we add to the end of the set of pages int position = pageList.size(); // add to workspace if (position == 0) { // replace the blank default page workspace.putPage(page, 0); } else { workspace.addPage(page, position); } pageList.add(position, page); } blocksForPages.put(page, page.loadPageFrom(pageNode, false)); } } // add blocks in drawers for (String d : blocksForDrawers.keySet()) { manager.addDynamicBlocks(blocksForDrawers.get(d), d); } // blocks in pages for (Page p : blocksForPages.keySet()) { p.addLoadedBlocks(blocksForPages.get(p), false); } } }
public static void loadBlockDrawerSets( Workspace workspace, Element root, FactoryManager manager) { Pattern attrExtractor = Pattern.compile("\"(.*)\""); Matcher nameMatcher; NodeList drawerSetNodes = root.getElementsByTagName("BlockDrawerSet"); Node drawerSetNode; for (int i = 0; i < drawerSetNodes.getLength(); i++) { drawerSetNode = drawerSetNodes.item(i); if (drawerSetNode.getNodeName().equals("BlockDrawerSet")) { NodeList drawerNodes = drawerSetNode.getChildNodes(); Node drawerNode; // retreive drawer information of this bar for (int j = 0; j < drawerNodes.getLength(); j++) { drawerNode = drawerNodes.item(j); if (drawerNode.getNodeName().equals("BlockDrawer")) { String drawerName = null; Color buttonColor = Color.blue; StringTokenizer col; nameMatcher = attrExtractor.matcher(drawerNode.getAttributes().getNamedItem("name").toString()); if (nameMatcher.find()) { // will be true drawerName = nameMatcher.group(1); } // get drawer's color: Node colorNode = drawerNode.getAttributes().getNamedItem("button-color"); // if(colorNode == null){ // buttonColor = Color.blue; // System.out.println("Loading a drawer without defined color: "); // for(int ai=0; ai<drawerNode.getAttributes().getLength(); ai++){ // // System.out.println("\t"+drawerNode.getAttributes().item(ai).getNodeName()+ // ", "+drawerNode.getAttributes().item(ai).getNodeValue()); // } // }else{ if (colorNode != null) { nameMatcher = attrExtractor.matcher(colorNode.toString()); if (nameMatcher.find()) { // will be true col = new StringTokenizer(nameMatcher.group(1)); if (col.countTokens() == 3) { buttonColor = new Color( Integer.parseInt(col.nextToken()), Integer.parseInt(col.nextToken()), Integer.parseInt(col.nextToken())); } else { buttonColor = Color.BLACK; } } } manager.addStaticDrawer(drawerName, buttonColor); // get block genuses in drawer and create blocks NodeList drawerBlocks = drawerNode.getChildNodes(); Node blockNode; ArrayList<RenderableBlock> drawerRBs = new ArrayList<RenderableBlock>(); for (int k = 0; k < drawerBlocks.getLength(); k++) { blockNode = drawerBlocks.item(k); if (blockNode.getNodeName().equals("BlockGenusMember")) { String genusName = blockNode.getTextContent(); assert BlockGenus.getGenusWithName(genusName) != null : "Unknown BlockGenus: " + genusName; Block newBlock; // don't link factory blocks to their stubs because they will // forever remain inside the drawer and never be active newBlock = new Block(workspace, genusName, false); drawerRBs.add( new FactoryRenderableBlock(workspace, manager, newBlock.getBlockID())); } } manager.addStaticBlocks(drawerRBs, drawerName); } } } } }