下面列出了java.util.SortedMap#values ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* As Xpp3Dom is very picky about the order of children while comparing, create a new list where the children
* are added in alphabetical order. See <a href="https://jira.codehaus.org/browse/MOJO-1931">MOJO-1931</a>.
*
* @param originalListFromPom order not specified
* @return a list where children's member are alphabetically sorted.
*/
private List<Xpp3Dom> createRuleListWithNameSortedChildren( final List<Xpp3Dom> originalListFromPom )
{
final List<Xpp3Dom> listWithSortedEntries = new ArrayList<Xpp3Dom>( originalListFromPom.size() );
for ( Xpp3Dom unsortedXpp3Dom : originalListFromPom )
{
final Xpp3Dom sortedXpp3Dom = new Xpp3Dom( getRuleName() );
final SortedMap<String, Xpp3Dom> childrenMap = new TreeMap<String, Xpp3Dom>();
final Xpp3Dom[] children = unsortedXpp3Dom.getChildren();
for ( Xpp3Dom child : children )
{
childrenMap.put( child.getName(), child );
}
for ( Xpp3Dom entry : childrenMap.values() )
{
sortedXpp3Dom.addChild( entry );
}
listWithSortedEntries.add( sortedXpp3Dom );
}
return listWithSortedEntries;
}
/**
* Compacts the journal up to the given index.
* <p>
* The semantics of compaction are not specified by this interface.
*
* @param index The index up to which to compact the journal.
*/
public void compact(long index) {
Map.Entry<Long, JournalSegment<E>> segmentEntry = segments.floorEntry(index);
if (segmentEntry != null) {
SortedMap<Long, JournalSegment<E>> compactSegments = segments.headMap(segmentEntry.getValue().index());
if (!compactSegments.isEmpty()) {
log.debug("{} - Compacting {} segment(s)", name, compactSegments.size());
for (JournalSegment segment : compactSegments.values()) {
log.trace("Deleting segment: {}", segment);
segment.close();
segment.delete();
}
compactSegments.clear();
resetHead(segmentEntry.getValue().index());
}
}
}
@RequestMapping(value = "/showOtherUsersAnswers")
private String showOtherUsersAnswers(HttpServletRequest request) {
String sessionMapID = request.getParameter("sessionMapID");
request.setAttribute("sessionMapID", sessionMapID);
SessionMap<String, Object> sessionMap = (SessionMap<String, Object>) request.getSession()
.getAttribute(sessionMapID);
SortedMap<Integer, AnswerDTO> surveyItemMap = getQuestionList(sessionMap);
Long sessionId = (Long) sessionMap.get(AttributeNames.PARAM_TOOL_SESSION_ID);
List<AnswerDTO> answerDtos = new ArrayList<>();
for (SurveyQuestion question : surveyItemMap.values()) {
AnswerDTO answerDto = surveyService.getQuestionResponse(sessionId, question.getUid());
answerDtos.add(answerDto);
}
request.setAttribute("answerDtos", answerDtos);
SurveyUser surveyLearner = (SurveyUser) sessionMap.get(SurveyConstants.ATTR_USER);
surveyService.setResponseFinalized(surveyLearner.getUid());
int countFinishedUser = surveyService.getCountFinishedUsers(sessionId);
request.setAttribute(SurveyConstants.ATTR_COUNT_FINISHED_USERS, countFinishedUser);
return "pages/learning/resultOtherUsers";
}
private List<RecordField> getRecordFields() {
if (this.recordFields != null) {
return this.recordFields;
}
// Use a SortedMap keyed by index of the field so that we can get a List of field names in the correct order
final SortedMap<Integer, String> sortedMap = new TreeMap<>();
for (final Map.Entry<String, Integer> entry : csvParser.getHeaderMap().entrySet()) {
sortedMap.put(entry.getValue(), entry.getKey());
}
final List<RecordField> fields = new ArrayList<>();
final List<String> rawFieldNames = new ArrayList<>(sortedMap.values());
for (final String rawFieldName : rawFieldNames) {
final Optional<RecordField> option = schema.getField(rawFieldName);
if (option.isPresent()) {
fields.add(option.get());
} else {
fields.add(new RecordField(rawFieldName, RecordFieldType.STRING.getDataType()));
}
}
this.recordFields = fields;
return fields;
}
/**
* Filter and sort
* @param fms The FrameworkMethods
* @param isStatic Filter static
* @return The filtered and sorted FrameworkMethods
* @exception Exception If an order definition is incorrect
*/
private Collection<FrameworkMethod> filterAndSort(List<FrameworkMethod> fms, boolean isStatic) throws Exception
{
SortedMap<Integer, FrameworkMethod> m = new TreeMap<>();
for (FrameworkMethod fm : fms)
{
SecurityActions.setAccessible(fm.getMethod());
if (Modifier.isStatic(fm.getMethod().getModifiers()) == isStatic)
{
Deployment deployment = (Deployment)fm.getAnnotation(Deployment.class);
int order = deployment.order();
if (order <= 0 || m.containsKey(Integer.valueOf(order)))
throw new Exception("Incorrect order definition '" + order + "' on " +
fm.getDeclaringClass().getName() + "#" + fm.getName());
m.put(Integer.valueOf(order), fm);
}
}
return m.values();
}
private final void counter(String[] data) throws Exception {
Topology t = newTopology();
TStream<String> s = t.strings(data);
s = Metrics.counter(s);
waitUntilComplete(t, s, data);
if (metricRegistry != null) {
SortedMap<String, Counter> counters = metricRegistry.getCounters();
assertEquals(1, counters.size());
Collection<Counter> values = counters.values();
for (Counter v : values) {
assertEquals(data.length, v.getCount());
}
}
}
@Override
public boolean advance() throws IOException {
// This is in a while loop because the blocks that we are asked to look into may
// not contain the key prefix.
while (iterator == null || !iterator.hasNext()) {
// If there are no blocks to iterate over we can return false
if (!blockEntriesIterator.hasNext()) {
return false;
}
NavigableMap<RandomAccessData, WindowedValue<IsmRecord<V>>> map;
try (Closeable counterCloseable = IsmReader.setSideInputReadContext(readCounter)) {
IsmShardKey nextBlock = blockEntriesIterator.next();
map = fetch(nextBlock);
}
SortedMap<RandomAccessData, WindowedValue<IsmRecord<V>>> submap =
map.subMap(prefix, prefixUpperBound);
Collection<WindowedValue<IsmRecord<V>>> values = submap.values();
iterator = values.iterator();
}
current = Optional.of(iterator.next());
return true;
}
/**
* @param qualifier
* @param initialsToInfo this is where we are going to get the info from (currently: inner or top level list)
* @param toks (out) the tokens will be added to this list
* @return
*/
protected void getWithFilter(String qualifier, SortedMap<String, Set<IInfo>> initialsToInfo,
Collection<IInfo> toks, Filter filter, boolean useLowerCaseQual) {
String initials = getInitials(qualifier);
String qualToCompare = qualifier;
if (useLowerCaseQual) {
qualToCompare = qualifier.toLowerCase();
}
//get until the end of the alphabet
SortedMap<String, Set<IInfo>> subMap = initialsToInfo.subMap(initials, initials + "\uffff\uffff\uffff\uffff");
for (Set<IInfo> listForInitials : subMap.values()) {
for (IInfo info : listForInitials) {
if (filter.doCompare(qualToCompare, info)) {
toks.add(info);
}
}
}
}
/**
* Prints summary of all tables found on the system.
*/
private void printTableSummary(SortedMap<TableName, HbckTableInfo> tablesInfo) {
StringBuilder sb = new StringBuilder();
int numOfSkippedRegions;
errors.print("Summary:");
for (HbckTableInfo tInfo : tablesInfo.values()) {
numOfSkippedRegions = (skippedRegions.containsKey(tInfo.getName())) ?
skippedRegions.get(tInfo.getName()).size() : 0;
if (errors.tableHasErrors(tInfo)) {
errors.print("Table " + tInfo.getName() + " is inconsistent.");
} else if (numOfSkippedRegions > 0){
errors.print("Table " + tInfo.getName() + " is okay (with "
+ numOfSkippedRegions + " skipped regions).");
}
else {
errors.print("Table " + tInfo.getName() + " is okay.");
}
errors.print(" Number of regions: " + tInfo.getNumRegions());
if (numOfSkippedRegions > 0) {
Set<String> skippedRegionStrings = skippedRegions.get(tInfo.getName());
System.out.println(" Number of skipped regions: " + numOfSkippedRegions);
System.out.println(" List of skipped regions:");
for(String sr : skippedRegionStrings) {
System.out.println(" " + sr);
}
}
sb.setLength(0); // clear out existing buffer, if any.
sb.append(" Deployed on: ");
for (ServerName server : tInfo.deployedOn) {
sb.append(" " + server.toString());
}
errors.print(sb.toString());
}
}
private static int[] getNearestNeighbors(SortedMap<Double, Integer> distanceMap) {
int[] nearest = new int[6];
int i = 0;
for (Integer index : distanceMap.values())
{
nearest[i++] = index;
if (i >= 6)
{
break;
}
}
return nearest;
}
public static int[] getNearestNeighbors(SortedMap<Double, Integer> distanceMap) {
int[] nearest = new int[6];
int i = 0;
for (Integer index : distanceMap.values()) {
nearest[i++] = index;
if (i >= 6) {
break;
}
}
return nearest;
}
public static void shutdownMetrics(String indexerName) {
SortedMap<String, SortedMap<MetricName, Metric>> groupedMetrics = Metrics.defaultRegistry().groupedMetrics(
new IndexerMetricPredicate(indexerName));
for (SortedMap<MetricName, Metric> metricMap : groupedMetrics.values()) {
for (MetricName metricName : metricMap.keySet()) {
Metrics.defaultRegistry().removeMetric(metricName);
}
}
}
public boolean append(@Nonnull AppendEntries appendEntries) {
final long prevLogIndex = appendEntries.getPrevLogIndex();
final long prevLogTerm = appendEntries.getPrevLogTerm();
final List<Entry> entries = appendEntries.getEntriesList();
EntryMeta previousEntry = entryIndex.get(prevLogIndex);
if ((previousEntry == null) || (previousEntry.term != prevLogTerm)) {
LOGGER.debug("Append prevLogIndex {} prevLogTerm {} previousEntry {}", prevLogIndex, prevLogTerm, previousEntry);
return false;
}
SortedMap<Long, EntryMeta> old = this.entryIndex.tailMap(prevLogIndex + 1);
for (EntryMeta e : old.values()) {
try {
LOGGER.debug("Deleting {}", e.index);
journal.delete(e.location);
} catch (IOException e1) {
e1.printStackTrace();
}
}
old.clear();
lastLogIndex = prevLogIndex;
for (Entry entry : entries) {
storeEntry(++lastLogIndex, entry);
}
return true;
}
/**
*
* @param centralAtom
* @param atomContainer
* @param angleMap
* @return
*/
@Override
public IStereoElement execute(IAtom centralAtom,
IAtomContainer atomContainer,
SortedMap<Double, IBond> angleMap) {
int[] permutation = getMatchPermutation();
List<IBond> bonds = new ArrayList<>(angleMap.values());
IAtom[] ligandAtoms = new IAtom[4];
for (int index = 0; index < 4; index++) {
IBond bond = bonds.get(permutation[index]);
ligandAtoms[index] = bond.getOther(centralAtom);
}
ITetrahedralChirality.Stereo chirality = CLOCKWISE;
return new TetrahedralChirality(centralAtom, ligandAtoms, chirality);
}
@Override
public void archiveCompletedReservations(long tick) {
// Since we are looking for old reservations, read lock is optimal
LOG.debug("Running archival at time: {}", tick);
List<InMemoryReservationAllocation> expiredReservations =
new ArrayList<InMemoryReservationAllocation>();
readLock.lock();
// archive reservations and delete the ones which are beyond
// the reservation policy "window"
try {
long archivalTime = tick - policy.getValidWindow();
ReservationInterval searchInterval =
new ReservationInterval(archivalTime, archivalTime);
SortedMap<ReservationInterval, Set<InMemoryReservationAllocation>> reservations =
currentReservations.headMap(searchInterval, true);
if (!reservations.isEmpty()) {
for (Set<InMemoryReservationAllocation> reservationEntries : reservations
.values()) {
for (InMemoryReservationAllocation reservation : reservationEntries) {
if (reservation.getEndTime() <= archivalTime) {
expiredReservations.add(reservation);
}
}
}
}
} finally {
readLock.unlock();
}
if (expiredReservations.isEmpty()) {
return;
}
// Need write lock only if there are any reservations to be deleted
writeLock.lock();
try {
for (InMemoryReservationAllocation expiredReservation : expiredReservations) {
removeReservation(expiredReservation);
}
} finally {
writeLock.unlock();
}
}
/**
* Paint the "neutralized" lines (staff lines, ledgers, stems) with a special value,
* so that template matching can ignore these locations.
*/
private void paintLines ()
{
// Neutralize foreground due to staff lines / ledgers and stems
for (SystemInfo system : sheet.getSystems()) {
for (Staff staff : system.getStaves()) {
// "Erase" staff lines
for (LineInfo line : staff.getLines()) {
// Paint the line glyph
Glyph glyph = line.getGlyph();
paintGlyph(glyph);
// Also paint this line even at crossings with vertical objects
double halfLine = 0.5 * glyph.getMeanThickness(Orientation.HORIZONTAL);
Point2D leftPt = line.getEndPoint(LEFT);
Point2D rightPt = line.getEndPoint(RIGHT);
int xMin = (int) Math.floor(leftPt.getX());
int xMax = (int) Math.ceil(rightPt.getX());
for (int x = xMin; x <= xMax; x++) {
double yl = line.yAt((double) x);
int yMin = (int) Math.rint(yl - halfLine);
int yMax = (int) Math.rint(yl + halfLine);
for (int y = yMin; y <= yMax; y++) {
table.setValue(x, y, ChamferDistance.VALUE_UNKNOWN);
}
}
}
// "Erase" ledgers
SortedMap<Integer, List<LedgerInter>> ledgerMap = staff.getLedgerMap();
for (List<LedgerInter> ledgers : ledgerMap.values()) {
for (LedgerInter ledger : ledgers) {
paintGlyph(ledger.getGlyph());
}
}
}
// "Erase" stem seeds
List<Glyph> systemSeeds = system.getGroupedGlyphs(GlyphGroup.VERTICAL_SEED);
for (Glyph seed : systemSeeds) {
paintGlyph(seed);
}
}
}
/**
* This method stores the depreciation transactions in the general pending entry table and creates a new documentHeader entry.
* <p>
*
* @param trans SortedMap with the transactions
* @return none
*/
protected void processGeneralLedgerPendingEntry(Integer fiscalYear, Integer fiscalMonth, List<String> documentNos, SortedMap<String, AssetDepreciationTransaction> trans) {
LOG.debug("populateExplicitGeneralLedgerPendingEntry(AccountingDocument, AccountingLine, GeneralLedgerPendingEntrySequenceHelper, GeneralLedgerPendingEntry) - start");
String financialSystemDocumentTypeCodeCode;
try {
String documentNumber = createNewDepreciationDocument(documentNos);
financialSystemDocumentTypeCodeCode = CamsConstants.DocumentTypeName.ASSET_DEPRECIATION;
LOG.debug(CamsConstants.Depreciation.DEPRECIATION_BATCH + "Depreciation Document Type Code: " + financialSystemDocumentTypeCodeCode);
Timestamp transactionTimestamp = new Timestamp(dateTimeService.getCurrentDate().getTime());
GeneralLedgerPendingEntrySequenceHelper sequenceHelper = new GeneralLedgerPendingEntrySequenceHelper();
List<GeneralLedgerPendingEntry> saveList = new ArrayList<GeneralLedgerPendingEntry>();
int counter = 0;
for (AssetDepreciationTransaction t : trans.values()) {
if (t.getTransactionAmount().isNonZero()) {
counter++;
LOG.debug(CamsConstants.Depreciation.DEPRECIATION_BATCH + "Creating GLPE entries for asset:" + t.getCapitalAssetNumber());
GeneralLedgerPendingEntry explicitEntry = new GeneralLedgerPendingEntry();
explicitEntry.setFinancialSystemOriginationCode(KFSConstants.ORIGIN_CODE_KUALI);
explicitEntry.setDocumentNumber(documentNumber);
explicitEntry.setTransactionLedgerEntrySequenceNumber(new Integer(sequenceHelper.getSequenceCounter()));
sequenceHelper.increment();
explicitEntry.setChartOfAccountsCode(t.getChartOfAccountsCode());
explicitEntry.setAccountNumber(t.getAccountNumber());
explicitEntry.setSubAccountNumber(null);
explicitEntry.setFinancialObjectCode(t.getFinancialObjectCode());
explicitEntry.setFinancialSubObjectCode(null);
explicitEntry.setFinancialBalanceTypeCode(BALANCE_TYPE_ACTUAL);
explicitEntry.setFinancialObjectTypeCode(t.getFinancialObjectTypeCode());
explicitEntry.setUniversityFiscalYear(fiscalYear);
explicitEntry.setUniversityFiscalPeriodCode(StringUtils.leftPad(fiscalMonth.toString().trim(), 2, "0"));
explicitEntry.setTransactionLedgerEntryDescription(t.getTransactionLedgerEntryDescription());
explicitEntry.setTransactionLedgerEntryAmount(t.getTransactionAmount().abs());
explicitEntry.setTransactionDebitCreditCode(t.getTransactionType());
explicitEntry.setTransactionDate(new java.sql.Date(transactionTimestamp.getTime()));
explicitEntry.setFinancialDocumentTypeCode(financialSystemDocumentTypeCodeCode);
explicitEntry.setFinancialDocumentApprovedCode(KFSConstants.DocumentStatusCodes.APPROVED);
explicitEntry.setVersionNumber(new Long(1));
explicitEntry.setTransactionEntryProcessedTs(new java.sql.Timestamp(transactionTimestamp.getTime()));
// this.generalLedgerPendingEntryService.save(explicitEntry);
saveList.add(explicitEntry);
if (counter % 1000 == 0) {
// save here
getDepreciationBatchDao().savePendingGLEntries(saveList);
saveList.clear();
}
if (sequenceHelper.getSequenceCounter() == 99999) {
// create new document and sequence is reset
documentNumber = createNewDepreciationDocument(documentNos);
sequenceHelper = new GeneralLedgerPendingEntrySequenceHelper();
}
}
}
// save last list
getDepreciationBatchDao().savePendingGLEntries(saveList);
saveList.clear();
}
catch (Exception e) {
LOG.error("Error occurred", e);
throw new IllegalStateException(kualiConfigurationService.getPropertyValueAsString(CamsKeyConstants.Depreciation.ERROR_WHEN_UPDATING_GL_PENDING_ENTRY_TABLE) + " :" + e.getMessage());
}
LOG.debug("populateExplicitGeneralLedgerPendingEntry(AccountingDocument, AccountingLine, GeneralLedgerPendingEntrySequenceHelper, GeneralLedgerPendingEntry) - end");
}
private List<LookupElementBuilder> doFindSuggestionsForQueryPrefix(Module module,
Trie<String, MetadataSuggestionNode> rootSearchIndex, FileType fileType, PsiElement element,
@Nullable List<String> ancestralKeys, String queryWithDotDelimitedPrefixes,
@Nullable Set<String> siblingsToExclude) {
debug(() -> log.debug("Search requested for " + queryWithDotDelimitedPrefixes));
StopWatch timer = new StopWatch();
timer.start();
try {
String[] querySegmentPrefixes = toSanitizedPathSegments(queryWithDotDelimitedPrefixes);
Set<Suggestion> suggestions = null;
if (ancestralKeys != null) {
String[] ancestralKeySegments =
ancestralKeys.stream().flatMap(key -> stream(toRawPathSegments(key)))
.toArray(String[]::new);
MetadataSuggestionNode rootNode = rootSearchIndex.get(sanitise(ancestralKeySegments[0]));
if (rootNode != null) {
List<SuggestionNode> matchesRootToDeepest;
SuggestionNode startSearchFrom = null;
if (ancestralKeySegments.length > 1) {
String[] sanitisedAncestralPathSegments =
stream(ancestralKeySegments).map(SuggestionNode::sanitise).toArray(String[]::new);
matchesRootToDeepest = rootNode
.findDeepestSuggestionNode(module, modifiableList(rootNode),
sanitisedAncestralPathSegments, 1);
if (matchesRootToDeepest != null && matchesRootToDeepest.size() != 0) {
startSearchFrom = matchesRootToDeepest.get(matchesRootToDeepest.size() - 1);
}
} else {
startSearchFrom = rootNode;
matchesRootToDeepest = singletonList(rootNode);
}
if (startSearchFrom != null) {
// if search start node is a leaf, this means, the user is looking for values for the given key, lets find the suggestions for values
if (startSearchFrom.isLeaf(module)) {
suggestions = startSearchFrom.findValueSuggestionsForPrefix(module, fileType,
unmodifiableList(matchesRootToDeepest),
sanitise(truncateIdeaDummyIdentifier(element.getText())), siblingsToExclude);
} else {
suggestions = startSearchFrom.findKeySuggestionsForQueryPrefix(module, fileType,
unmodifiableList(matchesRootToDeepest), matchesRootToDeepest.size(),
querySegmentPrefixes, 0, siblingsToExclude);
}
}
}
} else {
String rootQuerySegmentPrefix = querySegmentPrefixes[0];
SortedMap<String, MetadataSuggestionNode> topLevelQueryResults =
rootSearchIndex.prefixMap(rootQuerySegmentPrefix);
Collection<MetadataSuggestionNode> childNodes;
int querySegmentPrefixStartIndex;
// If no results are found at the top level, let dive deeper and find matches
if (topLevelQueryResults == null || topLevelQueryResults.size() == 0) {
childNodes = rootSearchIndex.values();
querySegmentPrefixStartIndex = 0;
} else {
childNodes = topLevelQueryResults.values();
querySegmentPrefixStartIndex = 1;
}
Collection<MetadataSuggestionNode> nodesToSearchAgainst;
if (siblingsToExclude != null) {
Set<MetadataSuggestionNode> nodesToExclude = siblingsToExclude.stream()
.flatMap(exclude -> rootSearchIndex.prefixMap(exclude).values().stream())
.collect(toSet());
nodesToSearchAgainst =
childNodes.stream().filter(node -> !nodesToExclude.contains(node)).collect(toList());
} else {
nodesToSearchAgainst = childNodes;
}
suggestions = doFindSuggestionsForQueryPrefix(module, fileType, nodesToSearchAgainst,
querySegmentPrefixes, querySegmentPrefixStartIndex);
}
if (suggestions != null) {
return toLookupElementBuilders(suggestions);
}
return null;
} finally {
timer.stop();
debug(() -> log.debug("Search took " + timer.toString()));
}
}
@Override
public void archiveCompletedReservations(long tick) {
// Since we are looking for old reservations, read lock is optimal
LOG.debug("Running archival at time: {}", tick);
List<InMemoryReservationAllocation> expiredReservations =
new ArrayList<InMemoryReservationAllocation>();
readLock.lock();
// archive reservations and delete the ones which are beyond
// the reservation policy "window"
try {
long archivalTime = tick - policy.getValidWindow();
ReservationInterval searchInterval =
new ReservationInterval(archivalTime, archivalTime);
SortedMap<ReservationInterval, Set<InMemoryReservationAllocation>> reservations =
currentReservations.headMap(searchInterval, true);
if (!reservations.isEmpty()) {
for (Set<InMemoryReservationAllocation> reservationEntries : reservations
.values()) {
for (InMemoryReservationAllocation reservation : reservationEntries) {
if (reservation.getEndTime() <= archivalTime) {
expiredReservations.add(reservation);
}
}
}
}
} finally {
readLock.unlock();
}
if (expiredReservations.isEmpty()) {
return;
}
// Need write lock only if there are any reservations to be deleted
writeLock.lock();
try {
for (InMemoryReservationAllocation expiredReservation : expiredReservations) {
removeReservation(expiredReservation);
}
} finally {
writeLock.unlock();
}
}
private void calculateHeaders(Class<?> type) {
SortedMap<Integer, SortedMap<Integer, String>> allHeaders = new TreeMap<Integer, SortedMap<Integer, String>>();
calculateHeaders(type, allHeaders, 0);
for (SortedMap<Integer, String> headerMap : allHeaders.values()) {
for (String header : headerMap.values()) {
headers.add(header);
}
}
}