Java Code Examples for java.util.SortedMap#put()

@Override
public SortedMap<Integer, FullToken> fullTokenListWithPos(final char[] code) {
	final Iterable<Token> tokens = lexer.getTokens(new String(code));
	final SortedMap<Integer, FullToken> tokensWithPos = Maps.newTreeMap();
	tokensWithPos.put(-1, new FullToken(SENTENCE_START, SENTENCE_START));
	tokensWithPos.put(Integer.MAX_VALUE, new FullToken(SENTENCE_END,
			SENTENCE_END));
	for (final Token tok : tokens) {
		if (isProgramToken(tok)) {
			continue;
		}
		tokensWithPos.put(tok.getPos(), new FullToken(getTokenString(tok),
				""));
	}
	return tokensWithPos;
}
 

private void poolAdd(ByteArrayWrapper txHash, PooledTransaction poolTx) {

        LOG_TXPOOL.debug("Adding tx[{}]", poolTx.tx);

        poolTransactions.put(txHash, poolTx);
        long txTime = TimeUnit.MICROSECONDS.toSeconds(poolTx.tx.getTimeStampBI().longValue()) + transactionTimeout;
        Set<ByteArrayWrapper> timeSet = timeView.getOrDefault(txTime, new LinkedHashSet<>());
        timeView.putIfAbsent(txTime, timeSet);
        timeSet.add(txHash);

        long txEnergyPrice = poolTx.tx.getEnergyPrice();
        Set<ByteArrayWrapper> feeSet = feeView.getOrDefault(txEnergyPrice, new LinkedHashSet<>());
        feeView.putIfAbsent(txEnergyPrice, feeSet);
        feeSet.add(txHash);

        SortedMap<BigInteger, ByteArrayWrapper> accountInfo = accountView.getOrDefault(poolTx.tx.getSenderAddress(), new TreeMap<>());
        accountView.putIfAbsent(poolTx.tx.getSenderAddress(), accountInfo);
        accountInfo.put(poolTx.tx.getNonceBI(), txHash);

        LOG_TXPOOL.debug("Added tx[{}]", poolTx.tx);
    }
 

/**
 * Position the renaming in the text.
 * 
 * @param testSourceFile
 * @param suggestedRenamings
 * @return
 */
private SortedMap<Integer, SortedSet<Renaming>> postionRenamings(
		final String testSourceFile,
		final SortedMap<Integer, SortedSet<Renaming>> suggestedRenamings) {
	final List<String> tokensPos = tokenizer
			.tokenListFromCode(testSourceFile.toCharArray());

	// Hack: reverse engineer list to do something useful
	final SortedMap<Integer, SortedSet<Renaming>> positionedRenamings = Maps
			.newTreeMap();
	int i = 0;
	for (final Entry<Integer, String> token : tokenizer.getBaseTokenizer()
			.tokenListWithPos(testSourceFile.toCharArray()).entrySet()) {
		if (suggestedRenamings.containsKey(i)) {
			positionedRenamings.put(token.getKey(),
					suggestedRenamings.get(i));
		}
		if (tokensPos.get(i).equals(FormattingTokenizer.WS_NO_SPACE)) {
			i++;
		}
		i++;
	}

	return positionedRenamings;
}
 

/**
 * @param tokens
 * @param cu
 * @return
 */
public SortedMap<Integer, FullToken> doApproximateTypeInference(
		final SortedMap<Integer, FullToken> tokens, final ASTNode cu) {
	final JavaApproximateTypeInferencer tInf = new JavaApproximateTypeInferencer(
			cu);
	tInf.infer();
	final Map<Integer, String> types = tInf.getVariableTypesAtPosition();

	final SortedMap<Integer, FullToken> typeTokenList = Maps.newTreeMap();
	for (final Entry<Integer, FullToken> token : tokens.entrySet()) {
		final String type = types.get(token.getKey());
		if (type != null) {
			typeTokenList.put(token.getKey(), new FullToken("var%" + type
					+ "%", token.getValue().tokenType));
		} else {
			typeTokenList.put(token.getKey(),
					new FullToken(token.getValue().token,
							token.getValue().tokenType));
		}
	}
	return typeTokenList;
}
 

/**
 * Records from MySQL BinLog origin have a bit unique structure.
 *
 * Records for Insert and update operations have a field path "/Data", which is a map
 * of all column names as key and values stored in DB as value.
 *
 * Record for Delete operation don't have /Data field. Instead it has a filed path "/OldData",
 * which store the original data in table. So need to look into /OldData when operation is delete.
 *
 * We expect user to configure /Data as a filed path in column-filed mapping configuration.
 * @param record
 * @param op
 * @param parameters
 * @param columnsToFields
 * @return
 */
@Override
public SortedMap<String, String> getColumnsToParameters(
    final Record record, int op,
    Map<String, String> parameters,
    Map<String, String> columnsToFields)
{
  SortedMap<String, String> columnsToParameters = new TreeMap<>();
  for (Map.Entry<String, String> entry : columnsToFields.entrySet()) {
    String columnName = entry.getKey();
    String fieldPath = entry.getValue();
    if(op == OperationType.DELETE_CODE){
      fieldPath = fieldPath.replace(DATA_FIELD, OLD_DATA_FIELD);
    }

    if (record.has(fieldPath)) {
      columnsToParameters.put(columnName, parameters.get(columnName));
    }
  }
  return columnsToParameters;
}
 

@Override
public SortedMap<Integer, String> tokenListWithPos(final char[] code) {
	final SortedMap<Integer, String> tokens = Maps.newTreeMap();
	tokens.put(-1, SENTENCE_START);
	tokens.put(Integer.MAX_VALUE, SENTENCE_END);

	final Scanner scanner = new Scanner();
	scanner.setSource(code);
	final WhitespaceToTokenConverter wsConverter = new WhitespaceToTokenConverter();
	do {
		final int token = scanner.getNextToken();
		if (token == Token.tWHITESPACE) {
			final String wsToken = wsConverter
					.toWhiteSpaceSymbol(new String(scanner
							.getCurrentTokenSource()));
			tokens.put(scanner.getCurrentPosition(), wsToken);
		} else {
			final String nxtToken = new String(
					scanner.getCurrentTokenSource());
			tokens.put(scanner.getCurrentPosition(),
					getTokenType(token, nxtToken));
		}
	} while (!scanner.atEnd());
	return tokens;
}
 

public static SortedMap<String, ContextMapping> loadMappings(Object configuration, Version indexVersionCreated)
        throws ElasticsearchParseException {
    if (configuration instanceof Map) {
        Map<String, Object> configurations = (Map<String, Object>)configuration;
        SortedMap<String, ContextMapping> mappings = Maps.newTreeMap();
        for (Entry<String,Object> config : configurations.entrySet()) {
            String name = config.getKey();
            mappings.put(name, loadMapping(name, (Map<String, Object>) config.getValue(), indexVersionCreated));
        }
        return mappings;
    } else if (configuration == null) {
        return ContextMapping.EMPTY_MAPPING;
    } else {
        throw new ElasticsearchParseException("no valid context configuration");
    }
}
 

/**
 * GenPolynomial subtract a multiple.
 * 
 * @param a
 *            coefficient.
 * @param e
 *            exponent.
 * @param S
 *            GenPolynomial.
 * @return this - a x<sup>e</sup> S.
 */
public SymbolicPolynomial subtractMultiple(IExpr a, ExpVectorSymbolic e, SymbolicPolynomial S) {
	if (a == null || a.isZERO()) {
		return this;
	}
	if (S == null || S.isZERO()) {
		return this;
	}
	if (this.isZERO()) {
		return S.multiply(a.negate(), e);
	}
	assert (ring.nvar == S.ring.nvar);
	SymbolicPolynomial n = this.copy();
	SortedMap<ExpVectorSymbolic, IExpr> nv = n.val;
	SortedMap<ExpVectorSymbolic, IExpr> sv = S.val;
	for (Map.Entry<ExpVectorSymbolic, IExpr> me : sv.entrySet()) {
		ExpVectorSymbolic f = me.getKey();
		f = e.sum(f);
		IExpr y = me.getValue(); // assert y != null
		y = a.multiply(y);
		IExpr x = nv.get(f);
		if (x != null) {
			x = x.subtract(y);
			if (!x.isZERO()) {
				nv.put(f, x);
			} else {
				nv.remove(f);
			}
		} else if (!y.isZERO()) {
			nv.put(f, y.negate());
		}
	}
	return n;
}
 

public void testReadALogAndTestInputGestures() throws Exception {
    InputStream is = getClass().getResourceAsStream("NB1216449736.0");
    SortedMap<Integer,InputGesture> expectedGestures = new TreeMap<Integer,InputGesture>();
    expectedGestures.put(35, InputGesture.MENU);
    expectedGestures.put(59, InputGesture.KEYBOARD);
    expectedGestures.put(66, InputGesture.MENU);
    expectedGestures.put(80, InputGesture.MENU);
    expectedGestures.put(81, InputGesture.MENU);
    expectedGestures.put(177, InputGesture.KEYBOARD);
    expectedGestures.put(197, InputGesture.KEYBOARD);
    expectedGestures.put(205, InputGesture.MENU);
    TestHandler records = new TestHandler(is);
    for (int cnt = 0;; cnt++) {
        LOG.log(Level.INFO, "Reading {0}th record", cnt);
        LogRecord r = records.read();
        if (r == null) {
            break;
        }
        if (r.getSequenceNumber() > expectedGestures.lastKey()) {
            break;
        }
        LOG.log(Level.INFO, "Read {0}th record, seq {1}", new Object[] { cnt, r.getSequenceNumber() });

        InputGesture g = InputGesture.valueOf(r);
        InputGesture exp = expectedGestures.get((int)r.getSequenceNumber());
        assertEquals(cnt + ": For: " + r.getSequenceNumber() + " txt:\n`"+ r.getMessage() +
            "\nkey: " + r.getResourceBundleName()
            , exp, g);
    }
    is.close();
}
 

protected Collection<DataKey> getSortedFileKeys(Dataset dataset) {
	DataKeyFileMapper mapper = m_config.getKeyFileMapper();
	SortedMap<String,DataKey> map = new TreeMap<String,DataKey>();
	for ( DataKey key : dataset.getAllFileKeys() ) {
		String name = mapper.getFileName(key);
		map.put(name,key);
	}
	return map.values();
}
 

/**
 *
 * @return
 */
public SortedMap<String, ValueModel> assembleCommonLeadCorrectionParameters() {
    SortedMap<String, ValueModel> parameters = new TreeMap<>();

    // initial pb model parameters
    parameters.put("r207_206c", initialPbSchemeA_r207_206c);
    parameters.put("r206_204c", initialPbSchemeB_R206_204c);
    parameters.put("r207_204c", initialPbSchemeB_R207_204c);
    parameters.put("r208_204c", initialPbSchemeB_R208_204c);

    return parameters;
}
 

/**
 * Tests the method {@link BitSets#closure(java.util.SortedMap)}
 */
@Test void testClosure() {
  final SortedMap<Integer, BitSet> empty = new TreeMap<>();
  assertThat(BitSets.closure(empty), equalTo(empty));

  // Map with an an entry for each position.
  final SortedMap<Integer, BitSet> map = new TreeMap<>();
  map.put(0, BitSets.of(3));
  map.put(1, BitSets.of());
  map.put(2, BitSets.of(7));
  map.put(3, BitSets.of(4, 12));
  map.put(4, BitSets.of());
  map.put(5, BitSets.of());
  map.put(6, BitSets.of());
  map.put(7, BitSets.of());
  map.put(8, BitSets.of());
  map.put(9, BitSets.of());
  map.put(10, BitSets.of());
  map.put(11, BitSets.of());
  map.put(12, BitSets.of());
  final String original = map.toString();
  final String expected =
      "{0={3, 4, 12}, 1={}, 2={7}, 3={3, 4, 12}, 4={4, 12}, 5={}, 6={}, 7={7}, 8={}, 9={}, 10={}, 11={}, 12={4, 12}}";
  assertThat(BitSets.closure(map).toString(), equalTo(expected));
  assertThat("argument modified", map.toString(), equalTo(original));

  // Now a similar map with missing entries. Same result.
  final SortedMap<Integer, BitSet> map2 = new TreeMap<>();
  map2.put(0, BitSets.of(3));
  map2.put(2, BitSets.of(7));
  map2.put(3, BitSets.of(4, 12));
  map2.put(9, BitSets.of());
  final String original2 = map2.toString();
  assertThat(BitSets.closure(map2).toString(), equalTo(expected));
  assertThat("argument modified", map2.toString(), equalTo(original2));
}
 

public void testGetMostSelectiveMatchingIndexMostSelective() throws IOException {
	String json = TestHelpers.readFileToString(this.getClass(), "CObjectCQLGeneratorTestData.js");
	CDefinition definition = CDefinition.fromJsonString(json);
	SortedMap<String, Object> indexValues = new TreeMap<String, Object>();
	indexValues.put("type", "typeValue");
	indexValues.put("foreignid", 13);
	indexValues.put("instance", 11);

	CIndex matchingIndex = definition.getMostSelectiveMatchingIndex(indexValues);
	String expectedIndexKey = Joiner.on(":").join(indexValues.keySet());
	assertEquals(expectedIndexKey, matchingIndex.getKey());
}
 

@Override
public SortedMap<Integer, String> tokenListWithPos(final char[] code) {
	final SortedMap<Integer, String> tokens = Maps.newTreeMap();
	for (final Entry<Integer, AstAnnotatedToken> token : getAnnotatedTokens(
			code).entrySet()) {
		tokens.put(token.getKey(), token.getValue().token.token);
	}
	return tokens;
}
 

@Override
public SortedMap<ServletHolder,String> getExtraServlets() {
  final SortedMap<ServletHolder,String> extraServlets = new TreeMap<>();
  final ServletHolder solrRestApi = new ServletHolder("SolrSchemaRestApi", ServerServlet.class);
  solrRestApi.setInitParameter("org.restlet.application", "org.apache.solr.rest.SolrSchemaRestApi");
  extraServlets.put(solrRestApi, "/schema/*");  // '/schema/*' matches '/schema', '/schema/', and '/schema/whatever...'
  return extraServlets;
}
 

/**
 * Returns how often each variable occurs in the given BDD.
 * @param bdd the BDD
 * @return how often each variable occurs in the BDD
 */
public SortedMap<Variable, Integer> variableProfile(final BDD bdd) {
  final int[] varProfile = this.kernel.varProfile(bdd.index());
  final SortedMap<Variable, Integer> profile = new TreeMap<>();
  for (int i = 0; i < varProfile.length; i++) {
    profile.put(this.idx2var.get(i), varProfile[i]);
  }
  return profile;
}
 

protected SortedMap<String, ?> getCompletions(String searchSubstr, boolean insensitive, boolean regex) {
	SortedMap<String, ?> result = getCompletions();
	if (searchSubstr != null && result != null) {
		Set<String> keySet = result.keySet();
		String searchStr = (regex ? searchSubstr : toRegex(searchSubstr));
		boolean isRegex = (regex || isRegex(searchStr,searchSubstr));
		if (insensitive || isRegex) {
			try {
				SortedMap<String,? super Object> regResult = new TreeMap<String, Object>();
				Pattern pat = Pattern.compile(searchStr + RWILD, (insensitive ? Pattern.CASE_INSENSITIVE : 0));	//$NON-NLS-1$
				// we have to build the map up one by one on regex search
				for (String key : keySet) {
					if (pat.matcher(key).matches()) {
						regResult.put(key, result.get(key));
					}
				}
				result = regResult; 					
			} catch (Exception e) {
				// ignore any PatternSyntaxException
			}
			if (result.size() == 0 && !insensitive) {
				// try non-regex lookup
				result = getCompletions(searchSubstr, keySet);					
			} 
		} else {
			result = getCompletions(searchSubstr, keySet);
		}
		if ((result == null || result.size() == 0) && !insensitive) {
			// try once with case insensitivity
			return getCompletions(searchSubstr, true, regex);
		}
	}
	return result;
}
 

@Override
public SortedMap<Integer, String> tokenListWithPos(final char[] code) {
	final SortedMap<Integer, String> tokens = Maps.newTreeMap();
	tokens.put(-1, SENTENCE_START);
	tokens.put(Integer.MAX_VALUE, SENTENCE_END);
	final PublicScanner scanner = prepareScanner(code);

	while (!scanner.atEnd()) {
		do {
			try {
				final int token = scanner.getNextToken();
				final int position = scanner
						.getCurrentTokenStartPosition();
				if (token == ITerminalSymbols.TokenNameEOF) {
					break;
				}
				int i = 0;
				final List<String> cTokens = getConvertedToken(scanner,
						token);
				for (final String cToken : cTokens) {
					tokens.put(position + i, cToken);
					i++;
				}
			} catch (final InvalidInputException e) {
				LOGGER.warning(ExceptionUtils.getFullStackTrace(e));
			}
		} while (!scanner.atEnd());
	}
	return tokens;
}
 

@Override
public WxMpPayResult getJSSDKPayResult(String transactionId, String outTradeNo) {
  String nonce_str = System.currentTimeMillis() + "";

  SortedMap<String, String> packageParams = new TreeMap<String, String>();
  packageParams.put("appid", wxMpConfigStorage.getAppId());
  packageParams.put("mch_id", wxMpConfigStorage.getPartnerId());
  if (transactionId != null && !"".equals(transactionId.trim()))
    packageParams.put("transaction_id", transactionId);
  else if (outTradeNo != null && !"".equals(outTradeNo.trim()))
    packageParams.put("out_trade_no", outTradeNo);
  else
    throw new IllegalArgumentException("Either 'transactionId' or 'outTradeNo' must be given.");
  packageParams.put("nonce_str", nonce_str);
  packageParams.put("sign", WxCryptUtil.createSign(packageParams, wxMpConfigStorage.getPartnerKey()));

  StringBuilder request = new StringBuilder("<xml>");
  for (Entry<String, String> para : packageParams.entrySet()) {
    request.append(String.format("<%s>%s</%s>", para.getKey(), para.getValue(), para.getKey()));
  }
  request.append("</xml>");

  HttpPost httpPost = new HttpPost("https://api.mch.weixin.qq.com/pay/orderquery");
  if (httpProxy != null) {
    RequestConfig config = RequestConfig.custom().setProxy(httpProxy).build();
    httpPost.setConfig(config);
  }

  StringEntity entity = new StringEntity(request.toString(), Consts.UTF_8);
  httpPost.setEntity(entity);
  try {
    CloseableHttpResponse response = httpClient.execute(httpPost);
    String responseContent = Utf8ResponseHandler.INSTANCE.handleResponse(response);
    XStream xstream = XStreamInitializer.getInstance();
    xstream.alias("xml", WxMpPayResult.class);
    WxMpPayResult wxMpPayResult = (WxMpPayResult) xstream.fromXML(responseContent);
    return wxMpPayResult;
  } catch (IOException e) {
    throw new RuntimeException("Failed to query order due to IO exception.", e);
  }
}
 

/**
 * Testing setParameters in JdbcGenericRecordWriter as well as setParamsToStatement()
 * and setPrimaryKeys() in JdbcBaseRecordWriter.
 * @throws StageException
 */
@Test
public void testSetParameters() throws StageException {
  List<JdbcFieldColumnParamMapping> columnMapping = ImmutableList.of(
      new JdbcFieldColumnParamMapping("/field1", "P_ID", "?"),
      new JdbcFieldColumnParamMapping("/field2", "MSG", "?")
  );

  boolean caseSensitive = false;
  JdbcGenericRecordWriter writer = new JdbcGenericRecordWriter(
      connectionString,
      dataSource,
      "TEST",
      "TEST_TABLE",
      false, //rollback
      columnMapping,
      JDBCOperationType.INSERT.getCode(),
      UnsupportedOperationAction.DISCARD,
      null,
      new JdbcRecordReader(),
      caseSensitive,
      Collections.emptyList(),
      true,
      context
  );
  Record record = RecordCreator.create();
  Map<String, Field> fields = new HashMap<>();
  fields.put("field1", Field.create(100));
  fields.put("field2", Field.create("StreamSets"));
  record.set(Field.create(fields));

  SortedMap<String, String> columnsToParameters = new TreeMap<>();
  columnsToParameters.put("P_ID", "?");
  columnsToParameters.put("MSG", "?");

  String query = "INSERT INTO TEST.TEST_TABLE (MSG, P_ID) VALUES (?, ?)";
  executeSetParameters(OperationType.INSERT_CODE, query, writer, columnsToParameters, record);

  query = "DELETE FROM TEST.TEST_TABLE  WHERE P_ID = ?";
  executeSetParameters(OperationType.DELETE_CODE, query, writer, columnsToParameters, record);

  query = "UPDATE TEST.TEST_TABLE SET  MSG = ? WHERE P_ID = ?";
  fields.put("field2", Field.create("This is an updated message"));
  columnsToParameters.remove("P_ID");
  executeSetParameters(OperationType.UPDATE_CODE, query, writer, columnsToParameters, record);
}