DelegateCapacityMonitor xref

View Javadoc

    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 }