public Map<String, String> getDataAsMap() { if (data == null) { return Collections.emptyMap(); } return KeyValueFormat.parse(data); }
/** * NCLOC_DATA contains Key-value pairs, where key - is a number of line, and value - is an indicator of whether line * contains code (1) or not (0). * This method parses the value of the NCLOC_DATA measure and return the line numbers of lines which contain code. */ private static Iterable<Integer> nclocLineIndexes(Measure nclocDataMeasure) { Map<Integer, Integer> parsedNclocData = KeyValueFormat.parse(nclocDataMeasure.getData(), newIntegerConverter(), newIntegerConverter()); return parsedNclocData.entrySet() .stream() .filter(entry -> entry.getValue() == 1) .map(Map.Entry::getKey) .collect(Collectors.toList()); }
/** * @since 2.7 */ public static Map<Integer, Date> parseIntDateTime(@Nullable String data) { return parse(data, newIntegerConverter(), newDateTimeConverter()); }
/** * @since 2.7 */ public static Map<String, Integer> parseStringInt(@Nullable String data) { return parse(data, newStringConverter(), newIntegerConverter()); }
/** * @since 2.7 */ public static Map<Integer, Date> parseIntDate(@Nullable String data) { return parse(data, newIntegerConverter(), newDateConverter()); }
/** * @since 2.7 */ public static Map<Integer, Double> parseIntDouble(@Nullable String data) { return parse(data, newIntegerConverter(), newDoubleConverter()); }
/** * @since 2.7 */ public static Map<String, Double> parseStringDouble(@Nullable String data) { return parse(data, newStringConverter(), newDoubleConverter()); }
/** * @since 2.7 */ public static Map<Integer, String> parseIntString(@Nullable String data) { return parse(data, newIntegerConverter(), newStringConverter()); }
/** * @since 2.7 */ public static Map<Integer, Integer> parseIntInt(@Nullable String data) { return parse(data, newIntegerConverter(), newIntegerConverter()); }
private void initializeForOtherLeaf(CounterInitializationContext context) { Optional<Measure> measure = context.getMeasure(NCLOC_LANGUAGE_DISTRIBUTION_KEY); if (measure.isPresent()) { Map<String, Integer> parse = KeyValueFormat.parse(measure.get().getData(), newStringConverter(), newIntegerConverter()); for (Map.Entry<String, Integer> entry : parse.entrySet()) { multiset.add(entry.getKey(), entry.getValue()); } } } }
public static Map<String, String> parse(@Nullable String data) { return parse(data, newStringConverter(), newStringConverter()); }
private Map<Integer, Object> loadData(String metricKey, Converter<? extends Object> converter) { DefaultMeasure<?> measure = measureCache.byMetric(inputFile.key(), metricKey); String data = measure != null ? (String) measure.value() : null; if (data != null) { return ImmutableMap.copyOf(KeyValueFormat.parse(data, KeyValueFormat.newIntegerConverter(), converter)); } // no such measure return ImmutableMap.of(); }
private static boolean handle(Select.Row row, SqlStatement update, Map<String, Integer> ruleKeysById) throws SQLException { String key = row.getString(1); String data = row.getString(2); Map<String, String> map = KeyValueFormat.parse(data); String ruleKey = map.get(RULE_KEY_DATA_FIELD); if (ruleKey == null) { return false; } Integer ruleId = ruleKeysById.get(ruleKey); if (ruleId != null) { map.put(RULE_ID_DATA_FIELD, String.valueOf(ruleId)); } map.remove(RULE_KEY_DATA_FIELD); update.setString(1, KeyValueFormat.format(map)); update.setString(2, key); return true; }
@Test public void shouldParseStrings() { Map<String, String> map = KeyValueFormat.parse("one=un;two=deux"); assertThat(map.size()).isEqualTo(2); assertThat(map.get("one")).isEqualTo("un"); assertThat(map.get("two")).isEqualTo("deux"); assertThat(map.keySet().iterator().next()).isEqualTo("one");// same order as in string }
@Test public void escape_strings() { Map<String, String> input = new LinkedHashMap<>(); input.put("foo", "a=b=c"); input.put("bar", "a;b;c"); input.put("baz", "double\"quote"); String csv = KeyValueFormat.format(input); assertThat(csv).isEqualTo("foo=\"a=b=c\";bar=\"a;b;c\";baz=double\"quote"); Map<String, String> output = KeyValueFormat.parse(csv); assertThat(output.get("foo")).isEqualTo("a=b=c"); assertThat(output.get("bar")).isEqualTo("a;b;c"); assertThat(output.get("baz")).isEqualTo("double\"quote"); }
private static boolean handle(Select.Row row, SqlStatement update) throws SQLException { int id = row.getInt(1); String data = row.getString(2); Map<String, String> fields = KeyValueFormat.parse(data); String profileKey = fields.remove("profileKey"); if (isBlank(profileKey)) { return false; } update.setString(1, profileKey); update.setString(2, KeyValueFormat.format(fields)); update.setInt(3, id); return true; } }
@Test public void parse_blank() { Map<String, String> map = KeyValueFormat.parse(""); assertThat(map).isEmpty(); }
@Test public void parse_null() { Map<String, String> map = KeyValueFormat.parse(null); assertThat(map).isEmpty(); }
private RuleActivation readActivation(DbSession dbSession, Request request) { RuleKey ruleKey = RuleKey.parse(request.mandatoryParam(PARAM_RULE)); RuleDefinitionDto ruleDefinition = wsSupport.getRule(dbSession, ruleKey); boolean reset = Boolean.TRUE.equals(request.paramAsBoolean(PARAM_RESET)); if (reset) { return RuleActivation.createReset(ruleDefinition.getId()); } String severity = request.param(PARAM_SEVERITY); Map<String, String> params = null; String paramsAsString = request.param(PARAM_PARAMS); if (paramsAsString != null) { params = KeyValueFormat.parse(paramsAsString); } return RuleActivation.create(ruleDefinition.getId(), severity, params); }
@Override public void handle(Request request, Response response) throws Exception { ruleWsSupport.checkQProfileAdminPermissionOnDefaultOrganization(); String customKey = request.mandatoryParam(PARAM_CUSTOM_KEY); try (DbSession dbSession = dbClient.openSession(false)) { try { NewCustomRule newRule = NewCustomRule.createForCustomRule(customKey, RuleKey.parse(request.mandatoryParam(PARAM_TEMPLATE_KEY))) .setName(request.mandatoryParam(PARAM_NAME)) .setMarkdownDescription(request.mandatoryParam(PARAM_DESCRIPTION)) .setSeverity(request.mandatoryParam(PARAM_SEVERITY)) .setStatus(RuleStatus.valueOf(request.mandatoryParam(PARAM_STATUS))) .setPreventReactivation(request.mandatoryParamAsBoolean(PARAM_PREVENT_REACTIVATION)); String params = request.param(PARAMS); if (!isNullOrEmpty(params)) { newRule.setParameters(KeyValueFormat.parse(params)); } ofNullable(request.param(PARAM_TYPE)).ifPresent(t -> newRule.setType(RuleType.valueOf(t))); writeResponse(dbSession, request, response, ruleCreator.create(dbSession, newRule)); } catch (ReactivationException e) { response.stream().setStatus(HTTP_CONFLICT); writeResponse(dbSession, request, response, e.ruleKey()); } } }