<pre>
* the map of added blocks on all tiers
</pre>

<code>map&lt;string, .alluxio.grpc.block.TierList&gt; addedBlocksOnTiers = 4;</code>
187893
public alluxio.grpc.TierList getAddedBlocksOnTiersOrDefault(
      java.lang.String key,
      alluxio.grpc.TierList defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, alluxio.grpc.TierList> map =
        internalGetAddedBlocksOnTiers().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }
871445
public Map<String, Integer> getOnTierPercentages() {
    return mOrderedTierAliases.stream().collect(Collectors.toMap(tier -> tier, tier -> {
      Long sizeOnTier = mSizeOnTier.getOrDefault(tier, 0L);
      return mSize > 0 ? (int) (100 * sizeOnTier / mSize) : 0;
    }));
  }
26991
@Override
  public Set<Map.Entry<String, List<String>>> entrySet() {
    return getMap().entrySet();
  }
352860
public static <K, V> Map<K, V> asDeepTierMap(Map<K, V> map) {
        return from(map).deepLook().tierKey().map();
    }
1093164
public java.util.List<alluxio.grpc.BlockMasterInfoField> getFiltersList() {
    return new com.google.protobuf.Internal.ListAdapter<
        java.lang.Integer, alluxio.grpc.BlockMasterInfoField>(filters_, filters_converter_);
  }
302677
protected int addBlock(Collection<Record> candidates,
                         Map.Entry block) {
    Collection<Record> recs = (Collection<Record>) block.getValue();
    candidates.addAll(recs);
    return recs.size();
  }
1296716
Map<Integer, List<Integer>> initTreeMap() {
        Map<Integer, List<Integer>> treeMap = new LinkedHashMap<>(numWorkers);
        for(int r = 0; r < numWorkers; r++) {
            treeMap.put(r, getNeighbours(r));
        }
        return treeMap;
    }
1250275
public java.lang.String getTierName() {
    java.lang.Object ref = tierName_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        tierName_ = s;
      }
      return s;
    }
  }
1250165
public LinkedHashMap<String, String> getTierToBrokerMap()
  {
    return tierToBrokerMap == null ? new LinkedHashMap<>(
        ImmutableMap.of(
            DruidServer.DEFAULT_TIER, defaultBrokerServiceName
        )
    ) : tierToBrokerMap;
  }
66614
@Nullable
  public LookupExtractorFactoryMapContainer getLookup(final String tier, final String lookupName)
  {
    final Map<String, Map<String, LookupExtractorFactoryMapContainer>> prior = getKnownLookups();
    if (prior == null) {
      LOG.warn("Requested tier [%s] lookupName [%s]. But no lookups exist!", tier, lookupName);
      return null;
    }
    final Map<String, LookupExtractorFactoryMapContainer> tierLookups = prior.get(tier);
    if (tierLookups == null) {
      LOG.warn("Tier [%s] does not exist", tier);
      return null;
    }
    return tierLookups.get(lookupName);
  }
375852
@java.lang.Deprecated
  public java.util.Map<java.lang.String, alluxio.grpc.TierList> getCurrentBlocksOnTiers() {
    return getCurrentBlocksOnTiersMap();
  }
131980
private void addBlock(List<GenericCriteria> list, byte[] block, TestOperator operator)
   {
      GenericCriteria result = new GenericCriteria(m_properties);
      result.setOperator(operator);
      list.add(result);
      processBlock(result.getCriteriaList(), getChildBlock(block));
      processBlock(list, getListNextBlock(block));
   }
1188944
public <T> I addPageNames(Collection<T> webPages, Function<T, String> mapper) {
        for (T element : webPages) {
            addPage(WebPage.of(mapper.apply(element)));
        }
        return getThis();
    }
319350
private void checkTieredLocality() {
    // Check that any custom tiers set by alluxio.locality.{custom_tier}=value are also defined in
    // the tier ordering defined by alluxio.locality.order.
    Set<String> tiers = Sets.newHashSet(getList(PropertyKey.LOCALITY_ORDER, ","));
    Set<PropertyKey> predefinedKeys = new HashSet<>(PropertyKey.defaultKeys());
    for (PropertyKey key : mProperties.keySet()) {
      if (predefinedKeys.contains(key)) {
        // Skip non-templated keys.
        continue;
      }
      Matcher matcher = Template.LOCALITY_TIER.match(key.toString());
      if (matcher.matches() && matcher.group(1) != null) {
        String tierName = matcher.group(1);
        if (!tiers.contains(tierName)) {
          throw new IllegalStateException(
              String.format("Tier %s is configured by %s, but does not exist in the tier list %s "
                  + "configured by %s", tierName, key, tiers, PropertyKey.LOCALITY_ORDER));
        }
      }
    }
  }
803124
private static String getWorkerFormattedTierValues(Map<String, Map<String, String>> map,
      String workerName) {
    return map.values().stream().map((tierMap)
        -> (String.format("%-14s", tierMap.getOrDefault(workerName, "-"))))
        .collect(Collectors.joining(""));
  }
217488
public IStack<Object> tierOneUp(boolean newStack) {
		++tier;
		IStack<Object> result;
		if (newStack || tierStack.size() == tier) {
			if (logging) {
				result = new LogStack<>(new ProcessStack<>(), System.out);
			} else {
				result = new ProcessStack<>();
			}
			tierStack.add(result);
		} else {
			result = getTierStack();
		}
		return result;
	}
777169
public static <K, V> V getIfAbsent(Map<K, V> map, K key, Function0<? extends V> instanceBlock)
    {
        if (map instanceof UnsortedMapIterable)
        {
            return ((MapIterable<K, V>) map).getIfAbsent(key, instanceBlock);
        }
        V result = map.get(key);
        if (MapIterate.isAbsent(result, map, key))
        {
            result = instanceBlock.value();
        }
        return result;
    }