Setter for event parameters map

@param paramMap
Event parameters as Map
345879
public void setParamMap(Map<String, Object> paramMap) {
        if (paramMap != null && !paramMap.isEmpty()) {
            this.paramMap.putAll(paramMap);
        }
    }
874464
function runPostMapping (args, uriMappers, location) {
  uriMappers.some(mapper => {
    if (mapper.expression.test(location.path)) {
      args = mapper.map(args);
      return true;
    }
    return false;
  });

  return args;
}
390873
public void setMap(Map<String, Object> map) {
        eventMap.clear();
        eventMap.putAll(map);
    }
100024
public void setParameters(SortedMap<String, String> parameters) {

        checkFrozen();
        if (parameters == null) {
            throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_BAD_JOB_PARAMS_0));
        }
        // make sure the parameters are a sorted map
        m_parameters = new TreeMap<String, String>(parameters);
    }
1133709
public void setParameters(Map<String, String> parameters) {
        this.parameters.clear();
        this.parameters.putAll(parameters);
    }
228327
public void setEventSourceMappings(java.util.Collection<EventSourceMappingConfiguration> eventSourceMappings) {
        if (eventSourceMappings == null) {
            this.eventSourceMappings = null;
            return;
        }

        this.eventSourceMappings = new com.amazonaws.internal.SdkInternalList<EventSourceMappingConfiguration>(eventSourceMappings);
    }
2335
public void addFunctionParameter(final String param) {
    if (param == null || param.isEmpty()) {
      throw new IllegalArgumentException("Parameter cannot be null or empty");
    }
    if (func_params == null) {
      func_params = Lists.newArrayList();
    }
    func_params.add(param);
  }
1149011
public void addJavaScriptValues(Map<String, String> parameterMap) {
        for (String parameterName : parameterMap.keySet()) {
            this.javascriptExpressions.put(parameterName, parameterMap.get(parameterName));
        }
    }
492508
public ParameterBuilder<T> properties(Map<String, Object> map) {
    if (map == null) {
      throw new IllegalArgumentException("Map argument must not be null.");
    }
    this.properties.putAll(map);
    return this;
  }
156113
public void setParams(List<AstNode> params) {
        if (params == null) {
            this.params = null;
        } else {
            if (this.params != null)
                this.params.clear();
            for (AstNode param : params)
                addParam(param);
        }
    }
713367
public RunParams params(Map<String, Object> params) {
        if (params == null) {
            throw new NullPointerException("\"params\" parameter can not be null");
        }
        this.params.putAll(params);
        return this;
    }
1153348
public void setParams(Map<String, CharSequence> params) {
        if (this.params == null) {
            this.params = Collections.unmodifiableMap(params);
        } else {
            throw new IllegalStateException("Can't change parameters.");
        }
    }
957374
public final void setParameter(String name, Object value) {
        if (isNative()) {
            bindParameters.add(new BindParameter(name, value));
        } else {
            setParameterValue(":" + name, value);
        }

        parametersMap.put(":" + name, value);
    }
664319
public static String paramMapToString(final Map<String, String[]> parameters) {

        final StringBuffer result = new StringBuffer();
        for (final String key : parameters.keySet()) {
            String[] values = parameters.get(key);
            if (null == values) {
                result.append(key).append('&');
            } else {
                for (final String value : parameters.get(key)) {
                    result.append(key).append('=').append(CmsEncoder.encode(value)).append('&');
                }
            }
        }
        // remove last '&'
        if (result.length() > 0) {
            result.setLength(result.length() - 1);
        }
        return result.toString();
    }
254142
public static void setParamDefault(
            final Multimap<String, String> params, final String key, final String value) {
        if (!params.containsKey(key)) {
            params.put(key, value);
        }
    }
936129
private EventParameters createEventParameters(Map<String,String> pParams){
        EventParameters evParams = EventParameters.Factory.newInstance();
        for (String name : pParams.keySet()) {
             String val = pParams.get(name);
             if(val == null){
                 continue;
             }
             Parameter evParam = evParams.addNewParameter();
             evParam.setName(name);
             evParam.setStringValue(val);
         }
         return evParams;

    }
908620
@Override
    public void store(final Map<String, String> paramMap, final Map<String, Object> dataMap) {
        final long startTime = System.currentTimeMillis();
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final FessEsClient fessEsClient = ComponentUtil.getFessEsClient();

        if (logger.isDebugEnabled()) {
            logger.debug("Adding " + dataMap);
        }

        //   required check
        final Object urlObj = dataMap.get(fessConfig.getIndexFieldUrl());
        if (urlObj == null) {
            throw new DataStoreException("url is null. dataMap=" + dataMap);
        }

        final IndexingHelper indexingHelper = ComponentUtil.getIndexingHelper();
        final CrawlingInfoHelper crawlingInfoHelper = ComponentUtil.getCrawlingInfoHelper();
        dataMap.put(fessConfig.getIndexFieldId(), crawlingInfoHelper.generateId(dataMap));

        final String url = dataMap.get(fessConfig.getIndexFieldUrl()).toString();

        if (fessConfig.getIndexerClickCountEnabledAsBoolean()) {
            addClickCountField(dataMap, url, fessConfig.getIndexFieldClickCount());
        }

        if (fessConfig.getIndexerFavoriteCountEnabledAsBoolean()) {
            addFavoriteCountField(dataMap, url, fessConfig.getIndexFieldFavoriteCount());
        }

        final Set<String> matchedLabelSet = ComponentUtil.getLabelTypeHelper().getMatchedLabelValueSet(url);
        if (!matchedLabelSet.isEmpty()) {
            final Set<String> newLabelSet = new HashSet<>();
            final String[] oldLabels = DocumentUtil.getValue(dataMap, fessConfig.getIndexFieldLabel(), String[].class);
            StreamUtil.stream(oldLabels).of(stream -> stream.forEach(newLabelSet::add));
            matchedLabelSet.stream().forEach(newLabelSet::add);
            dataMap.put(fessConfig.getIndexFieldLabel(), newLabelSet.toArray(new String[newLabelSet.size()]));
        }

        if (!dataMap.containsKey(fessConfig.getIndexFieldDocId())) {
            final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
            dataMap.put(fessConfig.getIndexFieldDocId(), systemHelper.generateDocId(dataMap));
        }

        ComponentUtil.getLanguageHelper().updateDocument(dataMap);

        synchronized (docList) {
            docList.add(dataMap);
            if (logger.isDebugEnabled()) {
                logger.debug("Added the document. " + "The number of a document cache is " + docList.size() + ".");
            }

            final Long contentLength = DocumentUtil.getValue(dataMap, fessConfig.getIndexFieldContentLength(), Long.class);
            if (contentLength != null) {
                docList.addContentSize(contentLength.longValue());
                if (docList.getContentSize() >= maxDocumentRequestSize) {
                    indexingHelper.sendDocuments(fessEsClient, docList);
                }
            } else if (docList.size() >= fessConfig.getIndexerDataMaxDocumentCacheSizeAsInteger().intValue()) {
                indexingHelper.sendDocuments(fessEsClient, docList);
            }
            executeTime += System.currentTimeMillis() - startTime;
        }

        documentSize.getAndIncrement();

        if (logger.isDebugEnabled()) {
            logger.debug("The number of an added document is " + documentSize.get() + ".");
        }

    }