下面列出了java.util.NavigableMap#floorEntry ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Return original line number corresponding to the character at the specified position on the
* specified new/flattened line. If there is no entry covering the specified position, the last
* original line number associated with this flattened line is returned.
*/
public int getOriginalLine(@Nonnull Integer newLineNumber, @Nonnull Integer newStartingPosition) {
NavigableMap<Integer, Integer> wordMap = _lineMap.get(newLineNumber);
if (wordMap == null) {
/*
* Result from looking up an unmapped line, this handles lines like the header inserted after
* flattening
*/
return UNMAPPED_LINE_NUMBER;
} else {
Entry<Integer, Integer> originalLineEntry = wordMap.floorEntry(newStartingPosition);
/*
* Default to the last entry if there is no corresponding entry (e.g. looking up original
* line for a word like 'set' that did not exist in the original config should still give
* useful output)
*/
return (originalLineEntry == null)
? wordMap.lastEntry().getValue()
: originalLineEntry.getValue();
}
}
Integer get(Integer key, Integer time) {
NavigableMap<Integer, Integer> value = map.get(key);
if (Objects.isNull(value)) {
return null;
}
Map.Entry<Integer, Integer> timedValue = value.floorEntry(time);
if (Objects.isNull(timedValue)) {
return null;
}
return timedValue.getValue();
}
/**
* floorEntry returns preceding entry.
*/
public void testFloorEntry() {
NavigableMap map = map5();
Map.Entry e1 = map.floorEntry(three);
assertEquals(three, e1.getKey());
Map.Entry e2 = map.floorEntry(six);
assertEquals(five, e2.getKey());
Map.Entry e3 = map.floorEntry(one);
assertEquals(one, e3.getKey());
Map.Entry e4 = map.floorEntry(zero);
assertNull(e4);
}
/**
* floorEntry returns preceding entry.
*/
public void testDescendingFloorEntry() {
NavigableMap map = dmap5();
Map.Entry e1 = map.floorEntry(m3);
assertEquals(m3, e1.getKey());
Map.Entry e2 = map.floorEntry(m6);
assertEquals(m5, e2.getKey());
Map.Entry e3 = map.floorEntry(m1);
assertEquals(m1, e3.getKey());
Map.Entry e4 = map.floorEntry(zero);
assertNull(e4);
}
@Override
public void onRender(TypeAdapter aAdapter, VDocument aResponse,
Map<AnnotationFS, VSpan> annoToSpanIdx, int aPageBegin, int aPageEnd)
{
if (aAdapter.getLayer().isCrossSentence() || annoToSpanIdx.isEmpty()) {
return;
}
CAS cas = annoToSpanIdx.entrySet().iterator().next().getKey().getCAS();
// Build indexes to allow quickly looking up the sentence by its begin/end offsets. Since
// The indexes are navigable, we can also find the sentences starting/ending closes to a
// particular offset, even if it is not the start/end offset of a sentence.
NavigableMap<Integer, AnnotationFS> sentBeginIdx = new TreeMap<>();
NavigableMap<Integer, AnnotationFS> sentEndIdx = new TreeMap<>();
for (AnnotationFS sent : selectOverlapping(cas, getType(cas, Sentence.class), aPageBegin,
aPageEnd)) {
sentBeginIdx.put(sent.getBegin(), sent);
sentEndIdx.put(sent.getEnd(), sent);
}
for (AnnotationFS fs : annoToSpanIdx.keySet()) {
Entry<Integer, AnnotationFS> s1 = sentBeginIdx.floorEntry(fs.getBegin());
Entry<Integer, AnnotationFS> s2 = sentEndIdx.ceilingEntry(fs.getEnd());
if (s1 == null || s2 == null) {
// Unable to determine any sentences overlapping with the annotation
continue;
}
if (!WebAnnoCasUtil.isSame(s1.getValue(), s2.getValue())) {
aResponse.add(new VComment(new VID(fs), ERROR,
"Crossing sentence boundaries is not permitted."));
}
}
}
public GenerationResult get(String name, int index) {
NavigableMap<Integer,Generation> generations = this.contents.get(
name
);
if (generations == null) {
logger.info(String.format("Cache miss on generation: %s,%d", name, index));
return GenerationResult.miss();
}
Entry<Integer, Generation> best = generations.floorEntry(index);
if (best == null) {
logger.info(String.format("Cache miss on index: %s,%d", name, index));
return GenerationResult.miss();
}
if (best.getKey().equals(index)) {
logger.info(String.format("Cache hit: %s,%d", name, index));
return GenerationResult.hit(best.getValue());
} else {
logger.info(String.format("Partial cache hit: %s,%d", name, index));
Generation current = best.getValue();
for (int i = best.getKey() + 1; i <= index; i++) {
current = current.evolve();
}
generations.put(index, current);
return GenerationResult.partialHit(current, index - best.getKey());
}
}
/**
* floorEntry returns preceding entry.
*/
public void testFloorEntry() {
NavigableMap map = map5();
Map.Entry e1 = map.floorEntry(three);
assertEquals(three, e1.getKey());
Map.Entry e2 = map.floorEntry(six);
assertEquals(five, e2.getKey());
Map.Entry e3 = map.floorEntry(one);
assertEquals(one, e3.getKey());
Map.Entry e4 = map.floorEntry(zero);
assertNull(e4);
}
/**
* floorEntry returns preceding entry.
*/
public void testDescendingFloorEntry() {
NavigableMap map = dmap5();
Map.Entry e1 = map.floorEntry(m3);
assertEquals(m3, e1.getKey());
Map.Entry e2 = map.floorEntry(m6);
assertEquals(m5, e2.getKey());
Map.Entry e3 = map.floorEntry(m1);
assertEquals(m1, e3.getKey());
Map.Entry e4 = map.floorEntry(zero);
assertNull(e4);
}
synchronized KieModule load(InternalKieScanner kieScanner, ReleaseId releaseId, VersionRange versionRange) {
String ga = releaseId.getGroupId() + ":" + releaseId.getArtifactId();
NavigableMap<ComparableVersion, KieModule> artifactMap = kieModules.get(ga);
if ( artifactMap == null || artifactMap.isEmpty() ) {
return null;
}
KieModule kieModule = artifactMap.get(new ComparableVersion(releaseId.getVersion()));
if (versionRange.fixed) {
if ( kieModule != null && releaseId.isSnapshot() ) {
String oldSnapshotVersion = ((ReleaseIdImpl)kieModule.getReleaseId()).getSnapshotVersion();
if ( oldSnapshotVersion != null ) {
String currentSnapshotVersion = kieScanner.getArtifactVersion(releaseId);
if (currentSnapshotVersion != null &&
new ComparableVersion(currentSnapshotVersion).compareTo(new ComparableVersion(oldSnapshotVersion)) > 0) {
// if the snapshot currently available on the maven repo is newer than the cached one
// return null to enforce the building of this newer version
return null;
}
}
}
return kieModule;
}
Map.Entry<ComparableVersion, KieModule> entry =
versionRange.upperBound == null ?
artifactMap.lastEntry() :
versionRange.upperInclusive ?
artifactMap.floorEntry(new ComparableVersion(versionRange.upperBound)) :
artifactMap.lowerEntry(new ComparableVersion(versionRange.upperBound));
if ( entry == null ) {
return null;
}
if ( versionRange.lowerBound == null ) {
return entry.getValue();
}
int comparison = entry.getKey().compareTo(new ComparableVersion(versionRange.lowerBound));
return comparison > 0 || (comparison == 0 && versionRange.lowerInclusive) ? entry.getValue() : null;
}
/**
* Add a resource for the specified interval
*
* @param reservationInterval the interval for which the resource is to be
* added
* @param capacity the resource to be added
* @return true if addition is successful, false otherwise
*/
public boolean addInterval(ReservationInterval reservationInterval,
ReservationRequest capacity) {
Resource totCap =
Resources.multiply(capacity.getCapability(),
(float) capacity.getNumContainers());
if (totCap.equals(ZERO_RESOURCE)) {
return true;
}
writeLock.lock();
try {
long startKey = reservationInterval.getStartTime();
long endKey = reservationInterval.getEndTime();
NavigableMap<Long, Resource> ticks =
cumulativeCapacity.headMap(endKey, false);
if (ticks != null && !ticks.isEmpty()) {
Resource updatedCapacity = Resource.newInstance(0, 0, 0);
Entry<Long, Resource> lowEntry = ticks.floorEntry(startKey);
if (lowEntry == null) {
// This is the earliest starting interval
cumulativeCapacity.put(startKey, totCap);
} else {
updatedCapacity = Resources.add(lowEntry.getValue(), totCap);
// Add a new tick only if the updated value is different
// from the previous tick
if ((startKey == lowEntry.getKey())
&& (isSameAsPrevious(lowEntry.getKey(), updatedCapacity))) {
cumulativeCapacity.remove(lowEntry.getKey());
} else {
cumulativeCapacity.put(startKey, updatedCapacity);
}
}
// Increase all the capacities of overlapping intervals
Set<Entry<Long, Resource>> overlapSet =
ticks.tailMap(startKey, false).entrySet();
for (Entry<Long, Resource> entry : overlapSet) {
updatedCapacity = Resources.add(entry.getValue(), totCap);
entry.setValue(updatedCapacity);
}
} else {
// This is the first interval to be added
cumulativeCapacity.put(startKey, totCap);
}
Resource nextTick = cumulativeCapacity.get(endKey);
if (nextTick != null) {
// If there is overlap, remove the duplicate entry
if (isSameAsPrevious(endKey, nextTick)) {
cumulativeCapacity.remove(endKey);
}
} else {
// Decrease capacity as this is end of the interval
cumulativeCapacity.put(endKey, Resources.subtract(cumulativeCapacity
.floorEntry(endKey).getValue(), totCap));
}
return true;
} finally {
writeLock.unlock();
}
}
/**
* Add a resource for the specified interval
*
* @param reservationInterval the interval for which the resource is to be
* added
* @param capacity the resource to be added
* @return true if addition is successful, false otherwise
*/
public boolean addInterval(ReservationInterval reservationInterval,
ReservationRequest capacity) {
Resource totCap =
Resources.multiply(capacity.getCapability(),
(float) capacity.getNumContainers());
if (totCap.equals(ZERO_RESOURCE)) {
return true;
}
writeLock.lock();
try {
long startKey = reservationInterval.getStartTime();
long endKey = reservationInterval.getEndTime();
NavigableMap<Long, Resource> ticks =
cumulativeCapacity.headMap(endKey, false);
if (ticks != null && !ticks.isEmpty()) {
Resource updatedCapacity = Resource.newInstance(0, 0);
Entry<Long, Resource> lowEntry = ticks.floorEntry(startKey);
if (lowEntry == null) {
// This is the earliest starting interval
cumulativeCapacity.put(startKey, totCap);
} else {
updatedCapacity = Resources.add(lowEntry.getValue(), totCap);
// Add a new tick only if the updated value is different
// from the previous tick
if ((startKey == lowEntry.getKey())
&& (isSameAsPrevious(lowEntry.getKey(), updatedCapacity))) {
cumulativeCapacity.remove(lowEntry.getKey());
} else {
cumulativeCapacity.put(startKey, updatedCapacity);
}
}
// Increase all the capacities of overlapping intervals
Set<Entry<Long, Resource>> overlapSet =
ticks.tailMap(startKey, false).entrySet();
for (Entry<Long, Resource> entry : overlapSet) {
updatedCapacity = Resources.add(entry.getValue(), totCap);
entry.setValue(updatedCapacity);
}
} else {
// This is the first interval to be added
cumulativeCapacity.put(startKey, totCap);
}
Resource nextTick = cumulativeCapacity.get(endKey);
if (nextTick != null) {
// If there is overlap, remove the duplicate entry
if (isSameAsPrevious(endKey, nextTick)) {
cumulativeCapacity.remove(endKey);
}
} else {
// Decrease capacity as this is end of the interval
cumulativeCapacity.put(endKey, Resources.subtract(cumulativeCapacity
.floorEntry(endKey).getValue(), totCap));
}
return true;
} finally {
writeLock.unlock();
}
}
/**
* Returns the record for the last key having this iterators key prefix. Last is defined as the
* largest key with the same key prefix when comparing key's byte representations using an
* unsigned lexicographical byte order.
*
* <p>Null is returned if the prefix is not present within this file.
*/
@Override
public WindowedValue<IsmRecord<V>> getLast() throws IOException {
RandomAccessData keyBytes = new RandomAccessData();
int shardId = coder.encodeAndHash(keyComponents, keyBytes);
Optional<SeekableByteChannel> inChannel =
initializeFooterAndShardIndex(Optional.<SeekableByteChannel>absent(), readCounter);
// Key is not stored here
if (!shardIdToShardMap.containsKey(shardId) || !bloomFilterMightContain(keyBytes)) {
return null;
}
inChannel = initializeForKeyedRead(shardId, inChannel, readCounter);
closeIfPresent(inChannel);
final NavigableMap<RandomAccessData, IsmShardKey> indexInShard = indexPerShard.get(shardId);
RandomAccessData end = keyBytes.increment();
final IsmShardKey cacheEntry = indexInShard.floorEntry(end).getValue();
NavigableMap<RandomAccessData, WindowedValue<IsmRecord<V>>> block;
try (Closeable readerCloser = IsmReader.setSideInputReadContext(readCounter)) {
block = fetch(cacheEntry);
}
RandomAccessData lastKey = block.lastKey();
// If the requested key is greater than the last key within the block, then it
// does not exist.
if (RandomAccessData.UNSIGNED_LEXICOGRAPHICAL_COMPARATOR.compare(keyBytes, lastKey) > 0) {
return null;
}
Entry<RandomAccessData, WindowedValue<IsmRecord<V>>> rval = block.floorEntry(end);
// If the prefix matches completely then we can return
if (RandomAccessData.UNSIGNED_LEXICOGRAPHICAL_COMPARATOR.commonPrefixLength(
keyBytes, rval.getKey())
== keyBytes.size()) {
return rval.getValue();
}
return null;
}
@SuppressWarnings("Duplicates")
@Override
public void ack(Object msgId) {
long start = System.nanoTime();
ConsumerRecordMessageId consumerRecordMessageId = (ConsumerRecordMessageId) msgId;
TopicPartition topicPartition = consumerRecordMessageId.getTopicPartition();
if (!assignedPartitions.contains(topicPartition)) {
LOG.info("ignore {} because it's been revoked", consumerRecordMessageId);
return;
}
long offset = consumerRecordMessageId.getOffset();
ackRegistry.putIfAbsent(topicPartition, new TreeMap<>());
NavigableMap<Long, Long> navigableMap = ackRegistry.get(topicPartition);
Map.Entry<Long, Long> floorRange = navigableMap.floorEntry(offset);
Map.Entry<Long, Long> ceilingRange = navigableMap.ceilingEntry(offset);
long floorBottom = floorRange != null ? floorRange.getKey() : Long.MIN_VALUE;
long floorTop = floorRange != null ? floorRange.getValue() : Long.MIN_VALUE;
long ceilingBottom = ceilingRange != null ? ceilingRange.getKey() : Long.MAX_VALUE;
long ceilingTop = ceilingRange != null ? ceilingRange.getValue() : Long.MAX_VALUE;
//the ack is for a message that has already been acknowledged.
//This happens when a failed tuple has caused
//Kafka consumer to seek back to earlier position, and some messages are replayed.
if ((offset >= floorBottom && offset <= floorTop)
|| (offset >= ceilingBottom && offset <= ceilingTop)) {
return;
}
if (ceilingBottom - floorTop == 2) {
//the ack connects the two adjacent range
navigableMap.put(floorBottom, ceilingTop);
navigableMap.remove(ceilingBottom);
} else if (offset == floorTop + 1) {
//the acknowledged offset is the immediate neighbour
// of the upper bound of the floor range
navigableMap.put(floorBottom, offset);
} else if (offset == ceilingBottom - 1) {
//the acknowledged offset is the immediate neighbour
// of the lower bound of the ceiling range
navigableMap.remove(ceilingBottom);
navigableMap.put(offset, ceilingTop);
} else {
//it is a new born range
navigableMap.put(offset, offset);
}
LOG.debug("ack {} in {} ns", msgId, System.nanoTime() - start);
LOG.debug("{}", ackRegistry.get(consumerRecordMessageId.getTopicPartition()));
}
@Override
public List<Pair<LogMessage, AnnotationFS>> onValidate(TypeAdapter aAdapter, CAS aCas)
{
// If crossing sentence boundaries is permitted, then there is nothing to validate here
if (aAdapter.getLayer().isCrossSentence()) {
return emptyList();
}
Type type = getType(aCas, aAdapter.getAnnotationTypeName());
// If there are no annotations on this layer, nothing to do
Collection<AnnotationFS> annotations = select(aCas, type);
if (annotations.isEmpty()) {
return emptyList();
}
// Prepare feedback messsage list
List<Pair<LogMessage, AnnotationFS>> messages = new ArrayList<>();
// Build indexes to allow quickly looking up the sentence by its begin/end offsets. Since
// The indexes are navigable, we can also find the sentences starting/ending closes to a
// particular offset, even if it is not the start/end offset of a sentence.
NavigableMap<Integer, AnnotationFS> sentBeginIdx = new TreeMap<>();
NavigableMap<Integer, AnnotationFS> sentEndIdx = new TreeMap<>();
for (AnnotationFS sent : select(aCas, getType(aCas, Sentence.class))) {
sentBeginIdx.put(sent.getBegin(), sent);
sentEndIdx.put(sent.getEnd(), sent);
}
for (AnnotationFS fs : annotations) {
Entry<Integer, AnnotationFS> s1 = sentBeginIdx.floorEntry(fs.getBegin());
Entry<Integer, AnnotationFS> s2 = sentEndIdx.ceilingEntry(fs.getEnd());
if (s1 == null || s2 == null) {
messages.add(Pair.of(LogMessage.error(this,
"Unable to determine any sentences overlapping with [%d-%d]", fs.getBegin(),
fs.getEnd()), fs));
continue;
}
if (!WebAnnoCasUtil.isSame(s1.getValue(), s2.getValue())) {
messages.add(Pair.of(
LogMessage.error(this, "Crossing sentence boundaries is not permitted."),
fs));
}
}
return messages;
}
@Override
public List<Pair<LogMessage, AnnotationFS>> onValidate(TypeAdapter aAdapter, CAS aCas)
{
// If crossing sentence boundaries is permitted, then there is nothing to validate here
if (aAdapter.getLayer().isCrossSentence()) {
return emptyList();
}
RelationAdapter adapter = (RelationAdapter) aAdapter;
Type type = getType(aCas, aAdapter.getAnnotationTypeName());
Feature targetFeature = type.getFeatureByBaseName(adapter.getTargetFeatureName());
Feature sourceFeature = type.getFeatureByBaseName(adapter.getSourceFeatureName());
// If there are no annotations on this layer, nothing to do
Collection<AnnotationFS> annotations = select(aCas, type);
if (annotations.isEmpty()) {
return emptyList();
}
// Prepare feedback messsage list
List<Pair<LogMessage, AnnotationFS>> messages = new ArrayList<>();
// Build indexes to allow quickly looking up the sentence by its begin/end offsets. Since
// The indexes are navigable, we can also find the sentences starting/ending closes to a
// particular offset, even if it is not the start/end offset of a sentence.
NavigableMap<Integer, AnnotationFS> sentBeginIdx = new TreeMap<>();
NavigableMap<Integer, AnnotationFS> sentEndIdx = new TreeMap<>();
for (AnnotationFS sent : select(aCas, getType(aCas, Sentence.class))) {
sentBeginIdx.put(sent.getBegin(), sent);
sentEndIdx.put(sent.getEnd(), sent);
}
for (AnnotationFS fs : annotations) {
AnnotationFS sourceFs = (AnnotationFS) fs.getFeatureValue(sourceFeature);
AnnotationFS targetFs = (AnnotationFS) fs.getFeatureValue(targetFeature);
Entry<Integer, AnnotationFS> s1 = sentBeginIdx.floorEntry(sourceFs.getBegin());
Entry<Integer, AnnotationFS> s2 = sentEndIdx.ceilingEntry(targetFs.getEnd());
if (s1 == null || s2 == null) {
messages.add(Pair.of(LogMessage.error(this,
"Unable to determine any sentences overlapping with [%d-%d]",
sourceFs.getBegin(), targetFs.getEnd()), fs));
continue;
}
if (!WebAnnoCasUtil.isSame(s1.getValue(), s2.getValue())) {
messages.add(Pair.of(
LogMessage.error(this, "Crossing sentence boundaries is not permitted."),
fs));
}
}
return messages;
}
@VisibleForTesting
BigDecimal calculateSfdRate(Context context, Request request, boolean buy) {
if (FX_BTC_JPY != ProductType.find(request.getInstrument())) {
return ZERO;
}
BigDecimal sfdPct = getDecimalProperty(KEY_SFD_PCT, ONE);
if (sfdPct.signum() == 0) {
return ZERO;
}
Key key = Key.from(request);
BigDecimal fxPrice = buy ? context.getBestAskPrice(key) : context.getBestBidPrice(key);
if (fxPrice == null) {
return ZERO;
}
BigDecimal cashPrice = context.getLastPrice(Key.build(key).instrument(BTC_JPY.name()).build());
if (cashPrice == null || cashPrice.signum() == 0) {
return ZERO;
}
BigDecimal pct = fxPrice.divide(cashPrice, SCALE, HALF_UP).subtract(ONE);
BigDecimal adj = buy ? pct : pct.negate();
NavigableMap<BigDecimal, BigDecimal> table = getSfdTable();
Entry<BigDecimal, BigDecimal> floor = table.floorEntry(adj);
if (floor == null) {
return ZERO;
}
if (sfdPct.signum() > 0) {
return floor.getValue().multiply(sfdPct);
}
Entry<BigDecimal, BigDecimal> higher = table.higherEntry(adj);
if (higher == null) {
return floor.getValue().multiply(sfdPct.negate());
}
BigDecimal numerator = adj.subtract(floor.getKey()).multiply(higher.getValue().subtract(floor.getValue()));
BigDecimal denominator = higher.getKey().subtract(floor.getKey());
BigDecimal interpolated = floor.getValue().add(numerator.divide(denominator, SCALE, HALF_UP));
return interpolated.multiply(sfdPct.negate());
}