<pre>
* the map of list of blocks on each tier
</pre>

<code>map&lt;string, .alluxio.grpc.block.TierList&gt; currentBlocksOnTiers = 5;</code>
542152
public boolean containsCurrentBlocksOnTiers(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetCurrentBlocksOnTiers().getMap().containsKey(key);
  }
93406
@SuppressWarnings("unchecked")
    public <M extends T> Map<?, M> findMap() {
        return (Map<?, M>) query().findMap();
    }
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));
        }
      }
    }
  }
1206403
private void addBlockToAddedBlocks(long blockId, String tierAlias) {
    if (mAddedBlocks.containsKey(tierAlias)) {
      mAddedBlocks.get(tierAlias).add(blockId);
    } else {
      mAddedBlocks.put(tierAlias, Lists.newArrayList(blockId));
    }
  }
539174
public List<StorageTier> getTiersBelow(String tierAlias) {
    int ordinal = getTier(tierAlias).getTierOrdinal();
    return mTiers.subList(ordinal + 1, mTiers.size());
  }
127767
public alluxio.grpc.TieredIdentityOrBuilder getTieredIdentityOrBuilder() {
    return tieredIdentity_ == null ? alluxio.grpc.TieredIdentity.getDefaultInstance() : tieredIdentity_;
  }
639123
@Override
  public synchronized Map<String, Collection<OutputRecord>> getAllRecords() {
    Map<String, Collection<OutputRecord>> out = new TreeMap<String, Collection<OutputRecord>>();
    for (String recordName : bufferedData.keySet()) {
      RecordMap recordMap = bufferedData.get(recordName);
      synchronized (recordMap) {
        List<OutputRecord> records = new ArrayList<OutputRecord>();
        Set<Entry<TagMap, MetricMap>> entrySet = recordMap.entrySet();
        for (Entry<TagMap, MetricMap> entry : entrySet) {
          OutputRecord outRec = new OutputRecord(entry.getKey(), entry.getValue());
          records.add(outRec);
        }
        out.put(recordName, records);
      }
    }
    return out;
  }
1354302
private int getNextAvailDirInTier(StorageTierView tierView, long blockSize) {
    int dirViewIndex = mTierAliasToLastDirMap.get(tierView.getTierViewAlias());
    for (int i = 0; i < tierView.getDirViews().size(); i++) { // try this many times
      dirViewIndex = (dirViewIndex + 1) % tierView.getDirViews().size();
      if (tierView.getDirView(dirViewIndex).getAvailableBytes() >= blockSize) {
        return dirViewIndex;
      }
    }
    return -1;
  }
352860
public static <K, V> Map<K, V> asDeepTierMap(Map<K, V> map) {
        return from(map).deepLook().tierKey().map();
    }
536511
public Map<String, List<String>> getHeaders() {
        if (headers == null) {
            return null;
        }
        return headers.toMultimap();
    }
170751
public Collection<V> values() {
       Set<Map.Entry<K, V>> s = entrySet();
       ArrayList l = new ArrayList(s.size());
       for (Map.Entry e : s) 
           l.add(e.getValue());
       return l;
    }


    /**
     * Return a filtered set of keys.
     * @see Map.keySet
     */
    public Set<K> keySet() {
       Set<Map.Entry<K, V>> s = entrySet();
       HashSet keys = new HashSet(s.size());
       for (Map.Entry e : mBackingMap.entrySet())
           keys.add(e.getKey());
       return keys;
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.clear()
     */
    public void clear() { 
        mBackingMap.clear(); 
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.containsKey
     */
    public boolean containsKey(Object key) { 
        return mBackingMap.containsKey(key); 
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.containsValue
     */
    public boolean containsValue(Object value) {
       return mBackingMap.containsValue(value);
    }

    
    /**
     * Delegates to backing map.
     * @see Object.equals.
     */
    public boolean equals(Object o) {
       return mBackingMap.equals(o);
    }


    /**
     * Delegates to backing map.
     * @see Object.hashCode
     */
    public int hashCode() {
       return mBackingMap.hashCode();
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.get
     */
    public V get(Object key) {
       return mBackingMap.get(key);
    }

    
    /**
     * Delegates to backing map.
     * @see java.util.Map.isEmpty
     */
    public boolean isEmpty() {
       return mBackingMap.isEmpty();
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.put
     */
    public V put(K key, V value) {
        return mBackingMap.put(key, value);
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.putAll
     */
    public void putAll(Map<? extends K,? extends V> m) {
        mBackingMap.putAll(m);
    }
    

    /**
     * Delegates to backing map.
     * @see java.util.Map.remove
     */
    public V remove(Object key) {
        return mBackingMap.remove(key);
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.size
     */
    public int size() {
        return mBackingMap.size();
    }


    /**
     * Filter interface.
     */
    public interface Filter {
        /**
         * Returns true if the given entry should be included.
         */
        public boolean accept(Map.Entry e);
    }


}
183406
public Map<String, Object> asMap() {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("statusCode", statusCode);
        map.put("statusMessage", statusMessage);
        map.put("requestMethod", requestMethod);
        map.put("requestUri", requestUri);

        if (!StringUtils.isNullOrEmpty(message)) {
            map.put("message", message);
        }
        if (!StringUtils.isNullOrEmpty(stacktrace)) {
            map.put("stacktrace", stacktrace);
        }

        return map;
    }
821634
@Override
    public Iterator<T> iterator() {
        if (m_items == null) {
            m_items = new TreeMap<String, T>();
        }
        return m_items.values().iterator();
    }
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;
  }
441694
@Override
    public Map<String, List<String>> headers() {
        if (headers != null) {
            return headers;
        }
        headers = new HashMap<>();
        final MultiMap requestHeaders = request.headers();
        Set<String> names = requestHeaders.names();
        for (String name : names) {
            headers.put(name, requestHeaders.getAll(name));
        }
        return headers;
    }
921220
public java.util.Map<java.lang.String, alluxio.grpc.TierList> getAddedBlocksOnTiersMap() {
    return internalGetAddedBlocksOnTiers().getMap();
  }
1079206
public java.lang.String getTierAlias() {
    java.lang.Object ref = tierAlias_;
    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()) {
        tierAlias_ = s;
      }
      return s;
    }
  }