Java 类org.apache.hadoop.mapreduce.counters.CounterGroupBase 实例源码

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

/**
 * Make the pre 0.21 counters string
 * @param <C> type of the counter
 * @param <G> type of the counter group
 * @param <T> type of the counters object
 * @param counters the object to stringify
 * @return the string in the following format
 * {(groupName)(group-displayName)[(counterName)(displayName)(value)]*}*
 */
public static <C extends Counter, G extends CounterGroupBase<C>,
               T extends AbstractCounters<C, G>>
String toEscapedCompactString(T counters) {
  StringBuilder builder = new StringBuilder();
  synchronized(counters) {
    for (G group : counters) {
      builder.append(toEscapedCompactString(group));
    }
  }
  return builder.toString();
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

/**
 * Make the pre 0.21 counters string
 * @param <C> type of the counter
 * @param <G> type of the counter group
 * @param <T> type of the counters object
 * @param counters the object to stringify
 * @return the string in the following format
 * {(groupName)(group-displayName)[(counterName)(displayName)(value)]*}*
 */
public static <C extends Counter, G extends CounterGroupBase<C>,
               T extends AbstractCounters<C, G>>
String toEscapedCompactString(T counters) {
  StringBuilder builder = new StringBuilder();
  synchronized(counters) {
    for (G group : counters) {
      builder.append(toEscapedCompactString(group));
    }
  }
  return builder.toString();
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public synchronized boolean equals(Object genericRight) {
  if (genericRight instanceof CounterGroupBase<?>) {
    @SuppressWarnings("unchecked")
    CounterGroupBase<Counter> right = ((CounterGroupBase<Counter>) 
    genericRight).getUnderlyingGroup();
    return Iterators.elementsEqual(iterator(), right.iterator());
  }
  return false;
}

@Override
public void incrAllCounters(CounterGroupBase<Counter> rightGroup) {
  realGroup.incrAllCounters(rightGroup);
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return realGroup;
}

static long getCounterValue(CounterGroupBase<Counter> group, String counterName) {
  Counter counter = group.findCounter(counterName, false);
  if (counter != null) return counter.getValue();
  return 0L;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
 return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

/**
 * Make the 0.21 counter group string.
 * format: {(actual-name)(display-name)(value)[][][]}
 * where [] are compact strings for the counters within.
 * @param <G> type of the group
 * @param group to stringify
 * @return the stringified result
 */
public static <G extends CounterGroupBase<?>>
String toEscapedCompactString(G group) {
  List<String> escapedStrs = Lists.newArrayList();
  int length;
  String escapedName, escapedDispName;
  synchronized(group) {
    // First up, obtain the strings that need escaping. This will help us
    // determine the buffer length apriori.
    escapedName = escape(group.getName());
    escapedDispName = escape(group.getDisplayName());
    int i = 0;
    length = escapedName.length() + escapedDispName.length();
    for (Counter counter : group) {
      String escapedStr = toEscapedCompactString(counter);
      escapedStrs.add(escapedStr);
      length += escapedStr.length();
    }
  }
  length += 6; // for all the delimiting characters below
  StringBuilder builder = new StringBuilder(length);
  builder.append(GROUP_OPEN); // group start

  // Add the group name
  builder.append(UNIT_OPEN);
  builder.append(escapedName);
  builder.append(UNIT_CLOSE);

  // Add the display name
  builder.append(UNIT_OPEN);
  builder.append(escapedDispName);
  builder.append(UNIT_CLOSE);

  // write the value
  for(String escaped : escapedStrs) {
    builder.append(escaped);
  }

  builder.append(GROUP_CLOSE); // group end
  return builder.toString();
}

/**
 * Parse a pre 0.21 counters string into a counter object.
 * @param <C> type of the counter
 * @param <G> type of the counter group
 * @param <T> type of the counters object
 * @param compactString to parse
 * @param counters an empty counters object to hold the result
 * @return the counters object holding the result
 * @throws ParseException
 */
@SuppressWarnings("deprecation")
public static <C extends Counter, G extends CounterGroupBase<C>,
               T extends AbstractCounters<C, G>>
T parseEscapedCompactString(String compactString, T counters)
    throws ParseException {
  IntWritable index = new IntWritable(0);

  // Get the group to work on
  String groupString =
    getBlock(compactString, GROUP_OPEN, GROUP_CLOSE, index);

  while (groupString != null) {
    IntWritable groupIndex = new IntWritable(0);

    // Get the actual name
    String groupName =
        StringInterner.weakIntern(getBlock(groupString, UNIT_OPEN, UNIT_CLOSE, groupIndex));
    groupName = StringInterner.weakIntern(unescape(groupName));

    // Get the display name
    String groupDisplayName =
        StringInterner.weakIntern(getBlock(groupString, UNIT_OPEN, UNIT_CLOSE, groupIndex));
    groupDisplayName = StringInterner.weakIntern(unescape(groupDisplayName));

    // Get the counters
    G group = counters.getGroup(groupName);
    group.setDisplayName(groupDisplayName);

    String counterString =
      getBlock(groupString, COUNTER_OPEN, COUNTER_CLOSE, groupIndex);

    while (counterString != null) {
      IntWritable counterIndex = new IntWritable(0);

      // Get the actual name
      String counterName =
          StringInterner.weakIntern(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE, counterIndex));
      counterName = StringInterner.weakIntern(unescape(counterName));

      // Get the display name
      String counterDisplayName =
          StringInterner.weakIntern(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE, counterIndex));
      counterDisplayName = StringInterner.weakIntern(unescape(counterDisplayName));

      // Get the value
      long value =
        Long.parseLong(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE,
                                counterIndex));

      // Add the counter
      Counter counter = group.findCounter(counterName);
      counter.setDisplayName(counterDisplayName);
      counter.increment(value);

      // Get the next counter
      counterString =
        getBlock(groupString, COUNTER_OPEN, COUNTER_CLOSE, groupIndex);
    }

    groupString = getBlock(compactString, GROUP_OPEN, GROUP_CLOSE, index);
  }
  return counters;
}

@Override
public void incrAllCounters(CounterGroupBase<Counter> rightGroup) {
  realGroup.incrAllCounters(rightGroup);
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return realGroup;
}

static long getCounterValue(CounterGroupBase<Counter> group, String counterName) {
  Counter counter = group.findCounter(counterName, false);
  if (counter != null) return counter.getValue();
  return 0L;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
 return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return this;
}

/**
 * Make the 0.21 counter group string.
 * format: {(actual-name)(display-name)(value)[][][]}
 * where [] are compact strings for the counters within.
 * @param <G> type of the group
 * @param group to stringify
 * @return the stringified result
 */
public static <G extends CounterGroupBase<?>>
String toEscapedCompactString(G group) {
  List<String> escapedStrs = Lists.newArrayList();
  int length;
  String escapedName, escapedDispName;
  synchronized(group) {
    // First up, obtain the strings that need escaping. This will help us
    // determine the buffer length apriori.
    escapedName = escape(group.getName());
    escapedDispName = escape(group.getDisplayName());
    int i = 0;
    length = escapedName.length() + escapedDispName.length();
    for (Counter counter : group) {
      String escapedStr = toEscapedCompactString(counter);
      escapedStrs.add(escapedStr);
      length += escapedStr.length();
    }
  }
  length += 6; // for all the delimiting characters below
  StringBuilder builder = new StringBuilder(length);
  builder.append(GROUP_OPEN); // group start

  // Add the group name
  builder.append(UNIT_OPEN);
  builder.append(escapedName);
  builder.append(UNIT_CLOSE);

  // Add the display name
  builder.append(UNIT_OPEN);
  builder.append(escapedDispName);
  builder.append(UNIT_CLOSE);

  // write the value
  for(String escaped : escapedStrs) {
    builder.append(escaped);
  }

  builder.append(GROUP_CLOSE); // group end
  return builder.toString();
}

/**
 * Parse a pre 0.21 counters string into a counter object.
 * @param <C> type of the counter
 * @param <G> type of the counter group
 * @param <T> type of the counters object
 * @param compactString to parse
 * @param counters an empty counters object to hold the result
 * @return the counters object holding the result
 * @throws ParseException
 */
@SuppressWarnings("deprecation")
public static <C extends Counter, G extends CounterGroupBase<C>,
               T extends AbstractCounters<C, G>>
T parseEscapedCompactString(String compactString, T counters)
    throws ParseException {
  IntWritable index = new IntWritable(0);

  // Get the group to work on
  String groupString =
    getBlock(compactString, GROUP_OPEN, GROUP_CLOSE, index);

  while (groupString != null) {
    IntWritable groupIndex = new IntWritable(0);

    // Get the actual name
    String groupName =
        StringInterner.weakIntern(getBlock(groupString, UNIT_OPEN, UNIT_CLOSE, groupIndex));
    groupName = StringInterner.weakIntern(unescape(groupName));

    // Get the display name
    String groupDisplayName =
        StringInterner.weakIntern(getBlock(groupString, UNIT_OPEN, UNIT_CLOSE, groupIndex));
    groupDisplayName = StringInterner.weakIntern(unescape(groupDisplayName));

    // Get the counters
    G group = counters.getGroup(groupName);
    group.setDisplayName(groupDisplayName);

    String counterString =
      getBlock(groupString, COUNTER_OPEN, COUNTER_CLOSE, groupIndex);

    while (counterString != null) {
      IntWritable counterIndex = new IntWritable(0);

      // Get the actual name
      String counterName =
          StringInterner.weakIntern(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE, counterIndex));
      counterName = StringInterner.weakIntern(unescape(counterName));

      // Get the display name
      String counterDisplayName =
          StringInterner.weakIntern(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE, counterIndex));
      counterDisplayName = StringInterner.weakIntern(unescape(counterDisplayName));

      // Get the value
      long value =
        Long.parseLong(getBlock(counterString, UNIT_OPEN, UNIT_CLOSE,
                                counterIndex));

      // Add the counter
      Counter counter = group.findCounter(counterName);
      counter.setDisplayName(counterDisplayName);
      counter.increment(value);

      // Get the next counter
      counterString =
        getBlock(groupString, COUNTER_OPEN, COUNTER_CLOSE, groupIndex);
    }

    groupString = getBlock(compactString, GROUP_OPEN, GROUP_CLOSE, index);
  }
  return counters;
}

@Override
public void incrAllCounters(CounterGroupBase<Counter> rightGroup) {
  realGroup.incrAllCounters(rightGroup);
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
  return realGroup;
}

static long getCounterValue(CounterGroupBase<Counter> group, String counterName) {
  Counter counter = group.findCounter(counterName, false);
  if (counter != null) return counter.getValue();
  return 0L;
}

@Override
public CounterGroupBase<Counter> getUnderlyingGroup() {
 return this;
}