001    /** 
002     * 
003     * Copyright 2004 Protique Ltd
004     * 
005     * Licensed under the Apache License, Version 2.0 (the "License"); 
006     * you may not use this file except in compliance with the License. 
007     * You may obtain a copy of the License at 
008     * 
009     * http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS, 
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
014     * See the License for the specific language governing permissions and 
015     * limitations under the License. 
016     * 
017     **/
018    
019    package org.activemq.capacity;
020    import java.util.Iterator;
021    import EDU.oswego.cs.dl.util.concurrent.CopyOnWriteArrayList;
022    
023    /**
024     * BasicCapacityMonitor implementation
025     * @version $Revision: 1.1.1.1 $
026     */
027    public class DelegateCapacityMonitor implements CapacityMonitor {
028        String name;
029        CapacityMonitor monitor;
030        CopyOnWriteArrayList listeners = new CopyOnWriteArrayList();
031    
032        /**
033         * Construct a DelegateCapacityMonitor
034         * 
035         */
036        public DelegateCapacityMonitor() {
037        }
038        
039        /**
040         * Construct a DelegateCapacityMonitor
041         * @param name
042         * @param cm
043         */
044        public DelegateCapacityMonitor(String name,CapacityMonitor cm){
045            this.name = name;
046            this.monitor = cm;
047        }
048        
049        /**
050         * Set the delegated one
051         * @param cm
052         */
053        public void setDelegate(CapacityMonitor cm){
054            this.monitor = cm;
055            if (cm != null){
056                for (Iterator i = listeners.iterator(); i.hasNext();){
057                    CapacityMonitorEventListener listener = (CapacityMonitorEventListener)i.next();
058                    cm.addCapacityEventListener(listener);
059                }
060            }
061        }
062    
063        /**
064         * Get the name of the CapacityMonitor
065         * 
066         * @return
067         */
068        public String getName() {
069            return name; 
070        }
071        
072        /**
073         * @param newName
074         */
075        public void setName(String newName){
076            name = newName;
077        }
078        
079        /**
080         * Get the rounding factor - default is 10
081         * @return the rounding factor
082         */
083        public int getRoundingFactor(){
084            return monitor == null ? 0 : monitor.getRoundingFactor();
085        }
086        
087        /**
088         * Set the rounding factor (between 1-100)
089         * @param newRoundingFactor
090         */
091        public void setRoundingFactor(int newRoundingFactor){
092            if(monitor != null){
093                monitor.setRoundingFactor(newRoundingFactor);
094            }
095        }
096    
097        /**
098         * Add a CapacityEventListener
099         * 
100         * @param l
101         */
102        public void addCapacityEventListener(CapacityMonitorEventListener l) {
103            listeners.add(l);
104            if (monitor != null){
105                monitor.addCapacityEventListener(l);
106            }
107        }
108    
109        /**
110         * Remove a CapacityEventListener
111         * 
112         * @param l
113         */
114        public void removeCapacityEventListener(CapacityMonitorEventListener l) {
115            listeners.remove(l);
116            if (monitor != null){
117                monitor.removeCapacityEventListener(l);
118            }
119        }
120    
121        /**
122         * Get the current capscity of the service as a percentage
123         * 
124         * @return
125         */
126        public int getCurrentCapacity() {
127            return monitor == null ? 100 : monitor.getCurrentCapacity();
128        }
129        
130        /**
131         * Calculates the capacity rounded down to the rounding factor
132         * @return
133         */
134        public int getRoundedCapacity(){
135            return monitor == null ? 100 : monitor.getRoundedCapacity();
136        }
137    
138        /**
139         * Get the current value of the CapacityMonitor
140         * 
141         * @return
142         */
143        public long getCurrentValue() {
144            return monitor == null ? 100 : monitor.getCurrentValue();
145        }
146    
147        /**
148         * set the current value of the capacity
149         * 
150         * @param newCurrentValue
151         */
152        public void setCurrentValue(long newCurrentValue) {
153            if (monitor != null){
154                monitor.setCurrentValue(newCurrentValue);
155            }
156        }
157    
158        /**
159         * @return The upper limit of the value of the CapacityMonitor
160         */
161        public long getValueLimit() {
162            return monitor == null ? 100 : monitor.getValueLimit();
163        }
164    
165        /**
166         * set a new value limit for the CapacityMonitor
167         * 
168         * @param newValueLimit
169         */
170        public void setValueLimit(long newValueLimit) {
171            if(monitor != null){
172                monitor.setValueLimit(newValueLimit);
173            }
174            
175        }
176        
177        /**
178         * @return a CapacityMontorEvent for the currentCapacity
179         */
180        public CapacityMonitorEvent generateCapacityMonitorEvent(){
181            return monitor != null ? monitor.generateCapacityMonitorEvent() : null;
182        }
183    }