java.util.SortedMap#headMap

Source File: SortedJobSet.java From swift-k with Apache License 2.0

6 votes

/**
   Remove and return largest job with a walltime smaller than the
   given walltime and less than or equal to the given cpus
   Could be cleaned up using Java 1.6 functionality
 */
public synchronized Job removeOne(TimeInterval walltime, int cpus) {
    Job result = null;
    SortedMap<TimeInterval, LinkedList<Job>> smaller = sm.headMap(walltime);

    while (! smaller.isEmpty()) {
        TimeInterval key = smaller.lastKey();
        List<Job> jobs = smaller.get(key);
        result = removeOne(key, jobs, cpus);
        if (result != null) {
            jsize -= metric.getSize(result);
            if (--size == 0) {
                jsize = 0;
            }
            return result;
        }
        smaller = smaller.headMap(key);
    }
    return null;
}

Source File: DualTreeBidiMap.java From Penetration_Testing_POC with Apache License 2.0

5 votes

public Object previousKey(Object key) {
    if (isEmpty()) {
        return null;
    }
    if (maps[0] instanceof OrderedMap) {
        return ((OrderedMap) maps[0]).previousKey(key);
    }
    SortedMap sm = (SortedMap) maps[0];
    SortedMap hm = sm.headMap(key);
    if (hm.isEmpty()) {
        return null;
    }
    return hm.lastKey();
}

Source File: PendingTxCacheV1.java From aion with MIT License

5 votes

/**
 * @implNote remove the cached transactions base on the account nonce updated by the block import.
 * @param nonceMap The account with the latest nonce.
 * @return The transaction has been removed in the pending tx cache.
 */
public List<AionTransaction> removeSealedTransactions(Map<AionAddress, BigInteger> nonceMap) {
    Objects.requireNonNull(nonceMap);
    Objects.requireNonNull(nonceMap.entrySet());

    lock.lock();
    try {
        List<AionTransaction> txList = new ArrayList<>();
        for (Entry<AionAddress, BigInteger> e : nonceMap.entrySet()) {
            AionAddress address = e.getKey();
            SortedMap<BigInteger, AionTransaction> accountCachedTx = cacheTxMap.get(address);
            if (accountCachedTx != null) {
                BigInteger nonce = e.getValue();
                Map<BigInteger, AionTransaction> flushedTxMap = accountCachedTx.headMap(nonce);
                if (!flushedTxMap.isEmpty()) {
                    for (AionTransaction tx : flushedTxMap.values()) {
                        removeTxInTimeoutMap(tx);
                        addTransactionToRemovedTransactionForPoolBackup(tx);
                    }

                    txList.addAll(flushedTxMap.values());
                }

                cacheTxMap.get(address).headMap(nonce).clear();
                if (cacheTxMap.get(address).isEmpty()) {
                    cacheTxMap.remove(address);
                }
            }
        }

        // Update the timeout cached Tx
        txList.addAll(flushTimeoutTx(false));
        LOG.info("cacheTx.flush cacheTx# {}", cacheTxSize());

        return txList;
    } finally {
        lock.unlock();
    }
}

Source File: LearningController.java From lams with GNU General Public License v2.0

5 votes

@RequestMapping(value = "/previousQuestion")
   private String previousQuestion(@ModelAttribute("surveyForm") AnswerForm surveyForm,
    MultiValueMap<String, String> errorMap, HttpServletRequest request) {
Integer questionSeqID = surveyForm.getQuestionSeqID();
String sessionMapID = surveyForm.getSessionMapID();

SessionMap<String, Object> sessionMap = (SessionMap<String, Object>) request.getSession()
	.getAttribute(sessionMapID);
SortedMap<Integer, AnswerDTO> surveyItemMap = getQuestionList(sessionMap);

if (!errorMap.isEmpty()) {
    request.setAttribute("errorMap", errorMap);
    return "pages/learning/learning";
}

SortedMap<Integer, AnswerDTO> subMap = surveyItemMap.headMap(questionSeqID);
if (subMap.isEmpty()) {
    questionSeqID = surveyItemMap.firstKey();
} else {
    questionSeqID = subMap.lastKey();
}

// get current question index of total questions
int currIdx = new ArrayList<>(surveyItemMap.keySet()).indexOf(questionSeqID) + 1;
surveyForm.setCurrentIdx(currIdx);

if (questionSeqID.equals(surveyItemMap.firstKey())) {
    surveyForm.setPosition(SurveyConstants.POSITION_FIRST);
} else {
    surveyForm.setPosition(SurveyConstants.POSITION_INSIDE);
}
surveyForm.setQuestionSeqID(questionSeqID);
request.setAttribute("surveyForm", surveyForm);
return "pages/learning/learning";
   }

Source File: Graph.java From gemfirexd-oss with Apache License 2.0

5 votes

/**
 * Add an edge to this graph.
 * @param timestamp
 * @param edgeName
 * @param source
 * @param dest
 * @param isFromPattern 
 */
public void addEdge(long timestamp, String edgeName, String state, String source,
    String dest, boolean isFromPattern) {

  Vertex destVertex = new Vertex(this, dest, state, timestamp);
  SortedMap<Long, Vertex> map  = this.indexedVertices.get(dest);
  if(map == null) {
    map = new TreeMap<Long, Vertex>();
    this.indexedVertices.put(dest, map);
  }
  
  //If this edge is being added by a pattern event, only
  //add the edge if the destination changes state as a result
  //of this edge. This cuts down on noise in the graph.
  if(isFromPattern) {
    SortedMap<Long, Vertex> headMap = map.headMap(timestamp);
    if(headMap != null && !headMap.isEmpty()) {
      Long previousKey = headMap.lastKey();
      Vertex previousVertex = headMap.get(previousKey);
      if(previousVertex.getState().equals(state)) {
        return;
      }
    } else {
      //Super hack here. Don't add a transition from the non existent state to
      //the destroyed state in a lifeline.
      if(state.equals("destroyed")) {
        return;
      }
    }
  }
  map.put(timestamp, destVertex);
  
  edges.add(new Edge(this, timestamp, edgeName, source, destVertex));
}

Source File: Edge.java From gemfirexd-oss with Apache License 2.0

5 votes

public Vertex getSource() {
  SortedMap<Long, Vertex> sourceMap = graph.getIndexedVertices().get(source);
  if(sourceMap == null) {
    return null;
  }
  SortedMap<Long, Vertex> headMap = sourceMap.headMap(dest.getTimestamp() + 1);
  if(headMap.isEmpty()) {
    return null;
  }
  Long closestTimestamp = headMap.lastKey();
  return headMap.get(closestTimestamp);
}