1 /*** 2 * 3 * Copyright 2004 Protique Ltd 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 **/ 18 19 package org.codehaus.activemq.capacity; 20 import java.util.Iterator; 21 import EDU.oswego.cs.dl.util.concurrent.CopyOnWriteArrayList; 22 23 /*** 24 * BasicCapacityMonitor implementation 25 * @version $Revision: 1.1 $ 26 */ 27 public class DelegateCapacityMonitor implements CapacityMonitor { 28 String name; 29 CapacityMonitor monitor; 30 CopyOnWriteArrayList listeners = new CopyOnWriteArrayList(); 31 32 /*** 33 * Construct a DelegateCapacityMonitor 34 * 35 */ 36 public DelegateCapacityMonitor() { 37 } 38 39 /*** 40 * Construct a DelegateCapacityMonitor 41 * @param name 42 * @param cm 43 */ 44 public DelegateCapacityMonitor(String name,CapacityMonitor cm){ 45 this.name = name; 46 this.monitor = cm; 47 } 48 49 /*** 50 * Set the delegated one 51 * @param cm 52 */ 53 public void setDelegate(CapacityMonitor cm){ 54 this.monitor = cm; 55 if (cm != null){ 56 for (Iterator i = listeners.iterator(); i.hasNext();){ 57 CapacityMonitorEventListener listener = (CapacityMonitorEventListener)i.next(); 58 cm.addCapacityEventListener(listener); 59 } 60 } 61 } 62 63 /*** 64 * Get the name of the CapacityMonitor 65 * 66 * @return 67 */ 68 public String getName() { 69 return name; 70 } 71 72 /*** 73 * @param newName 74 */ 75 public void setName(String newName){ 76 name = newName; 77 } 78 79 /*** 80 * Get the rounding factor - default is 10 81 * @return the rounding factor 82 */ 83 public int getRoundingFactor(){ 84 return monitor == null ? 0 : monitor.getRoundingFactor(); 85 } 86 87 /*** 88 * Set the rounding factor (between 1-100) 89 * @param newRoundingFactor 90 */ 91 public void setRoundingFactor(int newRoundingFactor){ 92 if(monitor != null){ 93 monitor.setRoundingFactor(newRoundingFactor); 94 } 95 } 96 97 /*** 98 * Add a CapacityEventListener 99 * 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 }