public BeanContextServicesSupport() 
{
        this (null, null, false, true);
}

Create an instance that is not a delegate of another object

 public BeanContextServicesSupport(BeanContextServices peer) 
{
        this (peer, null, false, true);
}

Create an instance with a peer

Parameters:

peer - The peer BeanContext we are supplying an implementation for, if null the this object is its own peer

 public BeanContextServicesSupport(BeanContextServices peer,
    Locale lcle) 
{
        this (peer, lcle, false, true);
}

Create an instance using the specified locale

Parameters:

peer - The peer BeanContext we are supplying an implementation for, if null the this object is its own peer

lcle - The current Locale for this BeanContext.

 public BeanContextServicesSupport(BeanContextServices peer,
    Locale lcle,
    boolean dtime) 
{
        this (peer, lcle, dtime, true);
}

Create an instance using the specified Locale and design mode.

Parameters:

peer - The peer BeanContext we are supplying an implementation for, if null the this object is its own peer

lcle - The current Locale for this BeanContext.

dtime - The initial state, true if in design mode, false if runtime.

 public BeanContextServicesSupport(BeanContextServices peer,
    Locale lcle,
    boolean dTime,
    boolean visible) 
{
        super(peer, lcle, dTime, visible);
}

Construct a BeanContextServicesSupport instance

Parameters:

peer - The peer BeanContext we are supplying an implementation for, if null the this object is its own peer

lcle - The current Locale for this BeanContext.

dTime - The initial state, true if in design mode, false if runtime.

visible - The initial visibility.

 public  void addBeanContextServicesListener(BeanContextServicesListener bcsl) 
{
        if (bcsl == null) throw new NullPointerException("bcsl");
        synchronized(bcsListeners) {
            if (bcsListeners.contains(bcsl))
                return;
            else
                bcsListeners.add(bcsl);
        }
}

add a BeanContextServicesListener

 public boolean addService(Class serviceClass,
    BeanContextServiceProvider bcsp) 
{
        return addService(serviceClass, bcsp, true);
}

add a service

 protected boolean addService(Class serviceClass,
    BeanContextServiceProvider bcsp,
    boolean fireEvent) 
{
        if (serviceClass == null) throw new NullPointerException("serviceClass");
        if (bcsp         == null) throw new NullPointerException("bcsp");
        synchronized(BeanContext.globalHierarchyLock) {
            if (services.containsKey(serviceClass))
                return false;
            else {
                services.put(serviceClass,  createBCSSServiceProvider(serviceClass, bcsp));
                if (bcsp instanceof Serializable) serializable++;
                if (!fireEvent) return true;
                BeanContextServiceAvailableEvent bcssae = new BeanContextServiceAvailableEvent(getBeanContextServicesPeer(), serviceClass);
                fireServiceAdded(bcssae);
                synchronized(children) {
                    Iterator i = children.keySet().iterator();
                    while (i.hasNext()) {
                        Object c = i.next();
                        if (c instanceof BeanContextServices) {
                            ((BeanContextServicesListener)c).serviceAvailable(bcssae);
                        }
                    }
                }
                return true;
            }
        }
}

add a service

 protected synchronized  void bcsPreDeserializationHook(ObjectInputStream ois) throws IOException, ClassNotFoundException 
{
        serializable = ois.readInt();
        int count = serializable;
        while (count  > 0) {
            services.put(ois.readObject(), ois.readObject());
            count--;
        }
}

called from BeanContextSupport readObject before it deserializes the children ... This class will deserialize any Serializable BeanContextServiceProviders serialized earlier thus making them available to the children when they deserialized. subclasses may envelope this method to insert their own serialization processing that has to occur prior to serialization of the children

 protected synchronized  void bcsPreSerializationHook(ObjectOutputStream oos) throws IOException 
{
        oos.writeInt(serializable);
        if (serializable < = 0) return;
        int count = 0;
        Iterator i = services.entrySet().iterator();
        while (i.hasNext() && count <  serializable) {
            Map.Entry           entry = (Map.Entry)i.next();
            BCSSServiceProvider bcsp  = null;
             try {
                bcsp = (BCSSServiceProvider)entry.getValue();
             } catch (ClassCastException cce) {
                continue;
             }
             if (bcsp.getServiceProvider() instanceof Serializable) {
                oos.writeObject(entry.getKey());
                oos.writeObject(bcsp);
                count++;
             }
        }
        if (count != serializable)
            throw new IOException("wrote different number of service providers than expected");
}

called from BeanContextSupport writeObject before it serializes the children ... This class will serialize any Serializable BeanContextServiceProviders herein. subclasses may envelope this method to insert their own serialization processing that has to occur prior to serialization of the children

 protected  void childJustRemovedHook(Object child,
    BCSChild bcsc) 
{
        BCSSChild bcssc = (BCSSChild)bcsc;
        bcssc.cleanupReferences();
}

called from superclass child removal operations after a child has been successfully removed. called with child synchronized. This subclass uses this hook to immediately revoke any services being used by this child if it is a BeanContextChild. subclasses may envelope this method in order to implement their own child removal side-effects.

 protected BCSChild createBCSChild(Object targetChild,
    Object peer) 
{
        return new BCSSChild(targetChild, peer);
}

Subclasses can override this method to insert their own subclass of Child without having to override add() or the other Collection methods that add children to the set.

 protected BCSSServiceProvider createBCSSServiceProvider(Class sc,
    BeanContextServiceProvider bcsp) 
{
            return new BCSSServiceProvider(sc, bcsp);
}

subclasses can override this method to create new subclasses of BCSSServiceProvider without having to overrride addService() in order to instantiate.

 protected final  void fireServiceAdded(Class serviceClass) 
{
        BeanContextServiceAvailableEvent bcssae = new BeanContextServiceAvailableEvent(getBeanContextServicesPeer(), serviceClass);
        fireServiceAdded(bcssae);
}

Fires a BeanContextServiceEvent notifying of a new service.

 protected final  void fireServiceAdded(BeanContextServiceAvailableEvent bcssae) 
{
        Object[]                         copy;
        synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
        for (int i = 0; i <  copy.length; i++) {
            ((BeanContextServicesListener)copy[i]).serviceAvailable(bcssae);
        }
}

Fires a BeanContextServiceAvailableEvent indicating that a new service has become available.

 protected final  void fireServiceRevoked(BeanContextServiceRevokedEvent bcsre) 
{
        Object[]                         copy;
        synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
        for (int i = 0; i <  copy.length; i++) {
            ((BeanContextServiceRevokedListener)copy[i]).serviceRevoked(bcsre);
        }
}

Fires a BeanContextServiceEvent notifying of a service being revoked.

 protected final  void fireServiceRevoked(Class serviceClass,
    boolean revokeNow) 
{
        Object[]                       copy;
        BeanContextServiceRevokedEvent bcsre = new BeanContextServiceRevokedEvent(getBeanContextServicesPeer(), serviceClass, revokeNow);
        synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
        for (int i = 0; i <  copy.length; i++) {
            ((BeanContextServicesListener)copy[i]).serviceRevoked(bcsre);
        }
}

Fires a BeanContextServiceRevokedEvent indicating that a particular service is no longer available.

 public BeanContextServices getBeanContextServicesPeer() 
{
        return (BeanContextServices)getBeanContextChildPeer();
}

Gets the BeanContextServices associated with this BeanContextServicesSupport.

 protected static final BeanContextServicesListener getChildBeanContextServicesListener(Object child) 
{
        try {
            return (BeanContextServicesListener)child;
        } catch (ClassCastException cce) {
            return null;
        }
}

Gets the BeanContextServicesListener (if any) of the specified child.

 public Iterator getCurrentServiceClasses() 
{
        return new BCSIterator(services.keySet().iterator());
}

 public Iterator getCurrentServiceSelectors(Class serviceClass) 
{
        BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
        return bcsssp != null ? new BCSIterator(bcsssp.getServiceProvider().getCurrentServiceSelectors(getBeanContextServicesPeer(), serviceClass)) : null;
}

 public Object getService(BeanContextChild child,
    Object requestor,
    Class serviceClass,
    Object serviceSelector,
    BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException 
{
        if (child        == null) throw new NullPointerException("child");
        if (serviceClass == null) throw new NullPointerException("serviceClass");
        if (requestor    == null) throw new NullPointerException("requestor");
        if (bcsrl        == null) throw new NullPointerException("bcsrl");
        Object              service = null;
        BCSSChild           bcsc;
        BeanContextServices bcssp   = getBeanContextServicesPeer();
        synchronized(BeanContext.globalHierarchyLock) {
            synchronized(children) { bcsc = (BCSSChild)children.get(child); }
            if (bcsc == null) throw new IllegalArgumentException("not a child of this context"); // not a child ...
            BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
            if (bcsssp != null) {
                BeanContextServiceProvider bcsp = bcsssp.getServiceProvider();
                service = bcsp.getService(bcssp, requestor, serviceClass, serviceSelector);
                if (service != null) { // do bookkeeping ...
                    try {
                        bcsc.usingService(requestor, service, serviceClass, bcsp, false, bcsrl);
                    } catch (TooManyListenersException tmle) {
                        bcsp.releaseService(bcssp, requestor, service);
                        throw tmle;
                    } catch (UnsupportedOperationException uope) {
                        bcsp.releaseService(bcssp, requestor, service);
                        throw uope; // unchecked rt exception
                    }
                    return service;
                }
            }
            if (proxy != null) {
                // try to delegate ...
                service = proxy.getService(bcssp, requestor, serviceClass, serviceSelector);
                if (service != null) { // do bookkeeping ...
                    try {
                        bcsc.usingService(requestor, service, serviceClass, proxy, true, bcsrl);
                    } catch (TooManyListenersException tmle) {
                        proxy.releaseService(bcssp, requestor, service);
                        throw tmle;
                    } catch (UnsupportedOperationException uope) {
                        proxy.releaseService(bcssp, requestor, service);
                        throw uope; // unchecked rt exception
                    }
                    return service;
                }
            }
        }
        return null;
}

obtain a service which may be delegated

 public synchronized boolean hasService(Class serviceClass) 
{
        if (serviceClass == null) throw new NullPointerException("serviceClass");
        synchronized(BeanContext.globalHierarchyLock) {
            if (services.containsKey(serviceClass)) return true;
            BeanContextServices bcs = null;
            try {
                bcs = (BeanContextServices)getBeanContext();
            } catch (ClassCastException cce) {
                return false;
            }
            return bcs == null ? false : bcs.hasService(serviceClass);
        }
}

has a service, which may be delegated

 public  void initialize() 
{
        super.initialize();
        services     = new HashMap(serializable + 1);
        bcsListeners = new ArrayList(1);
}

called by BeanContextSupport superclass during construction and deserialization to initialize subclass transient state. subclasses may envelope this method, but should not override it or call it directly.

 protected synchronized  void initializeBeanContextResources() 
{
        super.initializeBeanContextResources();
        BeanContext nbc = getBeanContext();
        if (nbc == null) return;
        try {
            BeanContextServices bcs = (BeanContextServices)nbc;
            proxy = new BCSSProxyServiceProvider(bcs);
        } catch (ClassCastException cce) {
            // do nothing ...
        }
}

called from setBeanContext to notify a BeanContextChild to allocate resources obtained from the nesting BeanContext. subclasses may envelope this method to implement their own semantics.

 protected synchronized  void releaseBeanContextResources() 
{
        Object[] bcssc;
        super.releaseBeanContextResources();
        synchronized(children) {
            if (children.isEmpty()) return;
            bcssc = children.values().toArray();
        }
        for (int i = 0; i <  bcssc.length; i++) {
            ((BCSSChild)bcssc[i]).revokeAllDelegatedServicesNow();
        }
        proxy = null;
}

called from setBeanContext to notify a BeanContextChild to release resources obtained from the nesting BeanContext. This method revokes any services obtained from its parent. subclasses may envelope this method to implement their own semantics.

 public  void releaseService(BeanContextChild child,
    Object requestor,
    Object service) 
{
        if (child     == null) throw new NullPointerException("child");
        if (requestor == null) throw new NullPointerException("requestor");
        if (service   == null) throw new NullPointerException("service");
        BCSSChild bcsc;
        synchronized(BeanContext.globalHierarchyLock) {
                synchronized(children) { bcsc = (BCSSChild)children.get(child); }
                if (bcsc != null)
                    bcsc.releaseService(requestor, service);
                else
                   throw new IllegalArgumentException("child actual is not a child of this BeanContext");
        }
}

release a service

 public  void removeBeanContextServicesListener(BeanContextServicesListener bcsl) 
{
        if (bcsl == null) throw new NullPointerException("bcsl");
        synchronized(bcsListeners) {
            if (!bcsListeners.contains(bcsl))
                return;
            else
                bcsListeners.remove(bcsl);
        }
}

remove a BeanContextServicesListener

 public  void revokeService(Class serviceClass,
    BeanContextServiceProvider bcsp,
    boolean revokeCurrentServicesNow) 
{
        if (serviceClass == null) throw new NullPointerException("serviceClass");
        if (bcsp         == null) throw new NullPointerException("bcsp");
        synchronized(BeanContext.globalHierarchyLock) {
            if (!services.containsKey(serviceClass)) return;
            BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
            if (!bcsssp.getServiceProvider().equals(bcsp))
                throw new IllegalArgumentException("service provider mismatch");
            services.remove(serviceClass);
            if (bcsp instanceof Serializable) serializable--;
            Iterator i = bcsChildren(); // get the BCSChild values.
            while (i.hasNext()) {
                ((BCSSChild)i.next()).revokeService(serviceClass, false, revokeCurrentServicesNow);
            }
            fireServiceRevoked(serviceClass, revokeCurrentServicesNow);
        }
}

remove a service

 public  void serviceAvailable(BeanContextServiceAvailableEvent bcssae) 
{
        synchronized(BeanContext.globalHierarchyLock) {
            if (services.containsKey(bcssae.getServiceClass())) return;
            fireServiceAdded(bcssae);
            Iterator i;
            synchronized(children) {
                i = children.keySet().iterator();
            }
            while (i.hasNext()) {
                Object c = i.next();
                if (c instanceof BeanContextServices) {
                    ((BeanContextServicesListener)c).serviceAvailable(bcssae);
                }
            }
        }
}

BeanContextServicesListener callback, propagates event to all currently registered listeners and BeanContextServices children, if this BeanContextService does not already implement this service itself. subclasses may override or envelope this method to implement their own propagation semantics.

 public  void serviceRevoked(BeanContextServiceRevokedEvent bcssre) 
{
        synchronized(BeanContext.globalHierarchyLock) {
            if (services.containsKey(bcssre.getServiceClass())) return;
            fireServiceRevoked(bcssre);
            Iterator i;
            synchronized(children) {
                i = children.keySet().iterator();
            }
            while (i.hasNext()) {
                Object c = i.next();
                if (c instanceof BeanContextServices) {
                    ((BeanContextServicesListener)c).serviceRevoked(bcssre);
                }
            }
        }
}

BeanContextServicesListener callback, propagates event to all currently registered listeners and BeanContextServices children, if this BeanContextService does not already implement this service itself. subclasses may override or envelope this method to implement their own propagation semantics.