home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / beans / beancontext / BeanContextServicesSupport.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  9.9 KB  |  463 lines
  1. package java.beans.beancontext;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7. import java.util.ArrayList;
  8. import java.util.HashMap;
  9. import java.util.Iterator;
  10. import java.util.Locale;
  11. import java.util.Map;
  12. import java.util.TooManyListenersException;
  13.  
  14. public class BeanContextServicesSupport extends BeanContextSupport implements BeanContextServices {
  15.    protected transient HashMap services;
  16.    protected transient int serializable;
  17.    protected transient BCSSProxyServiceProvider proxy;
  18.    protected transient ArrayList bcsListeners;
  19.  
  20.    public BeanContextServicesSupport(BeanContextServices var1, Locale var2, boolean var3, boolean var4) {
  21.       super(var1, var2, var3, var4);
  22.       this.serializable = 0;
  23.    }
  24.  
  25.    public BeanContextServicesSupport(BeanContextServices var1, Locale var2, boolean var3) {
  26.       this(var1, var2, var3, true);
  27.    }
  28.  
  29.    public BeanContextServicesSupport(BeanContextServices var1, Locale var2) {
  30.       this(var1, var2, false, true);
  31.    }
  32.  
  33.    public BeanContextServicesSupport(BeanContextServices var1) {
  34.       this(var1, (Locale)null, false, true);
  35.    }
  36.  
  37.    public BeanContextServicesSupport() {
  38.       this((BeanContextServices)null, (Locale)null, false, true);
  39.    }
  40.  
  41.    public void initialize() {
  42.       super.initialize();
  43.       this.services = new HashMap(this.serializable + 1);
  44.       this.bcsListeners = new ArrayList(1);
  45.    }
  46.  
  47.    public BeanContextServices getBeanContextServicesPeer() {
  48.       return (BeanContextServices)((BeanContextChildSupport)this).getBeanContextChildPeer();
  49.    }
  50.  
  51.    protected BeanContextSupport.BCSChild createBCSChild(Object var1, Object var2) {
  52.       return new BCSSChild(this, var1, var2);
  53.    }
  54.  
  55.    protected BCSSServiceProvider createBCSSServiceProvider(Class var1, BeanContextServiceProvider var2) {
  56.       return new BCSSServiceProvider(var1, var2);
  57.    }
  58.  
  59.    public void addBeanContextServicesListener(BeanContextServicesListener var1) {
  60.       if (var1 == null) {
  61.          throw new NullPointerException("bcsl");
  62.       } else {
  63.          ArrayList var2 = this.bcsListeners;
  64.          synchronized(var2) {
  65.             if (!this.bcsListeners.contains(var1)) {
  66.                this.bcsListeners.add(var1);
  67.             }
  68.          }
  69.       }
  70.    }
  71.  
  72.    public void removeBeanContextServicesListener(BeanContextServicesListener var1) {
  73.       if (var1 == null) {
  74.          throw new NullPointerException("bcsl");
  75.       } else {
  76.          ArrayList var2 = this.bcsListeners;
  77.          synchronized(var2) {
  78.             if (this.bcsListeners.contains(var1)) {
  79.                this.bcsListeners.remove(var1);
  80.             }
  81.          }
  82.       }
  83.    }
  84.  
  85.    public boolean addService(Class var1, BeanContextServiceProvider var2) {
  86.       return this.addService(var1, var2, true);
  87.    }
  88.  
  89.    protected boolean addService(Class var1, BeanContextServiceProvider var2, boolean var3) {
  90.       if (var1 == null) {
  91.          throw new NullPointerException("serviceClass");
  92.       } else if (var2 == null) {
  93.          throw new NullPointerException("bcsp");
  94.       } else {
  95.          Object var4 = BeanContext.globalHierarchyLock;
  96.          synchronized(var4) {
  97.             if (this.services.containsKey(var1)) {
  98.                boolean var5 = false;
  99.                return var5;
  100.             } else {
  101.                this.services.put(var1, this.createBCSSServiceProvider(var1, var2));
  102.                if (var2 instanceof Serializable) {
  103.                   ++this.serializable;
  104.                }
  105.  
  106.                if (!var3) {
  107.                   boolean var6 = true;
  108.                   return var6;
  109.                } else {
  110.                   BeanContextServiceAvailableEvent var7 = new BeanContextServiceAvailableEvent(this.getBeanContextServicesPeer(), var1);
  111.                   this.fireServiceAdded(var7);
  112.                   HashMap var8 = super.children;
  113.                   synchronized(var8) {
  114.                      for(Object var10 : super.children.keySet()) {
  115.                         if (var10 instanceof BeanContextServices) {
  116.                            ((BeanContextServicesListener)var10).serviceAvailable(var7);
  117.                         }
  118.                      }
  119.                   }
  120.  
  121.                   boolean var15 = true;
  122.                   return var15;
  123.                }
  124.             }
  125.          }
  126.       }
  127.    }
  128.  
  129.    public void revokeService(Class var1, BeanContextServiceProvider var2, boolean var3) {
  130.       if (var1 == null) {
  131.          throw new NullPointerException("serviceClass");
  132.       } else if (var2 == null) {
  133.          throw new NullPointerException("bcsp");
  134.       } else {
  135.          Object var4 = BeanContext.globalHierarchyLock;
  136.          synchronized(var4) {
  137.             if (this.services.containsKey(var1)) {
  138.                BCSSServiceProvider var5 = (BCSSServiceProvider)this.services.get(var1);
  139.                if (!var5.getServiceProvider().equals(var2)) {
  140.                   throw new IllegalArgumentException("service provider mismatch");
  141.                } else {
  142.                   this.services.remove(var1);
  143.                   if (var2 instanceof Serializable) {
  144.                      --this.serializable;
  145.                   }
  146.  
  147.                   Iterator var6 = ((BeanContextSupport)this).bcsChildren();
  148.  
  149.                   while(var6.hasNext()) {
  150.                      ((BCSSChild)var6.next()).revokeService(var1, false, var3);
  151.                   }
  152.  
  153.                   this.fireServiceRevoked(var1, var3);
  154.                }
  155.             }
  156.          }
  157.       }
  158.    }
  159.  
  160.    public synchronized boolean hasService(Class var1) {
  161.       if (var1 == null) {
  162.          throw new NullPointerException("serviceClass");
  163.       } else {
  164.          Object var2 = BeanContext.globalHierarchyLock;
  165.          synchronized(var2) {
  166.             if (this.services.containsKey(var1)) {
  167.                boolean var3 = true;
  168.                return var3;
  169.             } else {
  170.                Object var4 = null;
  171.  
  172.                try {
  173.                   var10 = (BeanContextServices)((BeanContextChildSupport)this).getBeanContext();
  174.                } catch (ClassCastException var8) {
  175.                   boolean var6 = false;
  176.                   return var6;
  177.                }
  178.  
  179.                boolean var5 = var10 == null ? false : var10.hasService(var1);
  180.                return var5;
  181.             }
  182.          }
  183.       }
  184.    }
  185.  
  186.    public Object getService(BeanContextChild var1, Object var2, Class var3, Object var4, BeanContextServiceRevokedListener var5) throws TooManyListenersException {
  187.       if (var1 == null) {
  188.          throw new NullPointerException("child");
  189.       } else if (var3 == null) {
  190.          throw new NullPointerException("serviceClass");
  191.       } else if (var2 == null) {
  192.          throw new NullPointerException("requestor");
  193.       } else if (var5 == null) {
  194.          throw new NullPointerException("bcsrl");
  195.       } else {
  196.          Object var6 = null;
  197.          BeanContextServices var8 = this.getBeanContextServicesPeer();
  198.          Object var9 = BeanContext.globalHierarchyLock;
  199.          synchronized(var9) {
  200.             HashMap var10 = super.children;
  201.             BCSSChild var7;
  202.             synchronized(var10) {
  203.                var7 = (BCSSChild)super.children.get(var1);
  204.             }
  205.  
  206.             if (var7 == null) {
  207.                throw new IllegalArgumentException("not a child of this context");
  208.             } else {
  209.                BCSSServiceProvider var11 = (BCSSServiceProvider)this.services.get(var3);
  210.                if (var11 != null) {
  211.                   BeanContextServiceProvider var12 = var11.getServiceProvider();
  212.                   var6 = var12.getService(var8, var2, var3, var4);
  213.                   if (var6 != null) {
  214.                      try {
  215.                         var7.usingService(var2, var6, var3, var12, false, var5);
  216.                      } catch (TooManyListenersException var16) {
  217.                         var12.releaseService(var8, var2, var6);
  218.                         throw var16;
  219.                      } catch (UnsupportedOperationException var17) {
  220.                         var12.releaseService(var8, var2, var6);
  221.                         throw var17;
  222.                      }
  223.  
  224.                      return var6;
  225.                   }
  226.                }
  227.  
  228.                if (this.proxy != null) {
  229.                   var6 = this.proxy.getService(var8, var2, var3, var4);
  230.                   if (var6 != null) {
  231.                      try {
  232.                         var7.usingService(var2, var6, var3, this.proxy, true, var5);
  233.                      } catch (TooManyListenersException var18) {
  234.                         this.proxy.releaseService(var8, var2, var6);
  235.                         throw var18;
  236.                      } catch (UnsupportedOperationException var19) {
  237.                         this.proxy.releaseService(var8, var2, var6);
  238.                         throw var19;
  239.                      }
  240.  
  241.                      return var6;
  242.                   }
  243.                }
  244.  
  245.                return null;
  246.             }
  247.          }
  248.       }
  249.    }
  250.  
  251.    public void releaseService(BeanContextChild var1, Object var2, Object var3) {
  252.       if (var1 == null) {
  253.          throw new NullPointerException("child");
  254.       } else if (var2 == null) {
  255.          throw new NullPointerException("requestor");
  256.       } else if (var3 == null) {
  257.          throw new NullPointerException("service");
  258.       } else {
  259.          Object var5 = BeanContext.globalHierarchyLock;
  260.          synchronized(var5) {
  261.             HashMap var6 = super.children;
  262.             BCSSChild var4;
  263.             synchronized(var6) {
  264.                var4 = (BCSSChild)super.children.get(var1);
  265.             }
  266.  
  267.             if (var4 != null) {
  268.                var4.releaseService(var2, var3);
  269.             } else {
  270.                throw new IllegalArgumentException("child actual is not a child of this BeanContext");
  271.             }
  272.          }
  273.       }
  274.    }
  275.  
  276.    public Iterator getCurrentServiceClasses() {
  277.       return new BeanContextSupport.BCSIterator(this.services.keySet().iterator());
  278.    }
  279.  
  280.    public Iterator getCurrentServiceSelectors(Class var1) {
  281.       BCSSServiceProvider var2 = (BCSSServiceProvider)this.services.get(var1);
  282.       return var2 != null ? new BeanContextSupport.BCSIterator(var2.getServiceProvider().getCurrentServiceSelectors(this.getBeanContextServicesPeer(), var1)) : null;
  283.    }
  284.  
  285.    public void serviceAvailable(BeanContextServiceAvailableEvent var1) {
  286.       Object var2 = BeanContext.globalHierarchyLock;
  287.       synchronized(var2) {
  288.          if (!this.services.containsKey(var1.getServiceClass())) {
  289.             this.fireServiceAdded(var1);
  290.             HashMap var4 = super.children;
  291.             synchronized(var4) {
  292.                ;
  293.             }
  294.  
  295.             for(Object var5 : super.children.keySet()) {
  296.                if (var5 instanceof BeanContextServices) {
  297.                   ((BeanContextServicesListener)var5).serviceAvailable(var1);
  298.                }
  299.             }
  300.  
  301.          }
  302.       }
  303.    }
  304.  
  305.    public void serviceRevoked(BeanContextServiceRevokedEvent var1) {
  306.       Object var2 = BeanContext.globalHierarchyLock;
  307.       synchronized(var2) {
  308.          if (!this.services.containsKey(var1.getServiceClass())) {
  309.             this.fireServiceRevoked(var1);
  310.             HashMap var4 = super.children;
  311.             synchronized(var4) {
  312.                ;
  313.             }
  314.  
  315.             for(Object var5 : super.children.keySet()) {
  316.                if (var5 instanceof BeanContextServices) {
  317.                   ((BeanContextServicesListener)var5).serviceRevoked(var1);
  318.                }
  319.             }
  320.  
  321.          }
  322.       }
  323.    }
  324.  
  325.    protected static final BeanContextServicesListener getChildBeanContextServicesListener(Object var0) {
  326.       try {
  327.          return (BeanContextServicesListener)var0;
  328.       } catch (ClassCastException var2) {
  329.          return null;
  330.       }
  331.    }
  332.  
  333.    protected void childJustRemovedHook(Object var1, BeanContextSupport.BCSChild var2) {
  334.       BCSSChild var3 = (BCSSChild)var2;
  335.       var3.cleanupReferences();
  336.    }
  337.  
  338.    protected synchronized void releaseBeanContextResources() {
  339.       super.releaseBeanContextResources();
  340.       HashMap var2 = super.children;
  341.       Object[] var1;
  342.       synchronized(var2) {
  343.          if (super.children.isEmpty()) {
  344.             return;
  345.          }
  346.  
  347.          var1 = super.children.values().toArray();
  348.       }
  349.  
  350.       for(int var3 = 0; var3 < var1.length; ++var3) {
  351.          ((BCSSChild)var1[var3]).revokeAllDelegatedServicesNow();
  352.       }
  353.  
  354.       this.proxy = null;
  355.    }
  356.  
  357.    protected synchronized void initializeBeanContextResources() {
  358.       super.initializeBeanContextResources();
  359.       BeanContext var1 = ((BeanContextChildSupport)this).getBeanContext();
  360.       if (var1 != null) {
  361.          try {
  362.             BeanContextServices var2 = (BeanContextServices)var1;
  363.             this.proxy = new BCSSProxyServiceProvider(this, var2);
  364.          } catch (ClassCastException var3) {
  365.          }
  366.  
  367.       }
  368.    }
  369.  
  370.    protected final void fireServiceAdded(Class var1) {
  371.       BeanContextServiceAvailableEvent var2 = new BeanContextServiceAvailableEvent(this.getBeanContextServicesPeer(), var1);
  372.       this.fireServiceAdded(var2);
  373.    }
  374.  
  375.    protected final void fireServiceAdded(BeanContextServiceAvailableEvent var1) {
  376.       ArrayList var3 = this.bcsListeners;
  377.       Object[] var2;
  378.       synchronized(var3) {
  379.          var2 = this.bcsListeners.toArray();
  380.       }
  381.  
  382.       for(int var4 = 0; var4 < var2.length; ++var4) {
  383.          ((BeanContextServicesListener)var2[var4]).serviceAvailable(var1);
  384.       }
  385.  
  386.    }
  387.  
  388.    protected final void fireServiceRevoked(BeanContextServiceRevokedEvent var1) {
  389.       ArrayList var3 = this.bcsListeners;
  390.       Object[] var2;
  391.       synchronized(var3) {
  392.          var2 = this.bcsListeners.toArray();
  393.       }
  394.  
  395.       for(int var4 = 0; var4 < var2.length; ++var4) {
  396.          ((BeanContextServiceRevokedListener)var2[var4]).serviceRevoked(var1);
  397.       }
  398.  
  399.    }
  400.  
  401.    protected final void fireServiceRevoked(Class var1, boolean var2) {
  402.       BeanContextServiceRevokedEvent var4 = new BeanContextServiceRevokedEvent(this.getBeanContextServicesPeer(), var1, var2);
  403.       ArrayList var5 = this.bcsListeners;
  404.       Object[] var3;
  405.       synchronized(var5) {
  406.          var3 = this.bcsListeners.toArray();
  407.       }
  408.  
  409.       for(int var6 = 0; var6 < var3.length; ++var6) {
  410.          ((BeanContextServicesListener)var3[var6]).serviceRevoked(var4);
  411.       }
  412.  
  413.    }
  414.  
  415.    protected synchronized void bcsPreSerializationHook(ObjectOutputStream var1) throws IOException {
  416.       var1.writeInt(this.serializable);
  417.       if (this.serializable > 0) {
  418.          int var2 = 0;
  419.          Iterator var3 = this.services.entrySet().iterator();
  420.  
  421.          while(var3.hasNext() && var2 < this.serializable) {
  422.             Map.Entry var4 = (Map.Entry)var3.next();
  423.             Object var5 = null;
  424.  
  425.             try {
  426.                var8 = (BCSSServiceProvider)var4.getValue();
  427.             } catch (ClassCastException var7) {
  428.                continue;
  429.             }
  430.  
  431.             if (var8.getServiceProvider() instanceof Serializable) {
  432.                var1.writeObject(var4.getKey());
  433.                var1.writeObject(var8);
  434.                ++var2;
  435.             }
  436.          }
  437.  
  438.          if (var2 != this.serializable) {
  439.             throw new IOException("wrote different number of service providers than expected");
  440.          }
  441.       }
  442.    }
  443.  
  444.    protected synchronized void bcsPreDeserializationHook(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  445.       this.serializable = var1.readInt();
  446.  
  447.       for(int var2 = this.serializable; var2 > 0; --var2) {
  448.          this.services.put(var1.readObject(), var1.readObject());
  449.       }
  450.  
  451.    }
  452.  
  453.    private synchronized void writeObject(ObjectOutputStream var1) throws IOException {
  454.       var1.defaultWriteObject();
  455.       ((BeanContextSupport)this).serialize(var1, this.bcsListeners);
  456.    }
  457.  
  458.    private synchronized void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  459.       var1.defaultReadObject();
  460.       ((BeanContextSupport)this).deserialize(var1, this.bcsListeners);
  461.    }
  462. }
  463.