java类com.google.common.collect.LinkedHashMultimap的实例源码

/**
 * Get a string containing the degrees of identified subgraphs and how many subgraphs exist for
 * a specific degree.
 *
 * @param vpmGraph
 *            The graph to analyze the subgraphs for.
 * @return The formated string of degree statistics [Size:SubGraphCount].
 */
private String getNodeDegrees(VPMGraph vpmGraph) {

    LinkedHashMultimap<Integer, Node> degreeStatistics = LinkedHashMultimap.create();
    for (Node node : vpmGraph.getNodeSet()) {
        degreeStatistics.get(node.getDegree()).add(node);
    }

    StringBuilder degreePrint = new StringBuilder();
    List<Integer> degrees = Lists.newLinkedList(degreeStatistics.keySet());
    Collections.sort(degrees);
    for (Integer degree : degrees) {
        if (degreePrint.length() > 0) {
            degreePrint.append("|");
        }
        degreePrint.append(degree + ":" + degreeStatistics.get(degree).size());
    }
    return degreePrint.toString();
}

@Override
public IndirectParamsInfo exec(SoyNode node) {

  Preconditions.checkArgument(node instanceof TemplateNode);

  isStartOfPass = true;
  visitedCallSituations = Sets.newHashSet();
  currTemplate = null;
  callerStack = new ArrayDeque<>();
  callerStack.add(
      new CallerFrame(null, ImmutableSet.<TemplateNode>of(), ImmutableSet.<String>of()));
  indirectParams = Maps.newHashMap();
  paramKeyToCalleesMultimap = HashMultimap.create();
  indirectParamTypes = LinkedHashMultimap.create();
  mayHaveIndirectParamsInExternalCalls = false;
  mayHaveIndirectParamsInExternalDelCalls = false;

  visit(node);

  return new IndirectParamsInfo(
      ImmutableSortedMap.copyOf(indirectParams),
      paramKeyToCalleesMultimap,
      ImmutableMultimap.copyOf(indirectParamTypes),
      mayHaveIndirectParamsInExternalCalls,
      mayHaveIndirectParamsInExternalDelCalls);
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

public Metadata() {
    mIdentifiers = Lists.newArrayList();
    mTitles = Lists.newArrayList();
    mLanguages = Lists.newArrayList();
    mContributors = Lists.newArrayList();
    mAuthors = Lists.newArrayList();
    mCoverages = Lists.newArrayList();
    mDescriptions = Lists.newArrayList();
    mFormats = Lists.newArrayList();
    mPublishers = Lists.newArrayList();
    mRelations = Lists.newArrayList();
    mRightses = Lists.newArrayList();
    mSubjects = Lists.newArrayList();
    mLinks = Lists.newArrayList();
    mMetas = LinkedHashMultimap.create();
    mMeta20s = Lists.newArrayList();
}

public Optional<? extends Iterable<HDLFunction>> resolveFunctionCall(HDLFunctionCall call, HDLQualifiedName funcName) {
    if (funcCache == null) {
        synchronized (this) {
            final HDLFunction[] funcDecl = resolveTo.getAllObjectsOf(HDLFunction.class, false);
            funcCache = LinkedHashMultimap.create();
            for (final HDLFunction hdlfuncDeclaration : funcDecl) {
                funcCache.put(fullNameOf(hdlfuncDeclaration), hdlfuncDeclaration);
            }
        }
    }
    // XXX Check if the qualifier does either match the pkg name, or is not
    // existant
    final Iterable<HDLFunction> checkCache = checkCache(funcName, funcCache);
    if ((checkCache != null) && checkCache.iterator().hasNext()) {
        return Optional.of(checkCache);
    }
    if ((resolveContainer == null) || !descent) {
        return Optional.absent();
    }
    return ScopingExtension.INST.resolveFunctionCall(resolveContainer, call, funcName);
}

@Test
public void testMakeTurn_OtherSuitInsteadOfTrump() throws Exception {
    handCardMultimap = LinkedHashMultimap.create();
    handCardMultimap.put(SOUTH, CLUB_ACE);
    handCardMultimap.put(WEST, HEART_JACK);
    handCardMultimap.put(WEST, SPADE_ACE);

    player = buildPlayer(name, description, Players.THREE, widow, handContractMap, SOUTH, handCardMultimap);

    player.makeTurn(CLUB_ACE);
    try {
        player.makeTurn(HEART_JACK);
        fail("IllegalSuitException must have been thrown!");
    } catch (IllegalSuitException e) {
        assertThat(e.getActualSuit(), equalTo(Suit.HEART));
        assertThat(e.getExpectedSuit(), equalTo(Suit.SPADE));
    }
}

@Test
public void testMakeTurn_OtherSuitWhenNoTrumpGame() throws Exception {
    handContractMap = ImmutableMap.of(
        EAST, Contract.PASS,
        SOUTH, Contract.SIX_NO_TRUMP,
        WEST, Contract.WHIST
    );

    handCardMultimap = LinkedHashMultimap.create();
    handCardMultimap.put(SOUTH, CLUB_ACE);
    handCardMultimap.put(WEST, HEART_JACK);
    handCardMultimap.put(WEST, SPADE_ACE);

    player = buildPlayer(name, description, Players.THREE, widow, handContractMap, SOUTH, handCardMultimap);

    player.makeTurn(CLUB_ACE);
    player.makeTurn(HEART_JACK);
}

private LinkedHashMultimap<Hand, Card> buildHandCardMultimap() {
    LinkedHashMultimap<Hand, Card> multimap = LinkedHashMultimap.create();

    multimap.put(EAST, CLUB_8);
    multimap.put(EAST, SPADE_8);
    multimap.put(EAST, DIAMOND_7);
    multimap.put(EAST, DIAMOND_8);

    multimap.put(SOUTH, CLUB_ACE);
    multimap.put(SOUTH, CLUB_KING);
    multimap.put(SOUTH, DIAMOND_9);
    multimap.put(SOUTH, DIAMOND_10);

    multimap.put(WEST, CLUB_JACK);
    multimap.put(WEST, CLUB_9);
    multimap.put(WEST, HEART_JACK);
    multimap.put(WEST, DIAMOND_JACK);
    multimap.put(WEST, DIAMOND_QUEEN);

    return multimap;
}