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 }