home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / prosrc.bin / DataBus.java < prev    next >
Text File  |  1998-03-18  |  8KB  |  233 lines
  1. /*
  2.  * @(#DataBus.java
  3.  *
  4.  * Copyright (c) 1997 Symantec Corporation. All Rights Reserved.
  5.  *
  6.  */
  7.  
  8. //This singleton class is the manifestation of the IB. Component classes participate in the IB by calling static member functions on
  9. //this class in order to register their interest in IB activity. In addition, helper methods are provided on this class to implement the
  10. //broadcast of notifications of and solicitations for new data. Bus participants must implement the DataBusEventListener interface
  11. //in order to register for and receive IB events. You cannot create a new instance of an DataBus by calling a constructor (it's
  12. //private); however, instances of an IB may be created as a byproduct of the joinDataBus() call.
  13.  
  14. package symantec.itools.db.beans.binding.databus;
  15.  
  16. import java.beans.*;
  17. import java.util.Vector;
  18. import java.awt.event.*;
  19.  
  20.  
  21.  
  22. public  class DataBus {
  23.  
  24.  
  25. //The debug instance variable
  26. //can be used to control the printing of stub information when handleEvent is called.
  27. private boolean debug = false;
  28.  
  29. //The list  of listeners
  30. private static Vector listeners = new Vector();
  31.  
  32. //the list if members
  33. // a listner can be a member or not
  34. //a member can be a listener or not
  35. private static Vector members = null;
  36.  
  37. private static DataBus ib=null;
  38.  
  39. private DataBus(){
  40.     if (members==null)
  41.         members = new Vector();
  42.         ib=this;
  43. }
  44.  
  45. public static void  initialize(){
  46.     ib=null;
  47.     members=null;
  48.     listeners=new Vector();
  49. }
  50.  
  51. private static DataBus getDataBus(DataBus ibx){
  52.     if (ibx==null && ib==null){
  53.         ib=new DataBus();
  54.         return ib;
  55.     }
  56.     else if (ib!=null)
  57.         return ib;
  58.     else
  59.         return ibx;
  60. }
  61.  
  62. //  This static member function uses the JavaBeans constrained property mechanism to push a (possibly
  63. // new) DataBus object onto the dbm object. This DataBus object is used in subsequent calls to identify
  64. // which of possible multiple DataBuses within an instance of a JVM is the target.
  65.  
  66. public static synchronized void joinDataBus(DataBusMember dbm)
  67. {
  68.     DataBus ib=dbm.getDataBus();
  69.     try
  70.     {
  71.         dbm.setDataBus(getDataBus(ib));
  72.     }
  73.     catch(PropertyVetoException e){}
  74.     members.addElement(dbm);
  75.  
  76. }
  77. public static synchronized void leaveDataBus(DataBusMember dbm)
  78. {
  79.      members.removeElement(dbm);
  80. }
  81.  
  82. // These methods register and unregister a listener from a particular instance of the IB.
  83.  
  84. public synchronized void addDataBusEventListener(DataBusEventListener listener)
  85. {
  86.     listeners.addElement(listener);
  87. }
  88.  
  89. public synchronized void removeDataBusEventListener(DataBusEventListener listener)
  90. {
  91.     listeners.removeElement(listener);
  92. }
  93.  
  94.  
  95. // This method broadcasts an event to all DataBusEvent listeners in the same IB context. The caller is
  96. // responsible for construction of an appropriate DataBusEvent.
  97.  
  98. public  synchronized void announceDataItem(DataBusEvent e)
  99. {
  100.       if (debug) {
  101.           System.err.println("Event type pressed: " + e.getEventType() +
  102.             " , for the data item: " + e.getDataItemName() +" from: " +e.toString());
  103.       }
  104.       Vector targets;
  105.       synchronized (this) {
  106.  
  107.           targets = (Vector) listeners.clone();
  108.  
  109.       }
  110.       try{
  111.  
  112.         DataBusEvent actionEvt = new DataBusEvent(e.getEventType(),e.getDataItemName(),e.getSource());
  113.  
  114.         for (int i = 0; i < targets.size(); i++) {
  115.  
  116.           DataBusEventListener target = (DataBusEventListener)targets.elementAt(i);
  117.  
  118.           target.handleDataBusEvent(actionEvt);
  119.  
  120.         }
  121.       }
  122.       catch ( InvalidType x ) {
  123.           System.err.println("Exception: " + x.getMessage());
  124.       }
  125. }
  126.  
  127. //Each of these methods broadcasts a request for data to all IB components. The version that returns a
  128.  //single DataItem returns the DataItem from the first positive response on the DataBus. This first version
  129.  //of findDataItem() stops polling IB members when it receives a response. Note that the polling order of
  130.  //IB members is indeterminate, but once established, remains essentially unchanged. To gather all
  131.  //responses to an inquiry, a requester should use the similar method, findAllDataItems(), which polls all
  132.  //IB members and returns all responses in an array of DataItems.
  133.  
  134.  
  135.  
  136. public DataItem findDataItem(String dataItemName, DataBusMember consumer)
  137. {
  138.     DataItem di=null;
  139.     try {
  140.         //create the event with Data Request and the object that creates the event
  141.         DataBusEvent ibevent=new DataBusEvent(DataBusEvent.DATA_REQUEST,dataItemName,consumer,di);
  142.         //question the members about dataItemName. If they aren't concerned than the dataItem returned
  143.         //will be null
  144.         for (int i=0;i<members.size();i++){
  145.             DataBusEventListener ibel=(DataBusEventListener)members.elementAt(i);
  146.             ibel.requestDataItem(ibevent);
  147.             if ((di=ibevent.getDataItem())!=null)
  148.                 //if a data item is reached we go out
  149.                break;
  150.         }
  151.     }
  152.     catch ( InvalidType x ) {
  153.           System.err.println("Exception: " + x.getMessage());
  154.     }
  155.     finally {
  156.         return(di);
  157.     }
  158.  
  159. }
  160.  
  161. public  synchronized DataItem[] findAllDataItems(String dataItemName,DataBusMember consumer)
  162. {
  163.     DataItem dia[]=null;
  164.     DataItem di=null;
  165.     int index=0;
  166.     try {
  167.         //create the event with Data Request and the object that creates the event
  168.         DataBusEvent ibevent=new DataBusEvent(DataBusEvent.DATA_REQUEST,dataItemName,consumer,di);
  169.         //question all the members about dataItemName. If they aren't concerned than the dataItem returned
  170.         //will be null
  171.         for (int i=0;i<members.size();i++){
  172.             DataBusEventListener ibel=(DataBusEventListener)members.elementAt(i);
  173.             ibel.requestDataItem(ibevent);
  174.             if ((di=ibevent.getDataItem())!=null){
  175.                 //if a data item is reached we go out
  176.                dia[i]=di;
  177.                i++;
  178.                di=null;
  179.             }
  180.         }
  181.     }
  182.     catch ( InvalidType x ) {
  183.           System.err.println("Exception: " + x.getMessage());
  184.     }
  185.     finally {
  186.         return dia;
  187.     }
  188. }
  189.  
  190. //The last version of findDataItem() is symmetric to the one which appears on the DataBusEventListener
  191.  //class. To use this version, the requesting IB member first constructs an DataBusEvent with the
  192.  //appropriate name, with the eventType set to DataBus.DATA_REQUEST, and with the DataItem field
  193.  //of the event set to NULL. If the query is successful, the DataItem from the first positive response will
  194.  //be attached to e.DataItem. Again, once a positive response occurs on the IB, other members are not
  195.  //queried.
  196.  
  197.  
  198. public  synchronized void findDataItem(DataBusEvent e)
  199. {
  200.     DataItem di=null;
  201.     //question the members about dataItemName. If they aren't concerned than the dataItem returned
  202.     //will be null
  203.     for (int i=0;i<members.capacity();i++){
  204.         DataBusEventListener ibel=(DataBusEventListener)members.elementAt(i);
  205.         ibel.requestDataItem(e);
  206.         if ((di=e.getDataItem())!=null)
  207.             //if a data item is reached we go out
  208.            break;
  209.     }
  210. }
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217. // Making debug a property lets you alter the reporting of events through a println
  218. // stub on the fly by changing the value of the property from false to true using
  219. // a property sheet editor. When debug is true calls to announceDataItem are reported
  220. // to the users by printing the label of the action that fired the event.
  221.  
  222.   public void setDebug(boolean x) {
  223.       boolean old = debug;
  224.       debug = x;
  225.   }
  226.  
  227.   public boolean getDebug() {
  228.       return debug;
  229.   }
  230.  
  231.  
  232. }
  233.