Example usage for org.apache.commons.collections4 MapUtils isNotEmpty

List of usage examples for org.apache.commons.collections4 MapUtils isNotEmpty

Introduction

In this page you can find the example usage for org.apache.commons.collections4 MapUtils isNotEmpty.

Prototype

public static boolean isNotEmpty(final Map<?, ?> map) 

Source Link

Document

Null-safe check if the specified map is not empty.

Usage

From source file:com.jkoolcloud.tnt4j.streams.StreamsAgent.java

private static boolean loadZKConfig(String zookeeperCfgFile, String zookeeperStreamId) {
    Properties zooProps = ZKConfigManager.readStreamsZKConfig(zookeeperCfgFile);

    if (MapUtils.isNotEmpty(zooProps)) {
        try {//from  w w  w.j a  va 2s  .  c o  m
            ZKConfigManager.openConnection(zooProps);
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                @Override
                public void run() {
                    ZKConfigManager.close();
                }
            }));

            String path = zooProps.getProperty(ZKConfigManager.PROP_CONF_PATH_STREAM);
            if (StringUtils.isEmpty(path) && StringUtils.isNotEmpty(zookeeperStreamId)) {
                LOGGER.log(OpLevel.DEBUG, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                        "StreamsAgent.streams.registry.sid"), zookeeperStreamId);
                path = ZKConfigManager.getZKNodePath(zooProps, zookeeperStreamId);
                LOGGER.log(OpLevel.DEBUG, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                        "StreamsAgent.streams.registry.sid.zk.path"), zookeeperStreamId, path);

                if (StringUtils.isEmpty(path)) {
                    throw new IllegalArgumentException(
                            StreamsResources.getStringFormatted(StreamsResources.RESOURCE_BUNDLE_NAME,
                                    "StreamsAgent.invalid.stream.id", zookeeperStreamId));
                }

                LOGGER.log(OpLevel.DEBUG, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                        "StreamsAgent.streams.registry.sid.setup"), zookeeperStreamId);
                ZKConfigManager.setupZKNodeData(zooProps, zookeeperStreamId);
                ZKConfigManager.setupZKNodeData(zooProps, ZKConfigManager.PROP_CONF_LOGGER);
                ZKConfigManager.setupZKNodeData(zooProps, ZKConfigManager.PROP_CONF_TNT4J);
                // ZKConfigManager.setupZKNodeData(zooProps, ZKConfigManager.PROP_CONF_TNT4J_KAFKA);
            }

            path = zooProps.getProperty(ZKConfigManager.PROP_CONF_PATH_LOGGER);

            if (StringUtils.isNotEmpty(path)) {
                LOGGER.log(OpLevel.INFO, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                        "StreamsAgent.zk.cfg.monitor.logger"), path);

                ZKConfigManager.handleZKStoredConfiguration(path, new ZKConfigManager.ZKConfigChangeListener() {
                    @Override
                    public void applyConfigurationData(byte[] data) {
                        LoggerUtils.setLoggerConfig(data, LOGGER);
                    }
                });
            }

            path = StringUtils.isEmpty(zookeeperStreamId)
                    ? zooProps.getProperty(ZKConfigManager.PROP_CONF_PATH_STREAM)
                    : ZKConfigManager.getZKNodePath(zooProps, zookeeperStreamId);

            if (path != null) {
                LOGGER.log(OpLevel.INFO, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                        "StreamsAgent.zk.cfg.monitor.streams"), path);

                ZKConfigManager.handleZKStoredConfiguration(path, new ZKConfigManager.ZKConfigChangeListener() {
                    @Override
                    public void applyConfigurationData(byte[] data) {
                        if (isStreamsRunning()) {
                            restarting = false;
                            stopStreams();
                            restarting = true;
                        }

                        try {
                            loadConfigAndRun(Utils.bytesReader(data));
                        } catch (Exception exc) {
                            synchronized (streamThreads) {
                                streamThreads.notifyAll();
                            }
                        }
                    }
                });
                return true;
            }
        } catch (Exception exc) {
            LOGGER.log(OpLevel.ERROR, StreamsResources.getString(StreamsResources.RESOURCE_BUNDLE_NAME,
                    "StreamsAgent.zk.cfg.failed"), exc);
        }
    }

    return false;
}

From source file:com.jkoolcloud.tnt4j.streams.outputs.AbstractJKCloudOutput.java

private void applyUserTNT4JProperties() {
    if (MapUtils.isNotEmpty(tnt4jProperties)) {
        for (Map.Entry<String, String> tnt4jProp : tnt4jProperties.entrySet()) {
            trackerConfig.setProperty(tnt4jProp.getKey(), tnt4jProp.getValue());
        }/*  w ww.  ja  v  a 2 s  . com*/

        ((TrackerConfigStore) trackerConfig).applyProperties();
    }
}

From source file:io.cloudslang.lang.runtime.steps.ParallelLoopExecutionData.java

private void checkExceptionInBranch(EndBranchDataContainer branch) {
    //first we check that no exception was thrown during the execution of the branch
    String branchException = branch.getException();
    if (StringUtils.isNotEmpty(branchException)) {
        Map<String, Serializable> systemContextMap = branch.getSystemContext();
        String branchId = null;/*from   w w w  . j  a  v  a2s  . c o m*/
        if (MapUtils.isNotEmpty(systemContextMap)) {
            ExecutionRuntimeServices branchExecutionRuntimeServices = new SystemContext(systemContextMap);
            branchId = branchExecutionRuntimeServices.getBranchId();
        }
        logger.error("There was an error running branch: " + branchId + " Error is: " + branchException);
        throw new RuntimeException(BRANCH_EXCEPTION_PREFIX + ": \n" + branchException);
    }
}

From source file:com.haulmont.cuba.web.exception.ExceptionDialog.java

public void sendSupportEmail(String message, String stackTrace) {
    try {//w w w. j  a  va  2  s.c o  m
        User user = userSessionSource.getUserSession().getUser();
        String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(timeSource.currentTimestamp());

        Map<String, Object> binding = new HashMap<>();
        binding.put("timestamp", date);
        binding.put("errorMessage", message);
        binding.put("stacktrace", stackTrace);
        binding.put("systemId", clientConfig.getSystemID());
        binding.put("userLogin", user.getLogin());

        if (MapUtils.isNotEmpty(additionalExceptionReportBinding)) {
            binding.putAll(additionalExceptionReportBinding);
        }

        reportService.sendExceptionReport(clientConfig.getSupportEmail(), MapUtils.unmodifiableMap(binding));

        Notification.show(messages.getMainMessage("exceptionDialog.emailSent"));
    } catch (Throwable e) {
        log.error("Error sending exception report", e);
        Notification.show(messages.getMainMessage("exceptionDialog.emailSendingErr"));
    }
}

From source file:com.mirth.connect.client.ui.dependencies.ChannelDependenciesPanel.java

private void initComponents() {
    setBackground(UIConstants.BACKGROUND_COLOR);

    dependencyLabel = new JLabel("This channel depends upon:");

    dependencyTreeTable = new MirthTreeTable();

    DefaultTreeTableModel dependencyModel = new SortableTreeTableModel();
    DefaultMutableTreeTableNode dependencyRootNode = new DefaultMutableTreeTableNode();
    dependencyModel.setRoot(dependencyRootNode);

    dependencyTreeTable.setTreeTableModel(dependencyModel);
    dependencyTreeTable.setRootVisible(false);
    dependencyTreeTable.setDoubleBuffered(true);
    dependencyTreeTable.setDragEnabled(false);
    dependencyTreeTable.setRowSelectionAllowed(true);
    dependencyTreeTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    dependencyTreeTable.setRowHeight(UIConstants.ROW_HEIGHT);
    dependencyTreeTable.setFocusable(true);
    dependencyTreeTable.setOpaque(true);
    dependencyTreeTable.setEditable(false);
    dependencyTreeTable.setSortable(true);
    dependencyTreeTable.putClientProperty("JTree.lineStyle", "Horizontal");
    dependencyTreeTable.setAutoCreateColumnsFromModel(false);
    dependencyTreeTable.setShowGrid(true, true);
    dependencyTreeTable.setTableHeader(null);

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        dependencyTreeTable.setHighlighters(HighlighterFactory
                .createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR, UIConstants.BACKGROUND_COLOR));
    }/*from   www  . ja va  2  s  .c  o  m*/

    dependencyTreeTable.setTreeCellRenderer(new DependencyTreeCellRenderer(dependencyTreeTable));

    dependencyTreeTable.addMouseListener(new MouseAdapter() {
        @Override
        public void mousePressed(MouseEvent evt) {
            checkSelection(evt);
        }

        @Override
        public void mouseReleased(MouseEvent evt) {
            checkSelection(evt);
        }

        private void checkSelection(MouseEvent evt) {
            if (dependencyTreeTable.rowAtPoint(new Point(evt.getX(), evt.getY())) < 0) {
                dependencyTreeTable.clearSelection();
            }
        }
    });

    dependencyTreeTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
        @Override
        public void valueChanged(ListSelectionEvent evt) {
            if (!evt.getValueIsAdjusting()) {
                boolean removeEnabled = false;
                int[] rows = dependencyTreeTable.getSelectedModelRows();

                if (rows.length == 1) {
                    TreePath selectedPath = dependencyTreeTable.getPathForRow(rows[0]);

                    if (selectedPath != null) {
                        if (selectedPath.getPathCount() == 2) {
                            removeEnabled = true;
                        }
                    }
                }

                dependencyRemoveButton.setEnabled(removeEnabled);
            }
        }
    });

    dependencyScrollPane = new JScrollPane(dependencyTreeTable);

    dependencyExpandAllLabel = new JLabel("<html><u>Expand All</u></html>");
    dependencyExpandAllLabel.setForeground(Color.BLUE);
    dependencyExpandAllLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    dependencyExpandAllLabel.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseReleased(MouseEvent evt) {
            dependencyTreeTable.expandAll();
        }
    });

    dependencyCollapseAllLabel = new JLabel("<html><u>Collapse All</u></html>");
    dependencyCollapseAllLabel.setForeground(Color.BLUE);
    dependencyCollapseAllLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    dependencyCollapseAllLabel.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseReleased(MouseEvent evt) {
            dependencyTreeTable.collapseAll();
        }
    });

    dependencyAddButton = new JButton("Add");
    dependencyAddButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            Map<String, String> allowedChannelsMap = getAllowedChannels(true);

            if (MapUtils.isNotEmpty(allowedChannelsMap)) {
                AddDialog dialog = new AddDialog(allowedChannelsMap, true);

                if (dialog.wasSaved()) {
                    for (String dependencyId : dialog.getSelectedChannelIds()) {
                        dependencies.add(new ChannelDependency(channel.getId(), dependencyId));
                    }

                    updateTreeTable(true, dependencies);
                    updateAddButton();
                }
            }
        }
    });

    dependencyRemoveButton = new JButton("Remove");
    dependencyRemoveButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int[] rows = dependencyTreeTable.getSelectedModelRows();

            if (rows.length == 1) {
                TreePath selectedPath = dependencyTreeTable.getPathForRow(rows[0]);

                if (selectedPath != null && selectedPath.getPathCount() == 2) {
                    Pair<String, String> pair = (Pair<String, String>) ((MutableTreeTableNode) selectedPath
                            .getLastPathComponent()).getUserObject();

                    for (Iterator<ChannelDependency> it = dependencies.iterator(); it.hasNext();) {
                        ChannelDependency dependency = it.next();
                        if (StringUtils.equals(channel.getId(), dependency.getDependentId())
                                && StringUtils.equals(pair.getLeft(), dependency.getDependencyId())) {
                            it.remove();
                        }
                    }

                    updateTreeTable(true, dependencies);
                    updateAddButton();
                }
            }
        }
    });
    dependencyRemoveButton.setEnabled(false);

    dependentLabel = new JLabel("This channel is depended upon by:");

    dependentTreeTable = new MirthTreeTable();

    DefaultTreeTableModel dependentModel = new SortableTreeTableModel();
    DefaultMutableTreeTableNode dependentRootNode = new DefaultMutableTreeTableNode();
    dependentModel.setRoot(dependentRootNode);

    dependentTreeTable.setTreeTableModel(dependentModel);
    dependentTreeTable.setRootVisible(false);
    dependentTreeTable.setDoubleBuffered(true);
    dependentTreeTable.setDragEnabled(false);
    dependentTreeTable.setRowSelectionAllowed(true);
    dependentTreeTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    dependentTreeTable.setRowHeight(UIConstants.ROW_HEIGHT);
    dependentTreeTable.setFocusable(true);
    dependentTreeTable.setOpaque(true);
    dependentTreeTable.setEditable(false);
    dependentTreeTable.setSortable(true);
    dependentTreeTable.putClientProperty("JTree.lineStyle", "Horizontal");
    dependentTreeTable.setAutoCreateColumnsFromModel(false);
    dependentTreeTable.setShowGrid(true, true);
    dependentTreeTable.setTableHeader(null);

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        dependentTreeTable.setHighlighters(HighlighterFactory
                .createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR, UIConstants.BACKGROUND_COLOR));
    }

    dependentTreeTable.setTreeCellRenderer(new DependencyTreeCellRenderer(dependentTreeTable));

    dependentTreeTable.addMouseListener(new MouseAdapter() {
        @Override
        public void mousePressed(MouseEvent evt) {
            checkSelection(evt);
        }

        @Override
        public void mouseReleased(MouseEvent evt) {
            checkSelection(evt);
        }

        private void checkSelection(MouseEvent evt) {
            if (dependentTreeTable.rowAtPoint(new Point(evt.getX(), evt.getY())) < 0) {
                dependentTreeTable.clearSelection();
            }
        }
    });

    dependentTreeTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
        @Override
        public void valueChanged(ListSelectionEvent evt) {
            if (!evt.getValueIsAdjusting()) {
                boolean removeEnabled = false;
                int[] rows = dependentTreeTable.getSelectedModelRows();

                if (rows.length == 1) {
                    TreePath selectedPath = dependentTreeTable.getPathForRow(rows[0]);

                    if (selectedPath != null) {
                        if (selectedPath.getPathCount() == 2) {
                            removeEnabled = true;
                        }
                    }
                }

                dependentRemoveButton.setEnabled(removeEnabled);
            }
        }
    });

    dependentScrollPane = new JScrollPane(dependentTreeTable);

    dependentExpandAllLabel = new JLabel("<html><u>Expand All</u></html>");
    dependentExpandAllLabel.setForeground(Color.BLUE);
    dependentExpandAllLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    dependentExpandAllLabel.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseReleased(MouseEvent evt) {
            dependentTreeTable.expandAll();
        }
    });

    dependentCollapseAllLabel = new JLabel("<html><u>Collapse All</u></html>");
    dependentCollapseAllLabel.setForeground(Color.BLUE);
    dependentCollapseAllLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    dependentCollapseAllLabel.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseReleased(MouseEvent evt) {
            dependentTreeTable.collapseAll();
        }
    });

    dependentAddButton = new JButton("Add");
    dependentAddButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            Map<String, String> allowedChannelsMap = getAllowedChannels(false);

            if (MapUtils.isNotEmpty(allowedChannelsMap)) {
                AddDialog dialog = new AddDialog(allowedChannelsMap, false);

                if (dialog.wasSaved()) {
                    for (String dependentId : dialog.getSelectedChannelIds()) {
                        dependencies.add(new ChannelDependency(dependentId, channel.getId()));
                    }

                    updateTreeTable(false, dependencies);
                    updateAddButton();
                }
            }
        }
    });

    dependentRemoveButton = new JButton("Remove");
    dependentRemoveButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int[] rows = dependentTreeTable.getSelectedModelRows();

            if (rows.length == 1) {
                TreePath selectedPath = dependentTreeTable.getPathForRow(rows[0]);

                if (selectedPath != null && selectedPath.getPathCount() == 2) {
                    Pair<String, String> pair = (Pair<String, String>) ((MutableTreeTableNode) selectedPath
                            .getLastPathComponent()).getUserObject();

                    for (Iterator<ChannelDependency> it = dependencies.iterator(); it.hasNext();) {
                        ChannelDependency dependency = it.next();
                        if (StringUtils.equals(pair.getLeft(), dependency.getDependentId())
                                && StringUtils.equals(channel.getId(), dependency.getDependencyId())) {
                            it.remove();
                        }
                    }

                    updateTreeTable(false, dependencies);
                    updateAddButton();
                }
            }
        }
    });
    dependentRemoveButton.setEnabled(false);
}

From source file:com.jkoolcloud.tnt4j.streams.inputs.KafkaStream.java

/**
 * {@inheritDoc}/*from w  w  w .j  a  v a  2s .c om*/
 * <p>
 * This method returns a map structured content of next raw activity data item received over Kafka consumer.
 * Returned {@link Map} contains:
 * <ul>
 * <li>{@value com.jkoolcloud.tnt4j.streams.utils.StreamsConstants#TOPIC_KEY}</li>
 * <li>{@value com.jkoolcloud.tnt4j.streams.utils.StreamsConstants#ACTIVITY_DATA_KEY}</li>
 * <li>{@value com.jkoolcloud.tnt4j.streams.utils.StreamsConstants#TRANSPORT_KEY}</li>
 * </ul>
 */
@Override
public Map<String, ?> getNextItem() throws Exception {
    while (!closed.get() && !isHalted()) {
        try {
            if (messageBuffer == null || !messageBuffer.hasNext()) {
                logger().log(OpLevel.DEBUG, StreamsResources.getString(
                        KafkaStreamConstants.RESOURCE_BUNDLE_NAME, "KafkaStream.empty.messages.buffer"));
                Map<String, Integer> topicCountMap = new HashMap<>();
                topicCountMap.put(topicName, 1);

                Map<String, List<kafka.consumer.KafkaStream<byte[], byte[]>>> streams = consumer
                        .createMessageStreams(topicCountMap);

                if (MapUtils.isNotEmpty(streams)) {
                    kafka.consumer.KafkaStream<byte[], byte[]> stream = streams.get(topicName).get(0);
                    messageBuffer = stream.iterator();
                    logger().log(OpLevel.DEBUG,
                            StreamsResources.getString(KafkaStreamConstants.RESOURCE_BUNDLE_NAME,
                                    "KafkaStream.retrieved.new.messages"),
                            stream.size());
                } else {
                    logger().log(OpLevel.DEBUG,
                            StreamsResources.getString(KafkaStreamConstants.RESOURCE_BUNDLE_NAME,
                                    "KafkaStream.retrieved.no.new.messages"));
                }
            }

            if (messageBuffer != null && messageBuffer.hasNext()) {
                MessageAndMetadata<byte[], byte[]> msg = messageBuffer.next();
                byte[] msgPayload = msg.message();
                String msgData = Utils.getString(msgPayload);

                logger().log(OpLevel.DEBUG, StreamsResources.getString(
                        KafkaStreamConstants.RESOURCE_BUNDLE_NAME, "KafkaStream.next.message"), msgData);

                Map<String, Object> msgDataMap = new HashMap<>();

                if (ArrayUtils.isNotEmpty(msgPayload)) {
                    msgDataMap.put(StreamsConstants.TOPIC_KEY, msg.topic());
                    msgDataMap.put(StreamsConstants.ACTIVITY_DATA_KEY, msgPayload);
                    msgDataMap.put(StreamsConstants.TRANSPORT_KEY, KafkaStreamConstants.TRANSPORT_KAFKA);

                    addStreamedBytesCount(msgPayload.length);
                }

                return msgDataMap;
            }
        } catch (ConsumerTimeoutException e) {
            logger().log(OpLevel.DEBUG, StreamsResources.getString(KafkaStreamConstants.RESOURCE_BUNDLE_NAME,
                    "KafkaStream.retrieving.messages.timeout"));
        }
    }
    logger().log(OpLevel.INFO,
            StreamsResources.getString(KafkaStreamConstants.RESOURCE_BUNDLE_NAME, "KafkaStream.stopping"));
    return null;
}

From source file:com.jkoolcloud.tnt4j.streams.fields.ActivityField.java

/**
 * Checks if field has any dynamic locators defined.
 *
 * @return {@code true} if field has any dynamic locators defined, {@code false} - otherwise
 *///from  w w  w.  j a  va2s  .  co m
public boolean isDynamic() {
    return MapUtils.isNotEmpty(dynamicLocators);
}

From source file:io.cloudslang.lang.compiler.modeller.ExecutableBuilder.java

private Workflow getOnFailureWorkflow(List<Map<String, Map<String, Object>>> workFlowRawData,
        Map<String, String> imports, List<RuntimeException> errors, String namespace, String execName,
        SensitivityLevel sensitivityLevel) {

    Map<String, Map<String, Object>> onFailureStepData = preCompileValidator
            .validateOnFailurePosition(workFlowRawData, execName, errors);

    Workflow onFailureWorkFlow = null;/*from www  .  j a  va  2s.c  o  m*/
    if (MapUtils.isNotEmpty(onFailureStepData)) {
        List<Map<String, Map<String, Object>>> onFailureData;
        try {
            //noinspection unchecked
            onFailureData = (List<Map<String, Map<String, Object>>>) onFailureStepData.values().iterator()
                    .next();
        } catch (ClassCastException ex) {
            onFailureData = new ArrayList<>();
            errors.add(new RuntimeException(
                    "Flow: '" + execName + "' syntax is illegal.\nBelow 'on_failure' property there "
                            + "should be a list of steps and not a map"));
        }
        if (CollectionUtils.isNotEmpty(onFailureData)) {
            if (onFailureData.size() > 1) {
                errors.add(new RuntimeException(
                        "Flow: '" + execName + "' syntax is illegal.\nBelow 'on_failure' property "
                                + "there should be only one step"));
            }
            handleOnFailureStepNavigationSection(onFailureData, execName, errors);

            WorkflowModellingResult workflowModellingResult = compileWorkFlow(onFailureData, imports, null,
                    true, namespace, sensitivityLevel);
            errors.addAll(workflowModellingResult.getErrors());
            onFailureWorkFlow = workflowModellingResult.getWorkflow();
        } else if (onFailureData == null) {
            errors.add(new RuntimeException("Flow: '" + execName
                    + "' syntax is illegal.\nThere is no step below the 'on_failure' property."));
        }
    }
    return onFailureWorkFlow;
}

From source file:com.jkoolcloud.tnt4j.streams.fields.ActivityField.java

private static String fillDynamicAttr(String dAttr, Map<String, Object> dValMap, int valueIndex) {
    String tAttr = dAttr;//from   ww w  .j  av a 2  s . c om

    if (isDynamicAttr(dAttr) && MapUtils.isNotEmpty(dValMap)) {
        List<String> vars = new ArrayList<>();
        Utils.resolveCfgVariables(vars, dAttr);

        for (String var : vars) {
            tAttr = tAttr.replace(var, String.valueOf(Utils.getItem(dValMap.get(var), valueIndex)));
        }
    }

    return tAttr;
}

From source file:fr.landel.utils.assertor.utils.AssertorMap.java

private static <M extends Map<K, V>, K, V> StepAssertor<M> contains(final StepAssertor<M> step,
        final Iterable<K> keys, final CharSequence key, final boolean all, final MessageAssertor message) {

    final Predicate<M> preChecker = (map) -> MapUtils.isNotEmpty(map) && !IterableUtils.isEmpty(keys);

    final BiPredicate<M, Boolean> checker = (map, not) -> AssertorMap.contains(map, keys, map::containsKey, all,
            not, step.getAnalysisMode());

    return new StepAssertor<>(step, preChecker, checker, true, message, key, false,
            new ParameterAssertor<>(keys, EnumType.ITERABLE));
}