701

Additions:
-All new structure that allows a (sub)tree to be managed on a subsystem basis, like OTDB, ParmDB, etc.
-Generic Tree Manager that allows for Tree Model events to be passed on to anyone interested to alter the contents of the tree they want.
-ITreeManager that specifies the methods needed by every node in a tree to determine their children, name, etc

SAS/OTB/OTB/src/nl/astron/lofar/sas/otb/util/treemanagers/GenericTreeManager.java

+/*
+ * GenericTreeManager.java
+ *
+ * Created on January 26, 2006, 2:56 PM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package nl.astron.lofar.sas.otb.util.treemanagers;
+
+import java.rmi.RemoteException;
+import java.util.Enumeration;
+import java.util.Vector;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import nl.astron.lofar.sas.otb.SharedVars;
+import nl.astron.lofar.sas.otb.jotdb2.jOTDBnode;
+import nl.astron.lofar.sas.otb.util.UserAccount;
+import nl.astron.lofar.sas.otb.util.jParmDBnode;
+import nl.astron.lofar.sas.otb.util.treenodes.TreeNode;
+import org.apache.log4j.Logger;
+
+/**
+ * Base GenericTreeManager Class
+ *
+ * @author pompert
+ * @version $Id$
+ */
+public abstract class GenericTreeManager{
+    
+    protected static UserAccount anAccount;
+    private javax.swing.event.EventListenerList listenerList =  null;
+    
+    /**
+     * default constructor, protected by a singleton pattern
+     */
+    public GenericTreeManager(UserAccount anAccount) {
+        this.anAccount = anAccount;
+    }
+    /**
+     * Registers ActionListener to receive events.
+     * @param listener The listener to register.
+     */
+    public synchronized void addTreeModelListener(TreeModelListener listener) {
+        if (listenerList == null ) {
+            listenerList = new javax.swing.event.EventListenerList();
+        }
+        listenerList.add(TreeModelListener.class, listener);
+    }
+    
+    /**
+     * Removes ActionListener from the list of listeners.
+     * @param listener The listener to remove.
+     */
+    public synchronized void removeTreeModelListener(TreeModelListener listener) {
+        listenerList.remove(TreeModelListener.class, listener);
+    }
+    
+    /**
+     * Notifies all registered listeners about the event.
+     *
+     * @param event The event to be fired
+     */
+    protected void fireTreeInsertionPerformed(TreeModelEvent event) {
+        if (listenerList == null) return;
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i]==TreeModelListener.class) {
+                ((TreeModelListener)listeners[i+1]).treeNodesInserted(event);
+            }
+        }
+    }
+    /**
+     * Notifies all registered listeners about the event.
+     *
+     * @param event The event to be fired
+     */
+    protected void fireTreeRemovalPerformed(TreeModelEvent event) {
+        if (listenerList == null) return;
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i]==TreeModelListener.class) {
+                ((TreeModelListener)listeners[i+1]).treeNodesRemoved(event);
+            }
+        }
+    }
+    /**
+     * Notifies all registered listeners about the event.
+     *
+     * @param event The event to be fired
+     */
+    protected void fireTreeChangePerformed(TreeModelEvent event) {
+        if (listenerList == null) return;
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i]==TreeModelListener.class) {
+                ((TreeModelListener)listeners[i+1]).treeNodesChanged(event);
+            }
+        }
+    }
+    /**
+     * Notifies all registered listeners about the event.
+     *
+     * @param event The event to be fired
+     */
+    protected void fireTreeStructureChanged(TreeModelEvent event) {
+        if (listenerList == null) return;
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i]==TreeModelListener.class) {
+                ((TreeModelListener)listeners[i+1]).treeStructureChanged(event);
+            }
+        }
+    }
+    
+}

SAS/OTB/OTB/src/nl/astron/lofar/sas/otb/util/treemanagers/ITreeManager.java

+/*
+ * ITreeManager.java
+ *
+ * Created on January 26, 2006, 2:56 PM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package nl.astron.lofar.sas.otb.util.treemanagers;
+
+import nl.astron.lofar.sas.otb.util.treenodes.TreeNode;
+
+/**
+ * Base TreeManager Interface
+ *
+ * @author pompert
+ * @version $Id$
+ */
+public interface ITreeManager {
+    
+    public String getNameForNode(TreeNode aNode);
+    
+    public boolean isNodeLeaf(TreeNode aNode);
+    
+    public void defineChildsForNode(TreeNode aNode);
+    
+    public TreeNode getRootNode(String[] arguments);
+}

SAS/OTB/OTB/src/nl/astron/lofar/sas/otb/util/treemanagers/OTDBNodeTreeManager.java

+/*
+ * OTDBNodeTreeManager.java
+ *
+ * Created on January 26, 2006, 2:56 PM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package nl.astron.lofar.sas.otb.util.treemanagers;
+
+import java.rmi.RemoteException;
+import java.util.Enumeration;
+import java.util.Vector;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import nl.astron.lofar.sas.otb.SharedVars;
+import nl.astron.lofar.sas.otb.jotdb2.jOTDBnode;
+import nl.astron.lofar.sas.otb.util.UserAccount;
+import nl.astron.lofar.sas.otb.util.jParmDBnode;
+import nl.astron.lofar.sas.otb.util.treenodes.TreeNode;
+import org.apache.log4j.Logger;
+
+/**
+ * Base OTDBNodeTreeManager Class
+ *
+ * @author pompert
+ * @version $Id$
+ */
+public class OTDBNodeTreeManager extends GenericTreeManager implements ITreeManager{
+    
+    // Create a Log4J logger instance
+    private static Logger logger = Logger.getLogger(OTDBNodeTreeManager.class);
+    private static OTDBNodeTreeManager instance;
+    
+    /**
+     * default constructor, protected by a singleton pattern
+     */
+    private OTDBNodeTreeManager(UserAccount anAccount) {
+        super(anAccount);
+    }
+    
+    public static OTDBNodeTreeManager getInstance(UserAccount anAccount){
+        if(instance==null){
+            instance = new OTDBNodeTreeManager(anAccount);
+        }
+        return instance;
+    }
+    
+    public String getNameForNode(TreeNode aNode){
+        String name = "";
+        if(aNode.getUserObject()!= null && aNode.getUserObject() instanceof jOTDBnode){
+            
+            String splitName[]=((jOTDBnode)aNode.getUserObject()).name.split("[.]");
+            if (splitName.length >=2) {
+                name=splitName[splitName.length-1];
+            } else {
+                name=((jOTDBnode)aNode.getUserObject()).name;
+            }
+            if (((jOTDBnode)aNode.getUserObject()).index > 0 && !((jOTDBnode)aNode.getUserObject()).leaf) {
+                name +="["+String.valueOf(((jOTDBnode)aNode.getUserObject()).index)+"]";
+            }
+        }else if(aNode.getUserObject()!= null && aNode.getUserObject() instanceof jParmDBnode){
+            name=((jParmDBnode)aNode.getUserObject()).name;
+        }
+        return name;
+    }
+    
+    public boolean isNodeLeaf(TreeNode aNode){
+        boolean leaf = false;
+        if (aNode.getUserObject() != null) {
+            if(aNode.getUserObject() instanceof jOTDBnode){
+                leaf = ((jOTDBnode)aNode.getUserObject()).leaf;
+            }
+        }
+        return leaf;
+    }
+    
+    public void defineChildsForNode(TreeNode aNode) {
+        logger.trace("Entry - TreeManager defineChildNodes("+toString()+")");
+        
+        if (aNode.getUserObject() == null) {
+            return;
+        }
+        
+        // You must set the flag before defining children if you
+        // use "add" for the new children. Otherwise you get an infinite
+        // recursive loop, since add results in a call to getChildCount.
+        // However, you could use "insert" in such a case.
+        aNode.areChildrenDefined = true;
+        
+        try {
+            Vector childs =
+                    SharedVars.getOTDBrmi().getRemoteMaintenance().getItemList(((jOTDBnode)aNode.getUserObject()).treeID(), ((jOTDBnode)aNode.getUserObject()).nodeID(), 1);
+            
+            Enumeration e = childs.elements();
+            while( e.hasMoreElements()  ) {
+                jOTDBnode item = (jOTDBnode)e.nextElement();
+                logger.trace("Node name selected :"+item.name);
+                TreeNode newNode = new TreeNode(this.instance,item,item.name);
+                aNode.add(newNode);
+                TreeModelEvent evt = new TreeModelEvent(newNode,newNode.getPath());
+                
+                fireTreeInsertionPerformed(evt);
+            }
+        } catch(Exception e) {
+            logger.fatal("Exception during TreeManager OTDB-defineChildNodes",e);
+        }
+    }
+    public TreeNode getRootNode(String[] arguments){
+        jOTDBnode otdbNode=null;
+        int itsTreeID = 0;
+        try {
+            itsTreeID = Integer.parseInt(arguments[0]);
+        } catch (NumberFormatException ex) {
+            logger.error("The OTDBNodeTreeManager received an incorrect TreeID! ",ex);
+        }
+        
+        if (itsTreeID == 0 ) {
+            // create a sample root node.
+            otdbNode = new jOTDBnode(0,0,0,0);
+            otdbNode.name = "No TreeSelection";
+        } else {
+            try {
+                otdbNode = SharedVars.getOTDBrmi().getRemoteMaintenance().getTopNode(itsTreeID);
+            } catch (RemoteException ex) {
+                logger.fatal("The OTDBNodeTreeManager could not build a root node! ",ex);
+            }
+        }
+        TreeNode newNode = new TreeNode(this.instance,otdbNode,otdbNode.name);
+        
+        return newNode;
+    }
+}
\ No newline at end of file

SAS/OTB/OTB/src/nl/astron/lofar/sas/otb/util/treemanagers/OTDBParamTreeManager.java

+/*
+ * OTDBParamTreeManager.java
+ *
+ * Created on January 26, 2006, 2:56 PM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package nl.astron.lofar.sas.otb.util.treemanagers;
+
+import java.rmi.RemoteException;
+import java.util.Enumeration;
+import java.util.Vector;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import nl.astron.lofar.sas.otb.SharedVars;
+import nl.astron.lofar.sas.otb.jotdb2.jOTDBparam;
+import nl.astron.lofar.sas.otb.jotdb2.jVICnodeDef;
+import nl.astron.lofar.sas.otb.util.UserAccount;
+import nl.astron.lofar.sas.otb.util.treenodes.TreeNode;
+import org.apache.log4j.Logger;
+
+/**
+ * Base OTDBParamTreeManager Class
+ *
+ * @author pompert
+ * @version $Id$
+ */
+public class OTDBParamTreeManager extends GenericTreeManager implements ITreeManager{
+    
+    // Create a Log4J logger instance
+    private static Logger logger = Logger.getLogger(OTDBParamTreeManager.class);
+    private static OTDBParamTreeManager instance;
+      
+    /**
+     * default constructor, protected by a singleton pattern
+     */
+    private OTDBParamTreeManager(UserAccount anAccount) {
+        super(anAccount);
+    }
+    
+    public static OTDBParamTreeManager getInstance(UserAccount anAccount){
+        if(instance==null){
+            instance = new OTDBParamTreeManager(anAccount);
+        }
+        return instance;
+    }
+    
+    public String getNameForNode(TreeNode aNode){
+        String name = "";
+        name = ((jOTDBparam)aNode.getUserObject()).name;
+        if (((jOTDBparam)aNode.getUserObject()).index > 0) {
+            name +="["+String.valueOf(((jOTDBparam)aNode.getUserObject()).index)+"]";
+        }
+        return name;
+    }
+    
+    public boolean isNodeLeaf(TreeNode aNode){
+        boolean leaf = false;
+        if (aNode.getUserObject() != null) {
+            leaf = true;
+            if (((jOTDBparam)aNode.getUserObject()).name.charAt(0) == '#' ) {
+                leaf = false;
+            }
+        }
+        return leaf;
+    }
+    
+    public void defineChildsForNode(TreeNode aNode) {
+        
+        logger.trace("Entry - TreeNode jOTDBparam-defineChildNodes("+toString()+")");
+        
+        if (aNode.getUserObject() == null) {
+            return;
+        }
+         // You must set the flag before defining children if you
+        // use "add" for the new children. Otherwise you get an infinite
+        // recursive loop, since add results in a call to getChildCount.
+        // However, you could use "insert" in such a case.
+        aNode.areChildrenDefined = true;
+        // Only need to be done for params who's name starts with #
+        if  (((jOTDBparam)aNode.getUserObject() ).name.charAt(0) != '#') {
+            return;
+        }
+        
+        String aNodeName= ((jOTDBparam)aNode.getUserObject() ).name.substring(1,((jOTDBparam)aNode.getUserObject()).name.length());
+        try {
+            
+            
+            Vector<jVICnodeDef> nodes = SharedVars.getOTDBrmi().getRemoteMaintenance().getComponentList(aNodeName,false);
+            
+            if (nodes.size() > 0) {
+                logger.debug("Found "+ nodes.size()+ " nr of matches for node "+aNodeName);
+            } else {
+                logger.debug("No matches for "+ aNodeName);
+                return;
+            }
+            
+            Vector<jOTDBparam> params = SharedVars.getOTDBrmi().getRemoteMaintenance().getComponentParams(((jVICnodeDef)nodes.elementAt(0)).nodeID());
+            
+            Enumeration e = params.elements();
+            while( e.hasMoreElements()  ) {
+                jOTDBparam item = (jOTDBparam)e.nextElement();
+                TreeNode newNode = new TreeNode(this.instance,item,item.name);
+                aNode.add(newNode);
+                //testcode to add parmdb
+                TreeModelEvent evt = new TreeModelEvent(newNode,newNode.getPath());
+                
+                fireTreeInsertionPerformed(evt);
+            }
+        } catch(Exception e) {
+            logger.fatal("Exception during TreeManager jOTDBparam-defineChildNodes: " + e);
+        }
+        
+        logger.trace("Exit - TreeManager defineChildNodes("+toString()+")");
+    }
+    public TreeNode getRootNode(String[] arguments){
+        jOTDBparam aParam =null;
+        jVICnodeDef aVICnodeDef=null;
+        int itsComponentID = 0;
+        try {
+            itsComponentID = Integer.parseInt(arguments[0]);
+        } catch (NumberFormatException ex) {
+            logger.error("The OTDBParamTreeManager received an incorrect itsComponentID! ",ex);
+        }
+        if (itsComponentID == 0 ) {
+            // create a sample component param
+            aParam = new jOTDBparam(0,0,0);
+            aParam.name = "No ParamSelection";
+        } else {
+            try {
+                aVICnodeDef = SharedVars.getOTDBrmi().getRemoteMaintenance().getComponentNode(itsComponentID);
+            } catch (RemoteException ex) {
+                logger.fatal("The OTDBParamTreeManager could not build a root node! ",ex);
+            }
+            if (aVICnodeDef != null) {
+                // create a fake param to pass to componentTree, to simulate a node param
+                aParam = new jOTDBparam(0,itsComponentID,0);
+                aParam.name="#"+aVICnodeDef.name;
+                aParam.index=0;
+                aParam.limits="";
+                aParam.type=-1;
+                aParam.unit=-1;
+                aParam.description="";
+            } else {
+                logger.debug("failed to get ComponentNode");
+            }
+        }
+        TreeNode newNode = new TreeNode(this.instance,aParam,aParam.name);
+        return newNode;
+    }
+}

SAS/OTB/OTB/src/nl/astron/lofar/sas/otb/util/treemanagers/ParmDBTreeManager.java

+/*
+ * ParmDBTreeManager.java
+ *
+ * Created on January 26, 2006, 2:56 PM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package nl.astron.lofar.sas.otb.util.treemanagers;
+
+import java.util.Enumeration;
+import java.util.Vector;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import nl.astron.lofar.sas.otb.SharedVars;
+import nl.astron.lofar.sas.otb.util.UserAccount;
+import nl.astron.lofar.sas.otb.util.jParmDBnode;
+import nl.astron.lofar.sas.otb.util.treenodes.TreeNode;
+import org.apache.log4j.Logger;
+
+/**
+ * Base ParmDBTreeManager Class
+ *
+ * @author pompert
+ * @version $Id$
+ */
+public class ParmDBTreeManager extends GenericTreeManager implements ITreeManager{
+    
+    // Create a Log4J logger instance
+    private static Logger logger = Logger.getLogger(OTDBParamTreeManager.class);
+    private static ParmDBTreeManager instance;
+   
+    /**
+     * default constructor, protected by a singleton pattern
+     */
+    private ParmDBTreeManager(UserAccount anAccount) {
+        super(anAccount);
+    }
+    
+    public static ParmDBTreeManager getInstance(UserAccount anAccount){
+        if(instance==null){
+            instance = new ParmDBTreeManager(anAccount);
+        }
+        return instance;
+    }
+    
+    public String getNameForNode(TreeNode aNode){
+        //logger.trace("Parm DB node : "+((jOTDBnode)aNode.getUserObject()).name);
+        String name = ((jParmDBnode)aNode.getUserObject()).name;
+        return name;
+    }
+    
+    public boolean isNodeLeaf(TreeNode aNode){
+        boolean leaf = false;
+        if (aNode.getUserObject() != null) {
+            leaf = ((jParmDBnode)aNode.getUserObject()).leaf;
+        }
+        return leaf;
+    }
+    
+    public void defineChildsForNode(TreeNode aNode) {
+        
+        logger.trace("Entry - TreeManager jParmDBnode-defineChildNodes("+toString()+")");
+        try {
+            Vector childs;
+            if(((jParmDBnode)aNode.getUserObject()).name.equalsIgnoreCase("ParmDB")){
+                logger.trace("ParmDBtreeNode calling getNames("+((jParmDBnode)aNode.getUserObject()).nodeID().substring(6)+"*)");
+                childs = SharedVars.getJParmFacade().getNames(""+((jParmDBnode)aNode.getUserObject()).nodeID().substring(6)+"*");
+                logger.trace("ParmDBtreeNode gets "+childs.size()+" names");
+            }else{
+                logger.trace("ParmDBtreeNode calling getNames(*"+((jParmDBnode)aNode.getUserObject()).nodeID().substring(7)+".*)");
+                childs = SharedVars.getJParmFacade().getNames("*"+((jParmDBnode)aNode.getUserObject()).nodeID().substring(7)+".*");
+                logger.trace("ParmDBtreeNode gets "+childs.size()+" names");
+            }
+            Vector<String> uniqueNames = new Vector<String>();
+            Enumeration e = childs.elements();
+            while( e.hasMoreElements()  ) {
+                String aValue = (String)e.nextElement();
+                String splitName[]= aValue.split("[.]");
+                String parentLevels[] = ((jParmDBnode)aNode.getUserObject()).nodeID().split("[.]");
+                
+                String trace = "ParmDBtreeNode gets name [";
+                for(int i = 0;i<splitName.length;i++){
+                    trace+=","+splitName[i];
+                }
+                logger.trace(trace+"]");
+                if (splitName.length >=2) {
+                    aValue=splitName[parentLevels.length-1];
+                }
+                
+                if(!uniqueNames.contains(aValue)){
+                    uniqueNames.addElement(aValue);
+                }
+            }
+            e = uniqueNames.elements();
+            while( e.hasMoreElements()  ) {
+                
+                String childName = (String)e.nextElement();
+                
+                jParmDBnode item = new jParmDBnode(((jParmDBnode)aNode.getUserObject()).nodeID()+"."+childName,((jParmDBnode)aNode.getUserObject()).nodeID());
+                //item.leaf=true;
+                item.name = childName;
+                logger.trace("Node name selected : "+item.name);
+                ((jParmDBnode)aNode.getUserObject()).leaf=false;
+                TreeNode newNode = new TreeNode(this.instance,item,item.name);
+                
+                TreeModelEvent evt = new TreeModelEvent(newNode,newNode.getPath());
+                
+                fireTreeInsertionPerformed(evt);
+                
+                aNode.add(newNode);
+            }
+            if(uniqueNames.size() == 0){
+                ((jParmDBnode)aNode.getUserObject()).leaf=true;
+            }
+            
+        } catch(Exception e) {
+            logger.fatal("Exception during TreeManager jParmDBnode-defineChildNodes: " + e);
+        }
+        logger.trace("Exit - TreeManager defineChildNodes("+toString()+")");
+    }
+    
+    public TreeNode getRootNode(String[] arguments){
+        jParmDBnode newPNode = new jParmDBnode(arguments[0],arguments[1]);
+        newPNode.name="ParmDB";
+        TreeNode parmDBnode = new TreeNode(this.instance,newPNode,newPNode.name);
+        
+        return parmDBnode;
+    }
+       
+}