001: /*
002: * <copyright>
003: *
004: * Copyright 1997-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:
027: package org.cougaar.core.thread;
028:
029: import java.util.ArrayList;
030: import java.util.List;
031:
032: import org.cougaar.core.service.ThreadListenerService;
033:
034: /**
035: * Implementation of {@link ThreadListenerService}.
036: */
037: final class ThreadListenerProxy implements ThreadListenerService {
038: private List<List<ThreadListener>> listenersList;
039: private TreeNode node;
040:
041: ThreadListenerProxy(int laneCount) {
042: listenersList = new ArrayList<List<ThreadListener>>(laneCount);
043: for (int i = 0; i < laneCount; i++)
044: listenersList.add(new ArrayList<ThreadListener>());
045: }
046:
047: void setTreeNode(TreeNode node) {
048: this .node = node;
049: }
050:
051: List<ThreadListener> getListeners(SchedulableObject schedulable) {
052: return listenersList.get(schedulable.getLane());
053: }
054:
055: List<ThreadListener> getListeners(Scheduler scheduler) {
056: return listenersList.get(scheduler.getLane());
057: }
058:
059: synchronized void notifyQueued(SchedulableObject schedulable) {
060: Object consumer = schedulable.getConsumer();
061: List<ThreadListener> listeners = getListeners(schedulable);
062: for (ThreadListener listener : listeners) {
063: listener.threadQueued(schedulable, consumer);
064: }
065: }
066:
067: synchronized void notifyDequeued(SchedulableObject schedulable) {
068: Object consumer = schedulable.getConsumer();
069: List<ThreadListener> listeners = getListeners(schedulable);
070: for (ThreadListener listener : listeners) {
071: listener.threadDequeued(schedulable, consumer);
072: }
073: }
074:
075: synchronized void notifyStart(SchedulableObject schedulable) {
076: Object consumer = schedulable.getConsumer();
077: List<ThreadListener> listeners = getListeners(schedulable);
078: for (ThreadListener listener : listeners) {
079: listener.threadStarted(schedulable, consumer);
080: }
081: }
082:
083: synchronized void notifyEnd(SchedulableObject schedulable) {
084: Object consumer = schedulable.getConsumer();
085: List<ThreadListener> listeners = getListeners(schedulable);
086: for (ThreadListener listener : listeners) {
087: listener.threadStopped(schedulable, consumer);
088: }
089: }
090:
091: synchronized void notifyRightGiven(Scheduler scheduler) {
092: String id = scheduler.getName();
093: List<ThreadListener> listeners = getListeners(scheduler);
094: for (ThreadListener listener : listeners) {
095: listener.rightGiven(id);
096: }
097: }
098:
099: synchronized void notifyRightReturned(Scheduler scheduler) {
100: String id = scheduler.getName();
101: List<ThreadListener> listeners = getListeners(scheduler);
102: for (ThreadListener listener : listeners) {
103: listener.rightReturned(id);
104: }
105: }
106:
107: public synchronized void addListener(ThreadListener listener,
108: int lane) {
109: if (lane < 0 || lane >= listenersList.size()) {
110: throw new RuntimeException("Lane is out of range: " + lane);
111: }
112: listenersList.get(lane).add(listener);
113: }
114:
115: public synchronized void removeListener(ThreadListener listener,
116: int lane) {
117: if (lane < 0 || lane >= listenersList.size()) {
118: throw new RuntimeException("Lane is out of range: " + lane);
119: }
120: listenersList.get(lane).remove(listener);
121: }
122:
123: public synchronized void addListener(ThreadListener listener) {
124: listenersList.get(node.getDefaultLane()).add(listener);
125: }
126:
127: public synchronized void removeListener(ThreadListener listener) {
128: listenersList.get(node.getDefaultLane()).remove(listener);
129: }
130:
131: }
|