Example usage for java.util.function Function identity

List of usage examples for java.util.function Function identity

  1. HOME
  2. Java
  3. java
  4. java.util.function.*
  5. Function
  6. identity

Introduction

In this page you can find the example usage for java.util.function Function identity.

Prototype

static <T> Function<T, T> identity()

Source Link

Document

Returns a function that always returns its input argument.

Usage

From source file:org.openecomp.sdc.be.model.cache.ComponentCache.java

public Either<Component, ActionStatus> getComponent(String componentUid, Long lastModificationTime) {

    return getComponent(componentUid, lastModificationTime, Function.identity());

}

From source file:com.spotify.heroic.suggest.elasticsearch.SuggestBackendKV.java

public static Supplier<BackendType> factory() {
    return () -> {
        final Map<String, Map<String, Object>> mappings = new HashMap<>();

        mappings.put(TAG_TYPE, loadJsonResource("kv/tag.json", variables(ImmutableMap.of("type", TAG_TYPE))));

        mappings.put(SERIES_TYPE,/*w ww .ja v  a 2  s . c  o  m*/
                loadJsonResource("kv/series.json", variables(ImmutableMap.of("type", SERIES_TYPE))));

        final Map<String, Object> settings = loadJsonResource("kv/settings.json", Function.identity());

        return new BackendType(mappings, settings, SuggestBackendKV.class);
    };
}

From source file:com.oneops.cms.dj.service.CmsDpmtProcessor.java

private void processSelectedZones(CmsWorkOrder wo, Entry<String, String> entry) {
    List<CmsCIRelation> existingRelations = cmProcessor.getFromCIRelations(wo.getResultCi().getCiId(),
            CmsConstants.BASE_PLACED_IN, CmsConstants.ZONE_CLASS);
    Map<String, CmsCIRelation> relationsMap = existingRelations.stream()
            .collect(Collectors.toMap(relation -> relation.getToCi().getCiName(), Function.identity()));
    String values = entry.getValue();
    if (values != null) {
        String[] zones = values.split(",");
        logger.info("selected zones for this ciId [" + wo.getResultCi().getCiId() + "] : " + values);
        logger.info("existing zones : " + relationsMap.keySet());

        Set<String> selectedZones = Collections.emptySet();
        if (zones.length > 0) {
            selectedZones = Stream.of(zones).map(String::trim).collect(Collectors.toSet());
            createPlacedInRelations(selectedZones, relationsMap, wo);
        }/*  w w  w. j  a  v a2  s .c  o m*/
        removeOldRelations(selectedZones, relationsMap);
    }
}

From source file:serposcope.controllers.google.GoogleTargetController.java

protected String getTableJsonData0(Group group, GoogleTarget target, List<GoogleSearch> searches,
        List<Run> runs, LocalDate startDate, LocalDate endDate) {
    StringBuilder jsonData = new StringBuilder("[{\"id\": -1, \"best\": null, \"days\": [");
    if (runs.isEmpty() || searches.isEmpty()) {
        jsonData.append("]}]");
        return jsonData.toString();
    }//  w  w  w.  j av a 2 s.c  om

    // events
    List<Event> events = baseDB.event.list(group, startDate, endDate);
    for (Run run : runs) {
        Event event = null;

        for (Event candidat : events) {
            if (run.getDay().equals(candidat.getDay())) {
                event = candidat;
                break;
            }
        }

        if (event != null) {
            jsonData.append("{\"title\":\"").append(StringEscapeUtils.escapeJson(event.getTitle()))
                    .append("\",\"description\":\"")
                    .append(StringEscapeUtils.escapeJson(event.getDescription())).append("\"},");
        } else {
            jsonData.append("null,");
        }
    }
    jsonData.deleteCharAt(jsonData.length() - 1);
    jsonData.append("]},");

    Map<Integer, StringBuilder> builders = new HashMap<>();

    for (GoogleSearch search : searches) {
        StringBuilder builder;
        builders.put(search.getId(), builder = new StringBuilder());
        builder.append("");
        GoogleBest best = googleDB.rank.getBest(target.getGroupId(), target.getId(), search.getId());

        builder.append("{\"id\":").append(search.getId()).append(",\"search\":{").append("\"id\":")
                .append(search.getId()).append(",\"k\":\"")
                .append(StringEscapeUtils.escapeJson(search.getKeyword())).append("\",\"t\":\"")
                .append(search.getTld() == null ? "" : StringEscapeUtils.escapeJson(search.getTld()))
                .append("\",\"d\":\"").append(SMARTPHONE.equals(search.getDevice()) ? 'M' : 'D')
                .append("\",\"l\":\"")
                .append(search.getLocal() == null ? "" : StringEscapeUtils.escapeJson(search.getLocal()))
                .append("\",\"dc\":\"")
                .append(search.getDatacenter() == null ? ""
                        : StringEscapeUtils.escapeJson(search.getDatacenter()))
                .append("\",\"c\":\"").append(search.getCustomParameters() == null ? ""
                        : StringEscapeUtils.escapeJson(search.getCustomParameters()))
                .append("\"}, \"best\":");

        if (best == null) {
            builder.append("null,");
        } else {
            builder.append("{\"rank\":").append(best.getRank()).append(",\"date\":\"")
                    .append(best.getRunDay() != null ? best.getRunDay().toLocalDate().toString() : "?")
                    .append("\",\"url\":\"").append(StringEscapeUtils.escapeJson(best.getUrl())).append("\"},");
        }
        builder.append("\"days\": [");
    }

    for (int i = 0; i < runs.size(); i++) {
        Run run = runs.get(i);

        Map<Integer, GoogleRank> ranks = googleDB.rank.list0(run.getId(), group.getId(), target.getId())
                .stream().collect(Collectors.toMap((r) -> r.googleSearchId, Function.identity()));

        for (GoogleSearch search : searches) {
            StringBuilder builder = builders.get(search.getId());
            GoogleRank fullRank = ranks.get(search.getId());
            if (fullRank != null && fullRank.rank != GoogleRank.UNRANKED) {
                builder.append("{\"r\":").append(fullRank.rank).append(",\"p\":").append(fullRank.previousRank)
                        .append(",\"u\":\"").append(StringEscapeUtils.escapeJson(fullRank.url)).append("\"},");
            } else {
                builder.append("{\"r\":32767,\"p\":null,\"u\":null},");
            }

            if (i == runs.size() - 1) {
                builder.deleteCharAt(builder.length() - 1);
                builder.append("]},");
            }
        }
    }

    for (StringBuilder value : builders.values()) {
        jsonData.append(value);
    }
    jsonData.deleteCharAt(jsonData.length() - 1);
    jsonData.append("]");

    return jsonData.toString();
}

From source file:alfio.manager.AdminReservationManager.java

@Transactional
public void removeTickets(String eventName, String reservationId, List<Integer> ticketIds,
        List<Integer> toRefund, boolean notify, String username) {
    loadReservation(eventName, reservationId, username).ifSuccess((res) -> {
        Event e = res.getRight();
        TicketReservation reservation = res.getLeft();
        List<Ticket> tickets = res.getMiddle();
        Map<Integer, Ticket> ticketsById = tickets.stream()
                .collect(Collectors.toMap(Ticket::getId, Function.identity()));
        Set<Integer> ticketIdsInReservation = tickets.stream().map(Ticket::getId).collect(toSet());
        // ensure that all the tickets ids are present in tickets
        Assert.isTrue(ticketIdsInReservation.containsAll(ticketIds),
                "Some ticket ids are not contained in the reservation");
        Assert.isTrue(ticketIdsInReservation.containsAll(toRefund),
                "Some ticket ids to refund are not contained in the reservation");
        ////from w  ww  .j  a v a  2  s.com

        removeTicketsFromReservation(reservationId, e, ticketIds, notify, username, false);
        //

        handleTicketsRefund(toRefund, e, reservation, ticketsById, username);

        if (tickets.size() - ticketIds.size() <= 0) {
            markAsCancelled(reservation);
            additionalServiceItemRepository.updateItemsStatusWithReservationUUID(reservation.getId(),
                    AdditionalServiceItem.AdditionalServiceItemStatus.CANCELLED);
        }
    });
}

From source file:org.apache.samza.system.kafka.KafkaSystemAdmin.java

/**
 * Fetch stream properties for all intermediate streams.
 *
 * @param config kafka system config//from w  w  w .  ja v  a 2 s. c  o m
 * @return a {@link Map} from {@code streamId} to stream {@link Properties}
 */
@VisibleForTesting
static Map<String, Properties> getIntermediateStreamProperties(Config config) {
    Map<String, Properties> intermedidateStreamProperties = Collections.emptyMap();
    ApplicationConfig appConfig = new ApplicationConfig(config);

    if (appConfig.getAppMode() == ApplicationConfig.ApplicationMode.BATCH) {
        StreamConfig streamConfig = new StreamConfig(config);
        intermedidateStreamProperties = JavaConverters.asJavaCollectionConverter(streamConfig.getStreamIds())
                .asJavaCollection().stream().filter(streamConfig::getIsIntermediateStream)
                .collect(Collectors.toMap(Function.identity(), streamId -> {
                    Properties properties = new Properties();
                    properties.putAll(streamConfig.getStreamProperties(streamId));
                    properties.putIfAbsent(TopicConfig.RETENTION_MS_CONFIG,
                            String.valueOf(KafkaConfig.DEFAULT_RETENTION_MS_FOR_BATCH()));
                    return properties;
                }));
    }

    return intermedidateStreamProperties;
}

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

private void doAddTraitsAndOrInstances() {
    try {/*from w  ww.  j a va  2s .  c o m*/

        List<Trait> unusedTraits = offlineData.getKdxploreDatabase().getAllTraits();
        //                  .stream()
        //                  .filter(trt -> ! currentTraitIds.contains(trt.getTraitId()))
        //                  .collect(Collectors.toList());

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

        Trial selectedTrial = trialTraitsTableModel.getSelectedTrial();
        List<TraitInstance> instances = 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 = 1;
            } else {
                inst++;
            }
            instancesByTrait.put(trait, inst);
        }

        for (Trait trait : traitById.values()) {
            if (!instancesByTrait.containsKey(trait)) {
                instancesByTrait.put(trait, 0);
            }
        }

        AddTraitsDialog dlg = new AddTraitsDialog(GuiUtil.getOwnerWindow(TrialOverviewPanel.this),
                selectedTrial, instancesByTrait);

        Dimension sz = dlg.getSize();
        dlg.setSize((int) (sz.width * 1.4), sz.height);

        dlg.setVisible(true);

        Map<Trait, List<Integer>> map = dlg.getTraitAndInstanceNumber();
        if (map != null) {
            doAddTraitInstances(selectedTrial, map);
        }
    } catch (IOException e1) {
        MsgBox.error(TrialOverviewPanel.this, e1, "Add Traits - Database Error");
    }
}

From source file:com.thinkbiganalytics.feedmgr.nifi.cache.NifiFlowCacheImpl.java

private Map<String, NifiFlowProcessor> toProcessorIdMap(Collection<NifiFlowProcessor> processors) {
    return processors.stream().collect(Collectors.toMap(NifiFlowProcessor::getId, Function.identity()));
}

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 {/* ww w .j  av a  2s  .c  o m*/
            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.thoughtworks.go.config.BasicCruiseConfig.java

public Map<CaseInsensitiveString, PipelineConfig> pipelineConfigsAsMap() {
    return getAllPipelineConfigs().stream().collect(toMap(PipelineConfig::name, Function.identity()));
}