Java TreeMultimap.entries方法代码示例

import com.google.common.collect.TreeMultimap; //导入方法依赖的package包/类
@Override
public String visitObjectLiteral(ObjectLiteral node, Void context) {
    StringBuilder builder = new StringBuilder("{");
    boolean first = true;
    TreeMultimap<String, Expression> sorted = TreeMultimap.create(
            Ordering.natural().nullsLast(),
            Ordering.usingToString().nullsLast()
    );
    sorted.putAll(node.values());
    for (Map.Entry<String, Expression> entry : sorted.entries()) {
        if (!first) {
            builder.append(", ");
        } else {
            first = false;
        }
        builder.append(formatIdentifier(entry.getKey()))
               .append("= ")
               .append(entry.getValue().accept(this, context));

    }
    return builder.append("}").toString();
}
 

import com.google.common.collect.TreeMultimap; //导入方法依赖的package包/类
private InternalRequestContext getRequestContextFromMap(TreeMultimap<Calendar, ItemInfo> versionsItems,
        StoringRepo repo, InternalRequestContext requestContext, ModuleInfo originalModuleInfo,
        boolean searchForReleaseVersion) {
    RepositoryService repositoryService = ContextHelper.get().getRepositoryService();
    for (Map.Entry<Calendar, ItemInfo> entry : versionsItems.entries()) {
        ItemInfo item = entry.getValue();
        if (!item.isFolder()) {
            ModuleInfo itemModuleInfo = repositoryService.getItemModuleInfo(item.getRepoPath());
            boolean isIntegration = itemModuleInfo.isIntegration();
            boolean matchReleaseSearch = searchForReleaseVersion && !isIntegration;
            boolean matchIntegrationSearch = !searchForReleaseVersion && isIntegration;
            if (itemModuleInfo.isValid() && (matchReleaseSearch || matchIntegrationSearch)) {
                if (areModuleInfosTheSame(originalModuleInfo, itemModuleInfo) && isPropertiesMatch(item,
                        requestContext.getProperties())) {
                    return translateRepoRequestContext(requestContext, repo, item.getRelPath());
                }
            }
        }
    }

    return requestContext;
}
 

import com.google.common.collect.TreeMultimap; //导入方法依赖的package包/类
/**
 * Return a polygon which is the union of the given polygons; combines
 * vertices that form edges that are almost identical, as defined by
 * vertexMergeRadius. Note: clears the List!
 */
public static S2Polygon destructiveUnionSloppy(
    List<S2Polygon> polygons, S1Angle vertexMergeRadius) {
  // Effectively create a priority queue of polygons in order of number of
  // vertices. Repeatedly union the two smallest polygons and add the result
  // to the queue until we have a single polygon to return.

  // map: # of vertices -> polygon
  TreeMultimap<Integer, S2Polygon> queue = TreeMultimap.create();

  for (S2Polygon polygon : polygons) {
    queue.put(polygon.getNumVertices(), polygon);
  }
  polygons.clear();

  Set<Map.Entry<Integer, S2Polygon>> queueSet = queue.entries();
  while (queueSet.size() > 1) {
    // Pop two simplest polygons from queue.
    queueSet = queue.entries();
    Iterator<Map.Entry<Integer, S2Polygon>> smallestIter = queueSet.iterator();

    Map.Entry<Integer, S2Polygon> smallest = smallestIter.next();
    int aSize = smallest.getKey().intValue();
    S2Polygon aPolygon = smallest.getValue();
    smallestIter.remove();

    smallest = smallestIter.next();
    int bSize = smallest.getKey().intValue();
    S2Polygon bPolygon = smallest.getValue();
    smallestIter.remove();

    // Union and add result back to queue.
    S2Polygon unionPolygon = new S2Polygon();
    unionPolygon.initToUnionSloppy(aPolygon, bPolygon, vertexMergeRadius);
    int unionSize = aSize + bSize;
    queue.put(unionSize, unionPolygon);
    // We assume that the number of vertices in the union polygon is the
    // sum of the number of vertices in the original polygons, which is not
    // always true, but will almost always be a decent approximation, and
    // faster than recomputing.
  }

  if (queue.isEmpty()) {
    return new S2Polygon();
  } else {
    return queue.get(queue.asMap().firstKey()).first();
  }
}