Example usage for com.google.common.collect SetMultimap size

Introduction

In this page you can find the example usage for com.google.common.collect SetMultimap size.

Prototype

int size();

Source Link

Document

Returns the number of key-value pairs in this multimap.

Usage

From source file:com.google.javascript.refactoring.testing.SuggestedFixes.java

private static void assertReplacements(SuggestedFix fix, Set<CodeReplacement> expectedReplacements) {
    SetMultimap<String, CodeReplacement> replacementMap = fix.getReplacements();
    assertEquals(1, replacementMap.size());
    Set<CodeReplacement> replacements = replacementMap.get("test");
    assertThat(replacements).hasSize(expectedReplacements.size());
    assertEquals(expectedReplacements, replacements);
}

---

From source file:es.usc.citius.composit.core.composition.search.CompositSearch.java

public static <E, T extends Comparable<T>> Algorithms.Search<State<E>, HeuristicNode<State<E>, Double>> create(
        final ServiceMatchNetwork<E, T> network) {

    TransitionFunction<State<E>> tf = new TransitionFunction<State<E>>() {
        @Override/*from w w w. jav a2 s  .  c  om*/
        public Iterable<? extends Transition<State<E>>> from(State<E> current) {
            log.debug("> Computing successors of the state at level {}, with {} services: {}", current.level,
                    current.countServices(), current.getStateOperations());
            // Get all required inputs (inputs from all services in this state)
            Set<E> inputs = Operations.inputs(current.getStateOperations());
            log.debug("\t- {} unsolved inputs in current state: {}", inputs.size(), inputs);
            SetMultimap<Operation<E>, E> providers = calculateProviders(inputs, current.level, network);
            log.debug("\t- {} relevant operations found for the unsolved inputs: (service => input) {}",
                    providers.size(), providers);
            SetMultimap<Set<E>, Operation<E>> groups = group(providers);
            log.debug("\t- {} groups generated based on the inputs matched: {}", groups.size(), groups);
            Set<Set<Operation<E>>> result = combine(groups);
            log.debug("\t- {} optimal successor states found that isExecutable the unsolved inputs: {}",
                    result.size(), result);
            // Generate new states.
            result = nodeEquivalence(result, network);
            //log.debug("\t- {} non-equivalent unique successor after node equivalence: {}", result.size(), result);
            Set<State<E>> neighbors = new HashSet<State<E>>();
            for (Set<Operation<E>> combination : result) {
                // Create the new state
                if (!combination.isEmpty()) {
                    neighbors.add(new State<E>(combination, current.level - 1));
                }
            }
            return Transition.map(current, neighbors);
        }
    };
    // Define cost function
    CostFunction<State<E>, Double> cf = new CostFunction<State<E>, Double>() {
        @Override
        public Double evaluate(Transition<State<E>> transition) {
            return (double) transition.to().countServices();
        }
    };
    // Define heuristic function
    HeuristicFunction<State<E>, Double> hf = new HeuristicFunction<State<E>, Double>() {
        @Override
        public Double estimate(State<E> state) {
            // Get layer
            return (double) state.level;
        }
    };
    State<E> goal = new State<E>(Collections.singleton(network.getSource()),
            network.levelOf(network.getSource()));
    State<E> initial = new State<E>(Collections.singleton(network.getSink()),
            network.levelOf(network.getSink()));
    DefaultSearchProblem<State<E>> problem = new DefaultSearchProblem<State<E>>(initial, goal, tf, cf);
    problem.setHeuristicFunction(hf);
    return Algorithms.createAStar(problem);
}

---

From source file:com.addthis.hydra.query.MeshFileRefCache.java

/**
 * This method filters the file references to ensure that only valid file references are returned.
 * <p/>/* w  ww . ja v  a 2 s  .  co  m*/
 * The filter checks for two things.
 * <p/>
 * <ol>
 * <li>the last modified date for each file for the same task should be the same, if not it will take the
 * newest file</li>
 * <li>the size of the files should be equal, if not, take the files with the largest known size</li>
 * </ol>
 *
 * @param fileRefDataSet - the original unfiltered file reference set
 * @return - filtered file reference map containing only valid file references
 */
@Nonnull
protected static SetMultimap<Integer, FileReference> filterFileReferences(
        @Nonnull SetMultimap<Integer, FileReference> fileRefDataSet) {
    if (fileRefDataSet.isEmpty()) {
        return fileRefDataSet;
    }
    int baseKeySetSize = fileRefDataSet.keySet().size();
    SetMultimap<Integer, FileReference> filteredFileReferenceSet = HashMultimap.create(baseKeySetSize,
            fileRefDataSet.size() / baseKeySetSize);
    for (Map.Entry<Integer, Collection<FileReference>> entry : fileRefDataSet.asMap().entrySet()) {
        int key = entry.getKey();
        final Collection<FileReference> fileReferences = entry.getValue();
        long mostRecentTime = -1;

        for (FileReference fileReference : fileReferences) {
            if ((mostRecentTime < 0) || (fileReference.lastModified > mostRecentTime)) {
                mostRecentTime = fileReference.lastModified;
            }
        }

        final long mostRecentTimeF = mostRecentTime;
        Predicate<FileReference> isMostRecent = input -> (input != null)
                && (input.lastModified == mostRecentTimeF);

        Collection<FileReference> filteredFileReferences = Collections2.filter(fileReferences, isMostRecent);
        filteredFileReferenceSet.putAll(key, filteredFileReferences);
    }
    return filteredFileReferenceSet;
}

---

From source file:org.eclipse.sw360.commonIO.ConvertRecord.java

@NotNull
public static <T, U> List<List<String>> serialize(SetMultimap<T, U> aToB, List<String> headers) {
    final List<List<String>> mapEntryList = new ArrayList<>(aToB.size() + 1);

    mapEntryList.add(headers);/*from   w w w.ja  va  2s  .  c om*/

    for (Map.Entry<T, U> mapEntry : aToB.entries()) {
        final ArrayList<String> entry = new ArrayList<>(2);
        entry.add(mapEntry.getKey().toString());
        entry.add(mapEntry.getValue().toString());
        mapEntryList.add(entry);
    }
    return mapEntryList;
}

---

From source file:org.jboss.capedwarf.search.CapedwarfSchema.java

public Schema buildSchema() {
    final Schema.Builder builder = Schema.newBuilder();
    final SetMultimap<String, Field.FieldType> fields = InfinispanUtils.submit(appId, CacheName.DIST,
            new GetFieldsTask(schemaName), schemaName);
    if (fields != null && fields.size() > 0) {
        for (Map.Entry<String, Field.FieldType> entry : fields.entries()) {
            builder.addTypedField(entry.getKey(), entry.getValue());
        }//from   ww w . j av  a2s.  c o m
    }
    return builder.build();
}

---

From source file:com.mgmtp.perfload.core.client.web.request.HttpRequestHandler.java

/**
 * Transforms the map of headers from the request template into a {@link NameValuePair} array
 * for use with the {@link HttpClient}./*w  ww .  j ava 2 s .c o  m*/
 * 
 * @param headers
 *            the request headers
 * @return the array of request headers for the HttpClient
 */
protected Header[] transformRequestHeaders(final SetMultimap<String, String> headers) {
    Header[] headersArray = new Header[headers.size()];

    int i = 0;
    for (Entry<String, String> entry : headers.entries()) {
        headersArray[i++] = new BasicHeader(entry.getKey(), entry.getValue());
    }

    return headersArray;
}

---

From source file:eu.esdihumboldt.hale.ui.style.handler.TypeStyleHandler.java

/**
 * @see IHandler#execute(ExecutionEvent)
 *//*from w  w w.j  a va  2s .  c o  m*/
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {

    // collect types and associated data sets
    SetMultimap<DataSet, TypeDefinition> types = collectTypesFromSelection(event);

    Pair<TypeDefinition, DataSet> typeInfo = null;

    // select a type
    if (types.size() == 1) {
        Entry<DataSet, TypeDefinition> entry = types.entries().iterator().next();
        typeInfo = new Pair<TypeDefinition, DataSet>(entry.getValue(), entry.getKey());
    } else if (!types.isEmpty()) {
        // choose through dialog
        DataSetTypeSelectionDialog dialog = new DataSetTypeSelectionDialog(
                Display.getCurrent().getActiveShell(), "Multiple types: select which to change the style for",
                null, types);
        if (dialog.open() == DataSetTypeSelectionDialog.OK) {
            typeInfo = dialog.getObject();
        }
    }

    if (typeInfo != null) {
        try {
            FeatureStyleDialog dialog = new FeatureStyleDialog(typeInfo.getFirst(), typeInfo.getSecond());
            dialog.setBlockOnOpen(false);
            dialog.open();
        } catch (Exception e) {
            throw new ExecutionException("Could not open style dialog", e);
        }
    }
    return null;
}

---

From source file:com.mgmtp.perfload.core.client.web.request.HttpRequestHandler.java

/**
 * Transforms the map of parameters from the request template into a {@link NameValuePair} array
 * for use with the {@link HttpClient}./*www  .  j a va2s  . c o  m*/
 * 
 * @param parameters
 *            the request parameters
 * @return the list of request parameters for the HttpClient
 */
protected List<NameValuePair> transformRequestParams(final SetMultimap<String, String> parameters) {
    List<NameValuePair> paramPairs = newArrayListWithCapacity(parameters.size());

    for (Entry<String, String> entry : parameters.entries()) {
        paramPairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    }

    return paramPairs;
}

---

From source file:edu.cmu.lti.oaqa.baseqa.providers.ml.classifiers.MekaProvider.java

@Override
public void train(List<Map<String, Double>> X, List<String> Y, boolean crossValidation)
        throws AnalysisEngineProcessException {
    // create attribute (including label) info
    ArrayList<Attribute> attributes = new ArrayList<>();
    List<String> labelNames = ClassifierProvider.labelNames(Y);
    labelNames.stream().map(attr -> new Attribute(attr, Arrays.asList("y", "n")))
            .forEachOrdered(attributes::add);
    List<String> featureNames = ClassifierProvider.featureNames(X);
    featureNames.stream().map(Attribute::new).forEachOrdered(attributes::add);
    String name = Files.getNameWithoutExtension(modelFile.getName());
    datasetSchema = new Instances(name, attributes, 0);
    datasetSchema.setClassIndex(labelNames.size());
    // add instances
    // due to the limitation of the interface definition, X, Y should be reorganized
    SetMultimap<Map<String, Double>, String> XY = HashMultimap.create();
    IntStream.range(0, X.size()).forEach(i -> XY.put(X.get(i), Y.get(i)));
    Instances trainingInstances = new Instances(datasetSchema, XY.size());
    for (Map.Entry<Map<String, Double>, Collection<String>> entry : XY.asMap().entrySet()) {
        Set<String> y = ImmutableSet.copyOf(entry.getValue());
        Map<String, Double> x = entry.getKey();
        SparseInstance instance = new SparseInstance(labelNames.size() + x.size());
        for (String labelName : labelNames) {
            instance.setValue(datasetSchema.attribute(labelName), y.contains(labelName) ? "y" : "n");
        }//  ww w . j av a  2s  .  c  om
        for (Map.Entry<String, Double> e : x.entrySet()) {
            instance.setValue(datasetSchema.attribute(e.getKey()), e.getValue());
        }
        trainingInstances.add(instance);
    }
    // training
    try {
        classifier = (MultiLabelClassifier) AbstractClassifier.forName(classifierName, options);
        classifier.buildClassifier(trainingInstances);
    } catch (Exception e) {
        throw new AnalysisEngineProcessException(e);
    }
    try {
        SerializationHelper.write(modelFile.getAbsolutePath(), classifier);
        SerializationHelper.write(datasetSchemaFile.getAbsolutePath(), datasetSchema);
    } catch (Exception e) {
        throw new AnalysisEngineProcessException(e);
    }
    if (crossValidation) {
        try {
            Evaluation eval = new Evaluation(trainingInstances);
            Random rand = new Random();
            eval.crossValidateModel(classifier, trainingInstances, 10, rand);
            LOG.debug(eval.toSummaryString());
        } catch (Exception e) {
            throw new AnalysisEngineProcessException(e);
        }
    }
}

---

From source file:com.jivesoftware.os.amza.service.AmzaRingStoreWriter.java

private void buildRandomSubRing(byte[] ringName, int desiredRingSize) throws Exception {
    if (ringName == null) {
        throw new IllegalArgumentException("ringName cannot be null.");
    }/*from   www.  java2  s .c  om*/
    RingTopology systemRing = ringStoreReader.getRing(AmzaRingReader.SYSTEM_RING, 0);
    if (systemRing.entries.size() < desiredRingSize) {
        throw new IllegalStateException(
                "Current 'system' ring is not large enough to support a ring of size:" + desiredRingSize);
    }

    SetMultimap<String, RingMemberAndHost> subRackMembers = HashMultimap.create();
    RingTopology subRing = ringStoreReader.getRing(ringName, 0);
    for (RingMemberAndHost entry : subRing.entries) {
        String rack = rackDistributionEnabled ? entry.ringHost.getRack() : "";
        subRackMembers.put(rack, entry);
    }

    Map<String, List<RingMemberAndHost>> systemRackMembers = new HashMap<>();
    for (RingMemberAndHost entry : systemRing.entries) {
        String rack = rackDistributionEnabled ? entry.ringHost.getRack() : "";
        systemRackMembers.computeIfAbsent(rack, (key) -> new ArrayList<>()).add(entry);
    }

    Random random = new Random(new Random(Arrays.hashCode(ringName)).nextLong());
    for (List<RingMemberAndHost> rackMembers : systemRackMembers.values()) {
        Collections.shuffle(rackMembers, random);
    }

    List<String> racks = new ArrayList<>(systemRackMembers.keySet());

    while (subRackMembers.size() < desiredRingSize) {
        Collections.sort(racks,
                (o1, o2) -> Integer.compare(subRackMembers.get(o1).size(), subRackMembers.get(o2).size()));
        boolean advanced = false;
        for (String cycleRack : racks) {
            List<RingMemberAndHost> rackMembers = systemRackMembers.get(cycleRack);
            if (!rackMembers.isEmpty()) {
                subRackMembers.put(cycleRack, rackMembers.remove(rackMembers.size() - 1));
                advanced = true;
                break;
            }
        }
        if (!advanced) {
            break;
        }
    }

    setInternal(ringName, Iterables.transform(subRackMembers.values(), input -> input.ringMember));
}

---

• «
• 1
• 2
• »