alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

What this is

This file is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Other links

The source code

/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.core.windows.persistence.convert;

import org.netbeans.core.projects.SessionManager;
import org.netbeans.core.windows.Debug;
import org.netbeans.core.windows.persistence.InternalConfig;
import org.netbeans.core.windows.persistence.PersistenceManager;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.modules.SpecificationVersion;
import org.openide.util.NbBundle;
import org.openide.xml.XMLUtil;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;


/**
 * Handle loading of WindowManager configuration data.
 *
 * @author Marek Slama
 */

class WindowManagerParserOld {
    
    private static final String INSTANCE_DTD_ID_1_0
        = "-//NetBeans//DTD Window Manager Properties 1.0//EN"; // NOI18N
    private static final String INSTANCE_DTD_ID_1_1
        = "-//NetBeans//DTD Window Manager Properties 1.1//EN"; // NOI18N
    private static final String INSTANCE_DTD_ID_2_0
        = "-//NetBeans//DTD Window Manager Properties 2.0//EN"; // NOI18N
    
    /** Unique wm name */
    private String wmName;
    
    private ImportManager importManager;
    
    private PropertyHandler propertyHandler;
    
    private InternalConfig internalConfig;
    
    private Map workspaceParserMap = new HashMap(19);
    
    //Set of 
    //Used to collect names of all localy stored wstcref files.
    //private Set tcRefNameLocalSet = new HashSet(101);
    
    private static Object SAVING_LOCK = new Object();
    
    public WindowManagerParserOld (ImportManager importManager, String wmName) {
        this.importManager = importManager;
        this.wmName = wmName;
    }
    
    /** Load window manager configuration including all modes and tcrefs. */
    WindowManagerConfigOld load() throws IOException {
        synchronized (SAVING_LOCK) {
            WindowManagerConfigOld wmc = new WindowManagerConfigOld();
            readProperties(wmc);
            readWorkspaces(wmc);
            return wmc;
        }
    }
    
    /** Called from ModuleChangeHandlerOld when folder Windows or Windows/WindowManager 
     * is deleted from module folder.
     * Removes all instances of WorkspaceParserOld, ModeParserOld, TCRefParserOld. 
     */
    void removeAllWorkspaces () {
        synchronized (SAVING_LOCK) {
            log("removeAllWorkspaces");
            for (Iterator it = workspaceParserMap.keySet().iterator(); it.hasNext(); ) {
                WorkspaceParserOld workspaceParser = (WorkspaceParserOld) workspaceParserMap.get(it.next());
                workspaceParser.removeAllModes();
            }
            workspaceParserMap.clear();
        }
    }
    
    /** Called from ModuleChangeHandlerOld when folder Windows or Windows/WindowManager
     * is deleted from module folder.
     * Removes given instance of WorkspaceParserOld and all its instances of
     * ModeParserOld, TCRefParserOld.
     */
    void removeWorkspace (String workspaceName) {
        synchronized (SAVING_LOCK) {
            log("removeWorkspace ws:" + workspaceName);
            WorkspaceParserOld workspaceParser =
                (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser != null) {
                workspaceParser.removeAllModes();
                workspaceParserMap.remove(workspaceName);
            }
        }
    }
    
    /** Called from ModuleChangeHandlerOld when folder Windows or Windows/WindowManager
     * is deleted from module folder.
     * Removes given instance of WorkspaceParserOld and all its instances of
     * ModeParserOld, TCRefParserOld.
     */
    void removeMode (String workspaceName, String modeName) {
        synchronized (SAVING_LOCK) {
            log("removeMode ws:" + workspaceName + " mo:" + modeName);
            WorkspaceParserOld workspaceParser =
                (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser != null) {
                workspaceParser.removeMode(modeName);
            }
        }
    }
    
    /** Called from ModuleChangeHandler when wstcref file is deleted from module folder.
     * Removes TCRefParser from ModeParser and cleans wstcref file from local folder
     * @param tcRefName unique name of tcRef
     */
    void removeTCRef (String workspaceName, String modeName, String tcRefName) {
        synchronized (SAVING_LOCK) {
            log("removeTCRef" + " ws:" + workspaceName
            + " mo:" + modeName + " tcRef:" + tcRefName);
            WorkspaceParserOld workspaceParser =
                (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser != null) {
                workspaceParser.removeTCRef(modeName,tcRefName);
            }
        }
    }
    
    /** Called from ImportManager when workspace is added to module folder.
     * Adds WorkspaceParserOld.
     * @param workspaceName unique name of workspace
     */
    WorkspaceConfigOld addWorkspace (String workspaceName) {
        synchronized (SAVING_LOCK) {
            log("addWorkspace ENTER" + " ws:" + workspaceName);
            WorkspaceParserOld workspaceParser =
                (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser != null) {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WindowManagerParserOld.addWorkspace]" // NOI18N
                + " Warning: WorkspaceParserOld " + workspaceName // NOI18N
                + " exists but it should not."); // NOI18N
                workspaceParserMap.remove(workspaceName);
            }
            workspaceParser = new WorkspaceParserOld(workspaceName);
            FileObject workspacesModuleFolder = importManager.getWindowManagerFolder();
            workspaceParser.setModuleParentFolder(workspacesModuleFolder);
            workspaceParserMap.put(workspaceName, workspaceParser);
            WorkspaceConfigOld workspaceConfig = null;
            try {
                workspaceConfig = workspaceParser.load();
            } catch (IOException exc) {
                ErrorManager em = ErrorManager.getDefault();
                em.log(ErrorManager.WARNING,
                "[WinSys.WindowManagerParserOld.addWorkspace]" // NOI18N
                + " Warning: Cannot load workspace " + workspaceName); // NOI18N
                em.notify(ErrorManager.INFORMATIONAL, exc);
            }
            return workspaceConfig;
        }
    }
        
    /** Called from ImportManager when wsmode file is added to module folder.
     * Adds ModeParserOld.
     * @param workspaceName unique name of workspace
     * @param modeName unique name of mode
     */
    ModeConfigOld addMode (String workspaceName, String modeName) {
        synchronized (SAVING_LOCK) {
            log("addMode ENTER" + " ws:" + workspaceName + " mo:" + modeName);
            WorkspaceParserOld workspaceParser = (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser == null) {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WindowManagerParserOld.addMode]" // NOI18N
                + " Warning: WorkspaceParserOld " + workspaceName // NOI18N
                + " does not exist."); // NOI18N
                return null;
            }
            ModeConfigOld modeConfig = workspaceParser.addMode(modeName);
            return modeConfig;
        }
    }
    
    /** Called from ImportManager when wstcref file is added to module folder.
     * Adds TCRefParserOld.
     * @param workspaceName unique name of workspace
     * @param modeName unique name of mode
     * @param tcRefName unique name of tcRef
     */
    TCRefConfigOld addTCRef (String workspaceName, String modeName, String tcRefName) {
        synchronized (SAVING_LOCK) {
            log("addTCRef ENTER" + " ws:" + workspaceName + " mo:" + modeName
            + " tcRef:" + tcRefName);
            WorkspaceParserOld workspaceParser = (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
            if (workspaceParser == null) {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WindowManagerParserOld.addTCRef]" // NOI18N
                + " Warning: WorkspaceParserOld " + workspaceName // NOI18N
                + " does not exist."); // NOI18N
                return null;
            }
            TCRefConfigOld tcRefConfig = workspaceParser.addTCRef(modeName,tcRefName);
            return tcRefConfig;
        }
    }
    
    private void readProperties (WindowManagerConfigOld wmc) throws IOException {
        log("readProperties ENTER");
        if (propertyHandler == null) {
            propertyHandler = new PropertyHandler();
        }
        internalConfig = new InternalConfig();
        propertyHandler.readData(wmc, internalConfig);
        log("readProperties LEAVE");
    }
    
    private void readWorkspaces (WindowManagerConfigOld wmc) throws IOException {
        log("readWorkspaces ENTER");
        
        FileObject workspacesModuleFolder = importManager.getWindowManagerFolder();
        log("workspacesModuleFolder: " + workspacesModuleFolder
        + " [" + Integer.toHexString(System.identityHashCode(workspacesModuleFolder)) + "]");
        if (workspacesModuleFolder != null) {
            FileObject [] files = workspacesModuleFolder.getChildren();
            for (int i = 0; i < files.length; i++) {
                log("fo[" + i + "]: " + files[i]);
                if ((!files[i].isFolder() && ImportManager.WORKSPACE_EXT.equals(files[i].getExt())) ||
                    files[i].isFolder()) {
                    //Workspace configuration 'wswksp' file or workspace folder
                    WorkspaceParserOld workspaceParser;
                    if (workspaceParserMap.containsKey(files[i].getName())) {
                        workspaceParser = (WorkspaceParserOld) workspaceParserMap.get(files[i].getName());
                    } else {
                        workspaceParser = new WorkspaceParserOld(files[i].getName());
                        workspaceParserMap.put(files[i].getName(), workspaceParser);
                    }
                    workspaceParser.setModuleParentFolder(workspacesModuleFolder);
                }
            }
        }
        
        List workspaceCfgList = new ArrayList(workspaceParserMap.size());
        for (Iterator it = workspaceParserMap.keySet().iterator(); it.hasNext(); ) {
            WorkspaceParserOld workspaceParser = (WorkspaceParserOld) workspaceParserMap.get(it.next());
            WorkspaceConfigOld workspaceCfg;
            try {
                workspaceCfg = workspaceParser.load();
            } catch (IOException exc) {
                //If reading of one Workspace fails we want to log message
                //and continue.
                ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, exc);
                continue;
            }
            workspaceCfgList.add(workspaceCfg);
        }
        
        wmc.workspaces = 
            (WorkspaceConfigOld []) workspaceCfgList.toArray(new WorkspaceConfigOld[workspaceCfgList.size()]);
        
        log("readWorkspaces LEAVE");
    }
    
    String getName () {
        return wmName;
    }
    
    /** Returns instance of TCRefParserOld.
     */
    TCRefParserOld findTCRefParser (String workspaceName, String modeName, String tcRefName) {
        WorkspaceParserOld workspaceParser =
            (WorkspaceParserOld) workspaceParserMap.get(workspaceName);
        if (workspaceParser != null) {
            return workspaceParser.findTCRefParser(modeName,tcRefName);
        } else {
            return null;
        }
    }
    
    void log (String s) {
        Debug.log(WindowManagerParserOld.class, s);
    }
    
    private final class PropertyHandler extends DefaultHandler {
        
        /** WindowManager configuration data */
        private WindowManagerConfigOld winMgrConfig = null;
        
        /** Internal configuration data */
        private InternalConfig internalConfig = null;
        
        /** xml parser */
        private XMLReader parser;
        
        /** Lock to prevent mixing readData and writeData */
        private final Object RW_LOCK = new Object();
        
        public PropertyHandler () {
        }
        
        private FileObject getConfigFOInput () {
            FileObject rootFolder = importManager.getRootFolder();
            
            log("getConfigFOInput" + " rootFolder:" + rootFolder);
            
            FileObject fo = rootFolder.getFileObject
            (WindowManagerParserOld.this.getName(), PersistenceManager.WINDOWMANAGER_EXT);
            
            log("getConfigFOInput" + " fo:" + fo);
            
            FileObject wmConfigFO = null;
            if (fo != null) {
                //Look for file at install layer
                SessionManager sm = SessionManager.getDefault();
                FileSystem installLayer = sm.getLayer(SessionManager.LAYER_INSTALL);
                wmConfigFO = installLayer.findResource(fo.getPath());
            }
            
            log("getConfigFOInput" + " wmConfigFO:" + wmConfigFO);
            
            return wmConfigFO;
        }
        
        /**
         Reads window manager configuration data from XML file. 
         Data are returned in output params.
         */
        void readData (WindowManagerConfigOld winMgrCfg, InternalConfig internalCfg)
        throws IOException {
            winMgrConfig = winMgrCfg;
            internalConfig = internalCfg;
            
            FileObject cfgFOInput = getConfigFOInput();
            if (cfgFOInput == null) {
                //No configuration data
                return;
            }
            try {
                synchronized (RW_LOCK) {
                    //DUMP BEGIN
                    /*InputStream is = cfgFOInput.getInputStream();
                    byte [] arr = new byte [is.available()];
                    is.read(arr);
                    log("DUMP WindowManagerOld:");
                    String s = new String(arr);
                    log(s);*/
                    //DUMP END
                    
                    getXMLParser().parse(new InputSource(cfgFOInput.getInputStream()));
                }
            } catch (SAXException exc) {
                //Turn into annotated IOException
                String msg = NbBundle.getMessage(WindowManagerParserOld.class,
                        "EXC_WindowManagerParse", cfgFOInput);
                IOException ioe = new IOException(msg);
                ErrorManager.getDefault().annotate(ioe, exc);
                throw ioe;
            }
            
            winMgrConfig.initialized = true;
            
            winMgrCfg = winMgrConfig;
            internalCfg = internalConfig;
            
            winMgrConfig = null;
            internalConfig = null;
        }
        
        public void startElement (String nameSpace, String name, String qname, Attributes attrs) throws SAXException {
            if ("windowmanager".equals(qname)) { // NOI18N
                handleWindowManager(attrs);
            } else if (internalConfig.specVersion.compareTo(new SpecificationVersion("2.0")) == 0) {
                //Parse version 2.0
            } else {
                //Parse version < 2.0
                log("startElement PARSING OLD qname:" + qname);
            }
        }

        public void error(SAXParseException ex) throws SAXException  {
            throw ex;
        }

        public void fatalError(SAXParseException ex) throws SAXException {
            throw ex;
        }

        public void warning(SAXParseException ex) throws SAXException {
            // ignore
        }
        
        /** Reads element "windowmanager" */
        private void handleWindowManager (Attributes attrs) {
            String version = attrs.getValue("version"); // NOI18N
            if (version != null) {
                internalConfig.specVersion = new SpecificationVersion(version);
            } else {
                ErrorManager.getDefault().log(ErrorManager.WARNING,
                "[WinSys.WindowManagerParserOld.handleWindowManager]" // NOI18N
                + " Missing attribute \"version\" of element \"windowmanager\"."); // NOI18N
                internalConfig.specVersion = new SpecificationVersion("1.1"); // NOI18N
            }
        }
        
        public void endDocument() throws SAXException {
        }
        
        public void ignorableWhitespace(char[] values, int param, int param2)
        throws SAXException {
        }
        
        public void endElement(String str, String str1, String str2)
        throws SAXException {
        }
        
        public void skippedEntity(String str) throws SAXException {
        }
        
        public void processingInstruction(String str, String str1)
        throws SAXException {
        }
                
        public void endPrefixMapping(String str) throws SAXException {
        }
        
        public void startPrefixMapping(String str, String str1)
        throws SAXException {
        }
        
        public void characters(char[] values, int param, int param2)
        throws SAXException {
        }
        
        public void setDocumentLocator(org.xml.sax.Locator locator) {
        }
        
        public void startDocument() throws SAXException {
        }
        
        /** @return Newly created parser with set content handler, errror handler
         * and entity resolver
         */
        private XMLReader getXMLParser () throws SAXException {
            if (parser == null) {
                // get non validating, not namespace aware parser
                parser = XMLUtil.createXMLReader();
                parser.setContentHandler(this);
                parser.setErrorHandler(this);
                parser.setEntityResolver(this);
            }
            return parser;
        }

        /** Implementation of entity resolver. Points to the local DTD
         * for our public ID */
        public InputSource resolveEntity (String publicId, String systemId)
        throws SAXException {
            if (INSTANCE_DTD_ID_1_0.equals(publicId)
             || INSTANCE_DTD_ID_1_1.equals(publicId)
             || INSTANCE_DTD_ID_2_0.equals(publicId)) {
                InputStream is = new ByteArrayInputStream(new byte[0]);
                //getClass().getResourceAsStream(INSTANCE_DTD_LOCAL);
//                if (is == null) {
//                    throw new IllegalStateException ("Entity cannot be resolved."); // NOI18N
//                }
                return new InputSource(is);
            }
            return null; // i.e. follow advice of systemID
        }
        
        void log (String s) {
            Debug.log(PropertyHandler.class, s);
        }
    }
    
}
... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.