Example usage for org.apache.commons.collections15 Bag getCount

List of usage examples for org.apache.commons.collections15 Bag getCount

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections15.*
  5. Bag
  6. getCount

Introduction

In this page you can find the example usage for org.apache.commons.collections15 Bag getCount.

Prototype

int getCount(E object);

Source Link

Document

Returns the number of occurrences (cardinality) of the given object currently in the bag.

Usage

From source file:de.dhke.projects.cutil.collections.aspect.AspectMultiMapValueCollectionTest.java

/**
 * Test of iterator method, of class AspectMultiMapValueCollection.
 *///w ww . ja  v a  2 s  . c  o m
@Test
public void testIterator() {
    _aspectMap.put("_", "a");
    Bag<String> values = new HashBag<>();
    Iterator<String> iter = _values.iterator();
    while (iter.hasNext())
        values.add(iter.next());
    assertEquals(2, values.getCount("a"));
    assertEquals(1, values.getCount("A"));
    assertEquals(1, values.getCount("b"));
    assertEquals(1, values.getCount("B"));
    assertEquals(1, values.getCount("c"));
    assertEquals(1, values.getCount("C"));
    assertEquals(0, values.getCount("d"));
    assertEquals(0, values.getCount("D"));
    assertEquals(_values.size(), values.size());
}

From source file:com.diversityarrays.kdxplore.importdata.bms.BmsExcelImportCallable.java

public void report(PrintStream ps) {

    ps.println("Collected " + plots.size() + " plots");

    Bag<String> plotTypeCounts = new HashBag<>();
    for (Plot plot : plots) {
        plotTypeCounts.add(plot.getPlotType());
    }/* ww  w  . jav  a  2 s .  co m*/

    ps.println("Found PlotTypes:");
    for (String plotType : plotTypeCounts.uniqueSet()) {
        ps.println("\t" + plotType + ": " + plotTypeCounts.getCount(plotType));
    }

    ps.println("Created " + traitByName.size() + " Traits");
    for (Trait trait : traitByName.values()) {
        ps.println("\t" + trait + " [id=" + trait.getTraitId() + "]");

    }

    ps.println("Created " + plotAttributeByName.size() + " Plot Attributes");
    for (PlotAttribute pa : plotAttributeByName.values()) {
        ps.println("\t" + pa);
    }

    ps.println("Created " + nPlotAttributeValues + " Plot Attribute Values");
    ps.println("Created " + nSamples + " Samples");

    if (!lineNumbersByMessage.isEmpty()) {
        ps.println("Warnings:");
        for (String msg : lineNumbersByMessage.keySet()) {
            Set<Integer> range = lineNumbersByMessage.get(msg);
            ps.println(range.size() + " times: " + msg);
        }
    }
}

From source file:com.diversityarrays.kdxplore.curate.TraitsAndInstancesPanel2.java

@SuppressWarnings({ "rawtypes", "unchecked" })
private void describe(StringBuilder html, String which, Bag outliers) {
    html.append(which);/*w  w  w .  jav a  2s. c o  m*/
    if (Check.isEmpty(outliers)) {
        html.append("<BR>").append("None");
    } else {
        for (Object t : outliers.uniqueSet()) {
            html.append("<BR>").append(t);

            int count = outliers.getCount(t);
            if (count > 1) {
                html.append(" (").append(count).append(')');
            }
        }
    }
}

From source file:com.diversityarrays.kdxplore.trials.TrialOverviewPanel.java

private void doAddTraitInstances(Trial selectedTrial, Map<Trait, List<Integer>> instanceNumbersByTrait)
        throws IOException {

    List<Trait> unusedTraits = offlineData.getKdxploreDatabase().getAllTraits();

    Map<Integer, Trait> traitById = unusedTraits.stream()
            .collect(Collectors.toMap(Trait::getTraitId, Function.identity()));

    List<TraitInstance> instances = this.getAllTraitInstances(selectedTrial);

    Map<Trait, Integer> instancesByTrait = new HashMap<>();
    for (TraitInstance ti : instances) {
        Trait trait = traitById.get(ti.getTraitId());

        Integer inst = instancesByTrait.get(trait);
        if (inst == null) {
            inst = ti.getInstanceNumber();
        } else {/*from  w ww.  j a v a 2s  .  com*/
            inst++;
        }
        instancesByTrait.put(trait, inst);
    }

    for (Trait trait : instanceNumbersByTrait.keySet()) {
        List<Integer> newInstances = instanceNumbersByTrait.get(trait);

        if (!Check.isEmpty(newInstances)) {
            Integer currentCount = instancesByTrait.get(trait);

            if (currentCount != null) {
                List<Integer> toUse = new ArrayList<>();
                newInstances.stream().forEach(i -> toUse.add(i += currentCount));
                instanceNumbersByTrait.put(trait, toUse);
            }
        }
    }

    if (instanceNumbersByTrait.isEmpty()) {
        return;
    }

    int trialId = selectedTrial.getTrialId();

    int maxSso = 0;
    Bag<Integer> ssoUseCount = new HashBag<>();

    Map<Trait, Integer> traitSsoMap = trialTraitsTableModel.getTraitsSsoForTrial(selectedTrial);
    if (!Check.isEmpty(traitSsoMap)) {
        for (Integer sso : traitSsoMap.values()) {
            if (sso != null) {
                maxSso = Math.max(maxSso, sso);
                ssoUseCount.add(sso);
            }
        }
    }

    TraitNameStyle traitNameStyle = selectedTrial.getTraitNameStyle();

    final int firstInstanceNumber = traitNameStyle.getFirstInstanceNumber();

    int maxSsoIncrement = 1;
    if (ssoUseCount.uniqueSet().size() == 1 && maxSso == 0 && ssoUseCount.getCount(maxSso) > 1) {
        // Special hack for Trials that haven't yet been "sorted".
        // (i.e. all the SSOs are the same value
        maxSsoIncrement = 0;
    }

    List<Trait> ignored = new ArrayList<>();
    Map<TraitLevel, List<TraitInstance>> instancesByLevel = new HashMap<>();
    boolean multipleTraitInstances = false;

    Set<TraitInstance> traitInstances = new LinkedHashSet<>();
    for (Trait trait : instanceNumbersByTrait.keySet()) {

        switch (trait.getTraitLevel()) {
        case PLOT:
        case SPECIMEN:
            break;
        default:
            ignored.add(trait);
            continue;
        }
        maxSso += maxSsoIncrement;

        List<Integer> instancesNumbersWanted = instanceNumbersByTrait.get(trait);
        if (instancesNumbersWanted.size() > 1) {
            multipleTraitInstances = true;
        }

        for (Integer instanceNumber : instancesNumbersWanted) {
            TraitInstance ti = new TraitInstance();
            //                if (firstInstanceNumber <= 0) {
            //                    ti.setInstanceNumber(instanceNumber - 1);
            //                }
            //                else {
            ti.setInstanceNumber(instanceNumber);
            //                }
            ti.setScoringSortOrder(maxSso);
            ti.setTraitId(trait.getTraitId());
            ti.setTrialId(trialId);
            ti.setUsedForScoring(true);

            traitInstances.add(ti);

            List<TraitInstance> list = instancesByLevel.get(trait.getTraitLevel());
            if (list == null) {
                list = new ArrayList<>();
                instancesByLevel.put(trait.getTraitLevel(), list);
            }
            list.add(ti);
        }
    }

    KdxploreDatabase kdxdb = offlineData.getKdxploreDatabase();
    KDSmartDatabase kdsdb = kdxdb.getKDXploreKSmartDatabase();

    Map<Integer, DeviceIdentifier> devidMap = kdxdb.getDeviceIdentifierMap();
    Optional<DeviceIdentifier> opt_devid = devidMap.values().stream()
            .filter(devid -> DeviceType.EDITED.equals(devid.getDeviceType())).findFirst();

    List<KdxSample> samples;
    if (opt_devid.isPresent()) {
        DeviceIdentifier curated = opt_devid.get();
        List<SampleGroup> sampleGroups = kdxdb.getSampleGroups(trialId,
                KdxploreDatabase.WithSamplesOption.WITH_SAMPLES);
        int curatedSampleGroupId = curated.getDeviceIdentifierId();

        Optional<SampleGroup> opt_sg = sampleGroups.stream()
                .filter(sg -> curatedSampleGroupId == sg.getDeviceIdentifierId()).findFirst();
        if (opt_sg.isPresent()) {
            samples = new ArrayList<>();

            List<TraitInstance> plotInstances = instancesByLevel.get(TraitLevel.PLOT);
            List<TraitInstance> subPlotInstances = instancesByLevel.get(TraitLevel.SPECIMEN);

            Consumer<KdxSample> sampleConsumer = new Consumer<KdxSample>() {
                @Override
                public void accept(KdxSample sample) {
                    samples.add(sample);
                }
            };
            TrialItemVisitor<Plot> plotVisitor = new TrialItemVisitor<Plot>() {
                @Override
                public void setExpectedItemCount(int count) {
                }

                @Override
                public boolean consumeItem(Plot plot) {
                    DatabaseUtil.createSamples(trialId, plot, curatedSampleGroupId, null, // previousSamplesByKey
                            plotInstances, subPlotInstances, sampleConsumer);
                    return true;
                }
            };

            kdsdb.visitPlotsForTrial(trialId, SampleGroupChoice.NO_TAGS_SAMPLE_GROUP,
                    KDSmartDatabase.WithPlotAttributesOption.WITHOUT_PLOT_ATTRIBUTES, plotVisitor);
        } else {
            samples = null;
        }
    } else {
        samples = null;
    }

    BatchHandler<Void> batchHandler = new BatchHandler<Void>() {
        @Override
        public Void call() throws Exception {
            kdsdb.saveTraitInstances(traitInstances);
            if (!Check.isEmpty(samples)) {
                kdsdb.saveMultipleSamples(samples, false);
            }
            return null;
        }

        @Override
        public boolean checkSuccess(Void t) {
            return true;
        }
    };

    boolean saved = true;
    Either<Exception, Void> either = kdsdb.doBatch(batchHandler);
    if (either.isLeft()) {
        saved = false;
        MsgBox.error(TrialOverviewPanel.this, either.left(), "Database Error");
    }
    refreshTrialTableModel(offlineData.getKdxploreDatabase());

    trialTraitsTableModel.setSelectedTrial(selectedTrial);

    if (saved) {
        String prefix = multipleTraitInstances ? "Trait Instances Added:\n" : "Traits Added:\n";

        Function<Trait, String> nameFactory = new Function<Trait, String>() {
            @Override
            public String apply(Trait trait) {
                List<Integer> instanceNumbers = instanceNumbersByTrait.get(trait);
                if (instanceNumbers == null) {
                    return null;
                } else {
                    return instanceNumbers.stream().map(inum -> inum.toString())
                            .collect(Collectors.joining(",", trait.getTraitName() + ": ", ""));
                }
            }
        };

        String selection = instanceNumbersByTrait.keySet().stream().map(nameFactory).filter(n -> n != null)
                .collect(Collectors.joining("\n", prefix, "\n------")); //$NON-NLS-1$//$NON-NLS-2$

        messagePrinter.println(selection);

        if (samples != null) {
            messagePrinter.println("Samples Added: " + samples.size());
        }
    }
}

From source file:com.diversityarrays.kdxplore.trials.SampleGroupViewer.java

private String getBriefSummary(SampleGroup sampleGroup) throws IOException {
    Bag<Integer> plotIdsWithSpecimens = new HashBag<>();
    Set<Integer> plotIdsWithScores = new HashSet<>();
    int[] results = new int[3];
    java.util.function.Predicate<KdxSample> visitor = new java.util.function.Predicate<KdxSample>() {
        @Override//from  ww w  .j a va2s . c  o m
        public boolean test(KdxSample s) {
            plotIdsWithScores.add(s.getPlotId());
            int snum = s.getSpecimenNumber();
            if (snum <= 0) {
                ++results[0]; // Plot level sample count
            } else {
                ++results[1]; // Individual level sample count
                plotIdsWithSpecimens.add(s.getPlotId());
                results[2] = Math.max(results[2], snum); // maximum specimen number
            }
            return true;
        }
    };

    boolean scored = true;
    kdxdb.visitKdxSamplesForSampleGroup(sampleGroup, KdxploreDatabase.SampleLevel.BOTH, scored, visitor);

    int nPlotSamples = results[0];
    int nSpecimenSamples = results[1];
    int totalScoredSamples = nPlotSamples + nSpecimenSamples;

    int maxSpecimenNumber = results[2];

    int nPlotsWithSpecimens = plotIdsWithSpecimens.size();
    int nPlotsWithScores = plotIdsWithScores.size();

    int maxCount = 0;
    for (Integer plotId : plotIdsWithSpecimens.uniqueSet()) {
        int count = plotIdsWithSpecimens.getCount(plotId);
        maxCount = Math.max(maxCount, count);
    }

    StringBuilder sb = new StringBuilder("<HTML>");

    sb.append("<br><B>Scored Samples:</b> ").append(totalScoredSamples);
    sb.append("<br><B>Plot Level Samples:</b> ").append(nPlotSamples);
    sb.append("<br><B>Individual Samples:</b> ").append(nSpecimenSamples);
    sb.append("<br>");
    sb.append("<br><B>Max Individual number:</b> ").append(maxSpecimenNumber);
    sb.append("<br><B># Plots with Individuals:</b> ").append(nPlotsWithSpecimens);
    sb.append("<br>");
    sb.append("<br><B># Plots with scored samples:</b> ").append(nPlotsWithScores);
    sb.append("<br><B>Max # individual scores per plot:</b> ").append(maxCount);

    return sb.toString();
}

From source file:com.diversityarrays.kdxplore.KDXploreFrame.java

private void initialiseKdxApps() throws IOException {

    String[] classNames = KdxploreConfig.getInstance().getMainPluginClassNames();
    if (classNames != null && classNames.length > 0) {
        List<String> classNamesToLoad = new ArrayList<>();
        Collections.addAll(classNamesToLoad, classNames);
        if (!classNamesToLoad.contains(OFFLINE_DATA_APP_SERVICE_CLASS_NAME)) {
            classNamesToLoad.add(0, OFFLINE_DATA_APP_SERVICE_CLASS_NAME);
            classNames = classNamesToLoad.toArray(new String[classNamesToLoad.size()]);
        }//from  w w  w  .  j  a  v  a  2s  .  com
    }

    Map<KdxApp, Component> componentByApp = collectKdxApps(classNames);

    appByComponent.clear();
    for (KdxApp app : componentByApp.keySet()) {
        Component comp = componentByApp.get(app);
        if (comp != null) {
            appByComponent.put(comp, app);
        }
    }

    allKdxApps.clear();
    allKdxApps.addAll(componentByApp.keySet());

    // Initialise the apps in initialisation order.
    allKdxApps.sort(Comparator.comparing(KdxApp::getInitialisationOrder));

    // And while we're initialising them we collect
    // those that can perform a databaseBackup (i.e. have a BackupProvider).
    backupProviders.clear();
    List<KdxApp> wantedAppsWithUi = new ArrayList<>();

    for (KdxApp app : allKdxApps) {
        BackupProvider bp = app.getBackupProvider();
        if (bp != null) {
            backupProviders.add(bp);
        }

        /**
         * See {@link com.diversityarrays.kdxplore.prefs.KdxplorePreferences#SHOW_ALL_APPS}
         */
        if (appIsWanted(app)) {
            try {
                app.initialiseAppBeforeUpdateCheck(appInitContext);
            } catch (Exception e) {
                String msg = Msg.MSG_KDXAPP_INIT_PROBLEM(app.getAppName());
                Shared.Log.w(TAG, msg, e);
                messagesPanel.println(msg);
                messagesPanel.println(e.getMessage());
            }
        }

        if (appIsWanted(app) && null != componentByApp.get(app)) {
            wantedAppsWithUi.add(app);
        }
    }

    // - - - - - - - - - - - - - - - - - - - - -
    // Display the apps in display order.
    wantedAppsWithUi.sort(Comparator.comparing(KdxApp::getDisplayOrder));
    backupProviders.sort(Comparator.comparing(BackupProvider::getDisplayOrder));

    switch (wantedAppsWithUi.size()) {
    case 0:
        JLabel label = new JLabel(Msg.MSG_NO_KDXPLORE_APPS_AVAILABLE());
        label.setHorizontalAlignment(JLabel.CENTER);
        cardPanel.add(label, CARD_KDXAPPS);
        break;
    case 1:
        KdxApp kdxApp = wantedAppsWithUi.get(0);
        Component uiComponent = componentByApp.get(kdxApp);

        Component appComponent = makeComponentForTab(kdxApp, uiComponent);
        cardPanel.add(appComponent, CARD_KDXAPPS);

        getRootPane().setDefaultButton(kdxApp.getDefaultButton());

        String msg = Msg.MSG_SHOWING_KDXAPP(kdxApp.getAppName());
        messagesPanel.println(msg);
        System.err.println(msg + " uiClass=" //$NON-NLS-1$
                + uiComponent.getClass().getName());
        break;
    default:
        kdxAppTabs = new JTabbedPane(JTabbedPane.LEFT);
        cardPanel.add(kdxAppTabs, CARD_KDXAPPS);
        Bag<String> tabsSeen = new HashBag<>();
        for (KdxApp app : wantedAppsWithUi) {
            Component ui = componentByApp.get(app);

            String tabName = app.getAppName();
            DevelopmentState devState = app.getDevelopmentState();
            switch (devState) {
            case ALPHA:
                tabName = tabName + " (\u03b1)"; // TODO move to UnicodeChars
                break;
            case BETA:
                tabName = tabName + " (\u03b2)"; // TODO move to UnicodeChars
                break;
            case PRODUCTION:
                break;
            default:
                tabName = tabName + " " + devState.name();
                break;
            }
            tabsSeen.add(tabName);
            int count = tabsSeen.getCount(tabName);
            if (count > 1) {
                tabName = tabName + "_" + count; //$NON-NLS-1$
            }

            Component tabComponent = makeComponentForTab(app, ui);
            kdxAppTabs.addTab(tabName, tabComponent);
            if (macapp == null) {
                int index = kdxAppTabs.indexOfTab(tabName);
                if (index >= 0) {
                    JLabel tabLabel = new JLabel(tabName);
                    tabLabel.setBorder(new EmptyBorder(2, 2, 2, 2));
                    tabLabel.setUI(new VerticalLabelUI(VerticalLabelUI.UPWARDS));
                    kdxAppTabs.setTabComponentAt(index, tabLabel);
                }
            }
            messagesPanel.println(Msg.MSG_SHOWING_KDXAPP(tabName));
        }

        kdxAppTabs.addChangeListener(kdxAppTabsChangeListener);
        kdxAppTabs.setSelectedIndex(0);
        break;
    }
}

From source file:net.sqs2.util.PathUtil.java

public static Set<File> getSharedSuperDirectorySet(Iterable<File> files) {

    Bag<File> bag = new HashBag<File>();
    for (File file : files) {
        File superdir = file;/* ww w.  j  a  v a 2  s. c o  m*/
        do {
            // System.err.print("SRC:"+file);
            bag.add(superdir);
            // System.err.print("\t");
            // System.err.print(superdir);
        } while ((superdir = superdir.getParentFile()) != null);
    }

    Set<File> ret = new HashSet<File>();
    for (File file : bag.uniqueSet()) {
        if (1 < bag.getCount(file)) {
            ret.add(file);
        }
    }
    return ret;
}

From source file:org.o3project.odenos.component.federator.FederatorBoundaryTableTest.java

/**
 * Test method for {@link org.o3project.odenos.component.federator.FederatorBoundaryTable#addEntry(java.lang.String, org.o3project.odenos.component.federator.FederatorBoundary)}.
 * @throws FederatorException/*  w  w  w . jav a2  s . c  om*/
 */
@Test
public void testAddEntry_Branch() throws FederatorException {

    /*
     * setting
     */
    FederatorBoundary boundary1 = new FederatorBoundary("Id1", "Type1", "Network1", "Node1", "Port1",
            "Network2", "Node2", "Port2");

    FederatorBoundary boundary2 = new FederatorBoundary("Id2", "Type2", "Network1", "Node1", "Port1",
            "Network3", "Node3", "Port3");

    /*
     * test
     */
    FederatorBoundary result1 = target.addEntry("Id1", boundary1);
    FederatorBoundary result2 = target.addEntry("Id2", boundary2);

    /*
     * check
     */
    assertThat(result1, is(boundary1));
    assertThat(result2, is(boundary2));

    Map<String, FederatorBoundary> maps = Whitebox.getInternalState(target, "boundaries");
    assertThat(maps.size(), is(2));
    assertThat(maps.get("Id1"), is(boundary1));
    assertThat(maps.get("Id2"), is(boundary2));

    Bag<BoundaryPort> boundaryPorts = Whitebox.getInternalState(target, "boundaryPorts");
    BoundaryPort port1 = new BoundaryPort("Network1", "Node1", "Port1");
    BoundaryPort port2 = new BoundaryPort("Network2", "Node2", "Port2");
    BoundaryPort port3 = new BoundaryPort("Network3", "Node3", "Port3");

    assertThat(boundaryPorts.getCount(port1), is(2));
    assertThat(boundaryPorts.getCount(port2), is(1));
    assertThat(boundaryPorts.getCount(port3), is(1));

}

From source file:org.o3project.odenos.component.federator.FederatorBoundaryTableTest.java

/**
 * Test method for {@link org.o3project.odenos.component.federator.FederatorBoundaryTable#deleteEntry(java.lang.String)}.
 * @throws Exception//from   w ww .java2s. c  o  m
 */
@Test
public void testDeleteEntry_Branch() throws Exception {

    /*
     * setting
     */
    FederatorBoundary boundary1 = new FederatorBoundary("Id1", "Type1", "Network1", "Node1", "Port1",
            "Network2", "Node2", "Port2");

    FederatorBoundary boundary2 = new FederatorBoundary("Id2", "Type2", "Network1", "Node1", "Port1",
            "Network3", "Node3", "Port3");
    target.addEntry("Id1", boundary1);
    target.addEntry("Id2", boundary2);

    /*
     * test
     */
    FederatorBoundary result = target.deleteEntry("Id2");

    /*
     * check
     */
    assertThat(result, is(boundary2));

    assertThat(target.isContains("Id2"), is(false));

    Bag<BoundaryPort> boundaryPorts = Whitebox.getInternalState(target, "boundaryPorts");
    BoundaryPort port1 = new BoundaryPort("Network1", "Node1", "Port1");
    BoundaryPort port2 = new BoundaryPort("Network2", "Node2", "Port2");
    BoundaryPort port3 = new BoundaryPort("Network3", "Node3", "Port3");

    assertThat(boundaryPorts.getCount(port1), is(1));
    assertThat(boundaryPorts.getCount(port2), is(1));
    assertThat(boundaryPorts.getCount(port3), is(0));

}