001: /*
002: * <copyright>
003: *
004: * Copyright 2000-2004 BBNT Solutions, LLC
005: * under sponsorship of the Defense Advanced Research Projects
006: * Agency (DARPA).
007: *
008: * You can redistribute this software and/or modify it under the
009: * terms of the Cougaar Open Source License as published on the
010: * Cougaar Open Source Website (www.cougaar.org).
011: *
012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
023: *
024: * </copyright>
025: */
026: package org.cougaar.core.component;
027:
028: import java.util.HashMap;
029: import java.util.Iterator;
030:
031: /** A Simple ServiceBroker which just delegates all
032: * queries to another, useful for making restricted extentions.
033: * Note that it does a little bit of magic to hide the identity of the
034: * other ServiceBroker from clients.
035: **/
036:
037: public class DelegatingServiceBroker implements ExtendedServiceBroker {
038: public DelegatingServiceBroker(ServiceBroker delegate) {
039: if (delegate == null) {
040: throw new IllegalArgumentException(
041: "Delegate must be non-null");
042: }
043:
044: this .delegate = delegate;
045: }
046:
047: private ServiceBroker delegate;
048:
049: protected ServiceBroker getDelegate() {
050: return delegate;
051: }
052:
053: private HashMap listeners = new HashMap(11);
054:
055: /** add a ServiceListener to this ServiceBroker Context **/
056: public void addServiceListener(final ServiceListener sl) {
057: if (sl == null)
058: throw new IllegalArgumentException(
059: "Add of null ServiceListener");
060:
061: ServiceListener slp;
062: if (sl instanceof ServiceAvailableListener) {
063: slp = new ServiceAvailableListener() {
064: public void serviceAvailable(ServiceAvailableEvent ae) {
065: ((ServiceAvailableListener) sl)
066: .serviceAvailable(new ServiceAvailableEvent(
067: DelegatingServiceBroker.this , ae
068: .getService()));
069: }
070: };
071: } else if (sl instanceof ServiceRevokedListener) {
072: slp = new ServiceRevokedListener() {
073: public void serviceRevoked(ServiceRevokedEvent ae) {
074: ((ServiceRevokedListener) sl)
075: .serviceRevoked(new ServiceRevokedEvent(
076: DelegatingServiceBroker.this , ae
077: .getService()));
078: }
079: };
080: } else {
081: throw new IllegalArgumentException(
082: "DelegatingServiceBroker cannot delegate this listener: "
083: + sl);
084: }
085: synchronized (listeners) {
086: listeners.put(sl, slp);
087: }
088: delegate.addServiceListener(slp);
089: }
090:
091: /** remove a services listener **/
092: public void removeServiceListener(ServiceListener sl) {
093: if (sl == null)
094: throw new IllegalArgumentException(
095: "Remove of null ServiceListener");
096:
097: ServiceListener slp;
098: synchronized (listeners) {
099: slp = (ServiceListener) listeners.get(sl);
100: if (slp != null) {
101: listeners.remove(sl);
102: }
103: }
104: if (slp != null) {
105: delegate.removeServiceListener(slp);
106: }
107: }
108:
109: /** add a Service to this ServiceBroker Context **/
110: public boolean addService(Class serviceClass,
111: ServiceProvider serviceProvider) {
112: return addService(serviceClass, serviceProvider, 0, null);
113: }
114:
115: public boolean addService(Class serviceClass,
116: ServiceProvider serviceProvider, int providerId,
117: ComponentDescription providerDesc) {
118: if (delegate instanceof ExtendedServiceBroker) {
119: ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
120: return esb.addService(serviceClass, serviceProvider,
121: providerId, providerDesc);
122: } else {
123: return delegate.addService(serviceClass, serviceProvider);
124: }
125: }
126:
127: /** remoke or remove an existing service **/
128: public void revokeService(Class serviceClass,
129: ServiceProvider serviceProvider) {
130: revokeService(serviceClass, serviceProvider, 0, null);
131: }
132:
133: public void revokeService(Class serviceClass,
134: ServiceProvider serviceProvider, int providerId,
135: ComponentDescription providerDesc) {
136: if (delegate instanceof ExtendedServiceBroker) {
137: ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
138: esb.revokeService(serviceClass, serviceProvider,
139: providerId, providerDesc);
140: } else {
141: delegate.revokeService(serviceClass, serviceProvider);
142: }
143: }
144:
145: /** is the service currently available? **/
146: public boolean hasService(Class serviceClass) {
147: return delegate.hasService(serviceClass);
148: }
149:
150: /** gets the currently available services for this context.
151: * This version copies the keyset to keep the iterator safe.
152: **/
153: public Iterator getCurrentServiceClasses() {
154: return delegate.getCurrentServiceClasses();
155: }
156:
157: /** get an instance of the requested service from a service provider associated
158: * with this context.
159: **/
160: public <T> T getService(Object requestor,
161: final Class<T> serviceClass,
162: final ServiceRevokedListener srl) {
163: return delegate.getService(requestor, serviceClass, srl);
164: }
165:
166: public ServiceResult getService(int requestorId,
167: ComponentDescription requestorDesc, Object requestor,
168: Class serviceClass, ServiceRevokedListener srl,
169: boolean recordInView) {
170: if (delegate instanceof ExtendedServiceBroker) {
171: ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
172: return esb.getService(requestorId, requestorDesc,
173: requestor, serviceClass, srl, recordInView);
174: } else {
175: Object service = delegate.getService(requestor,
176: serviceClass, srl);
177: return (service == null ? (null) : new ServiceResult(0,
178: null, service));
179: }
180: }
181:
182: public void releaseService(Object requestor, Class serviceClass,
183: Object service) {
184: delegate.releaseService(requestor, serviceClass, service);
185: }
186:
187: public void releaseService(int requestorId,
188: ComponentDescription requestorDesc, Object requestor,
189: Class serviceClass, Object service, boolean recordInView) {
190: if (delegate instanceof ExtendedServiceBroker) {
191: ExtendedServiceBroker esb = (ExtendedServiceBroker) delegate;
192: esb.releaseService(requestorId, requestorDesc, requestor,
193: serviceClass, service, recordInView);
194: } else {
195: delegate.releaseService(requestor, serviceClass, service);
196: }
197: }
198: }
|