CounterGroup.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.mapreduce;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import java.util.Iterator;
  23. import java.util.MissingResourceException;
  24. import java.util.ResourceBundle;
  25. import java.util.TreeMap;
  26. import org.apache.hadoop.io.Text;
  27. import org.apache.hadoop.io.Writable;
  28. import org.apache.hadoop.io.WritableUtils;
  29. /**
  30.  * A group of {@link Counter}s that logically belong together. Typically,
  31.  * it is an {@link Enum} subclass and the counters are the values.
  32.  */
  33. public class CounterGroup implements Writable, Iterable<Counter> {
  34.   private String name;
  35.   private String displayName;
  36.   private TreeMap<String, Counter> counters = new TreeMap<String, Counter>();
  37.   // Optional ResourceBundle for localization of group and counter names.
  38.   private ResourceBundle bundle = null;    
  39.   
  40.   /**
  41.    * Returns the specified resource bundle, or throws an exception.
  42.    * @throws MissingResourceException if the bundle isn't found
  43.    */
  44.   private static ResourceBundle getResourceBundle(String enumClassName) {
  45.     String bundleName = enumClassName.replace('$','_');
  46.     return ResourceBundle.getBundle(bundleName);
  47.   }
  48.   protected CounterGroup(String name) {
  49.     this.name = name;
  50.     try {
  51.       bundle = getResourceBundle(name);
  52.     }
  53.     catch (MissingResourceException neverMind) {
  54.     }
  55.     displayName = localize("CounterGroupName", name);
  56.   }
  57.   
  58.   protected CounterGroup(String name, String displayName) {
  59.     this.name = name;
  60.     this.displayName = displayName;
  61.   }
  62.  
  63.   /**
  64.    * Get the internal name of the group
  65.    * @return the internal name
  66.    */
  67.   public synchronized String getName() {
  68.     return name;
  69.   }
  70.   
  71.   /**
  72.    * Get the display name of the group.
  73.    * @return the human readable name
  74.    */
  75.   public synchronized String getDisplayName() {
  76.     return displayName;
  77.   }
  78.   synchronized void addCounter(Counter counter) {
  79.     counters.put(counter.getName(), counter);
  80.   }
  81.   /**
  82.    * Internal to find a counter in a group.
  83.    * @param counterName the name of the counter
  84.    * @param displayName the display name of the counter
  85.    * @return the counter that was found or added
  86.    */
  87.   protected Counter findCounter(String counterName, String displayName) {
  88.     Counter result = counters.get(counterName);
  89.     if (result == null) {
  90.       result = new Counter(counterName, displayName);
  91.       counters.put(counterName, result);
  92.     }
  93.     return result;
  94.   }
  95.   public synchronized Counter findCounter(String counterName) {
  96.     Counter result = counters.get(counterName);
  97.     if (result == null) {
  98.       String displayName = localize(counterName, counterName);
  99.       result = new Counter(counterName, displayName);
  100.       counters.put(counterName, result);
  101.     }
  102.     return result;
  103.   }
  104.   
  105.   public synchronized Iterator<Counter> iterator() {
  106.     return counters.values().iterator();
  107.   }
  108.   public synchronized void write(DataOutput out) throws IOException {
  109.     Text.writeString(out, displayName);
  110.     WritableUtils.writeVInt(out, counters.size());
  111.     for(Counter counter: counters.values()) {
  112.       counter.write(out);
  113.     }
  114.   }
  115.   
  116.   public synchronized void readFields(DataInput in) throws IOException {
  117.     displayName = Text.readString(in);
  118.     counters.clear();
  119.     int size = WritableUtils.readVInt(in);
  120.     for(int i=0; i < size; i++) {
  121.       Counter counter = new Counter();
  122.       counter.readFields(in);
  123.       counters.put(counter.getName(), counter);
  124.     }
  125.   }
  126.   /**
  127.    * Looks up key in the ResourceBundle and returns the corresponding value.
  128.    * If the bundle or the key doesn't exist, returns the default value.
  129.    */
  130.   private String localize(String key, String defaultValue) {
  131.     String result = defaultValue;
  132.     if (bundle != null) {
  133.       try {
  134.         result = bundle.getString(key);
  135.       }
  136.       catch (MissingResourceException mre) {
  137.       }
  138.     }
  139.     return result;
  140.   }
  141.   /**
  142.    * Returns the number of counters in this group.
  143.    */
  144.   public synchronized int size() {
  145.     return counters.size();
  146.   }
  147.   public synchronized boolean equals(Object genericRight) {
  148.     if (genericRight instanceof CounterGroup) {
  149.       Iterator<Counter> right = ((CounterGroup) genericRight).counters.
  150.                                        values().iterator();
  151.       Iterator<Counter> left = counters.values().iterator();
  152.       while (left.hasNext()) {
  153.         if (!right.hasNext() || !left.next().equals(right.next())) {
  154.           return false;
  155.         }
  156.       }
  157.       return !right.hasNext();
  158.     }
  159.     return false;
  160.   }
  161.   public synchronized int hashCode() {
  162.     return counters.hashCode();
  163.   }
  164.   
  165.   public synchronized void incrAllCounters(CounterGroup rightGroup) {
  166.     for(Counter right: rightGroup.counters.values()) {
  167.       Counter left = findCounter(right.getName(), right.getDisplayName());
  168.       left.increment(right.getValue());
  169.     }
  170.   }
  171. }