コード例 #1
0
  private void assertFurtherValuesSorting(final FDate key) {
    final FDate firstKey = extractKey(key, furtherValues.getHead());
    if (firstKey.compareTo(key) <= -1) {
      /*
       * readAllValuesAscendingFrom loads all data, thus we set the min key very deep so that later queries are
       * skipped if they are before minKey
       */
      minKey = minKey();
    }
    if (minKeyInDB == null || firstKey.compareTo(minKey) <= -1) {
      minKeyInDB = firstKey;
    }
    minKeyInDBFromLoadFurtherValues = FDates.min(minKeyInDBFromLoadFurtherValues, firstKey);
    final FDate lastKey = extractKey(key, furtherValues.getTail());
    if (maxKeyInDB == null || lastKey.compareTo(maxKeyInDB) <= -1) {
      maxKeyInDB = FDates.max(maxKeyInDB, lastKey);
    }
    maxKeyInDBFromLoadFurtherValues = FDates.max(maxKeyInDBFromLoadFurtherValues, lastKey);

    if (furtherValues.size() > 1) {
      Assertions.checkState(
          firstKey.compareTo(lastKey) <= 0,
          "Not ascending sorted! At firstKey [%s] and lastKey [%s]",
          firstKey,
          lastKey);
    }
  }
コード例 #2
0
 private V eventuallyGetMinValue(final FDate key, final boolean newMinKey) {
   // if key < minKey; use value for minKey
   if (minKeyInDB != null) {
     final boolean afterMinKey = !newMinKey && key.compareTo(minKey) >= 0;
     if (afterMinKey && key.compareTo(minKeyInDB) <= 0 && containsKey(minKey)) {
       // via readNewestValueTo
       return query().withFuture().getValue(minKey);
     }
     if (key.compareTo(minKeyInDB) <= 0 && containsKey(minKeyInDB)) {
       // via searchInFurtherValues
       return query().withFuture().getValue(minKeyInDB);
     }
   }
   return (V) null;
 }
コード例 #3
0
  private boolean shouldLoadFurtherValues(final FDate key, final boolean newMinKey) {
    if (furtherValues.isEmpty()) {
      final V tail = lastValuesFromFurtherValues.getTail();
      if (tail == null) {
        return true;
      }
      final V head = lastValuesFromFurtherValues.getHead();
      final FDate tailKey = extractKey(key, tail);
      final FDate headKey = extractKey(key, head);
      final boolean isEndReachedAnyway =
          tailKey.equals(maxKeyInDB)
              && key.isBeforeOrEqualTo(maxKeyInDB)
              && headKey.isBeforeOrEqualTo(key);
      return !isEndReachedAnyway;
    }
    final boolean keyIsBeforeMinKeyFromLoadFurtherValues =
        newMinKey && key.isBefore(minKeyInDBFromLoadFurtherValues);
    if (keyIsBeforeMinKeyFromLoadFurtherValues) {
      return true;
    }
    final boolean newMinKeyFromDBMayFindNewValues =
        isMinKeyInDBFromLoadFurtherValues() && key.compareTo(minKeyInDB) <= -1 && newMinKey;
    if (newMinKeyFromDBMayFindNewValues) {
      return true;
    }

    return false;
  }
コード例 #4
0
 private boolean eventuallyGetMaxKeyInDB(final FDate key, final boolean force) {
   // not updating highest allowed key, since this already happened during key adjustment
   final FDate newMaxKeyInDB = getAdjustKeyProvider().getHighestAllowedKey();
   if (newMaxKeyInDB != null) {
     if (newMaxKeyInDB.isAfter(maxKeyInDB)) {
       maxKeyInDB = newMaxKeyInDB;
       return true;
     } else {
       return false;
     }
   }
   // fallback to normal procedure if curHighWaterMark is not provided by provider
   if (maxKeyInDB == null || force) {
     final V maxValue = readNewestValueFromDB(maxKey());
     if (maxValue != null) {
       final FDate maxValueKey = extractKey(key, maxValue);
       if (maxKeyInDB == null || maxValueKey.compareTo(maxKeyInDB) <= -1) {
         maxKeyInDB = maxValueKey;
         getValuesMap().put(maxValueKey, maxValue);
         return true;
       }
     }
   }
   return false;
 }
コード例 #5
0
 private boolean updateMinKey(final FDate key) {
   if (minKey == null || key.compareTo(minKey) <= -1) {
     minKey = key;
     return true;
   } else {
     return false;
   }
 }
コード例 #6
0
 private boolean updateMaxKey(final FDate key) {
   if (maxKey == null || key.compareTo(maxKey) >= 1) {
     maxKey = key;
     return true;
   } else {
     return false;
   }
 }
コード例 #7
0
  private V loadFromCacheBeforeLoadFurtherValues(
      final FDate key, final boolean newMaxKey, final boolean newMinKey) {
    final V value = eventuallyGetMinValue(key, newMinKey);
    if (value != null) {
      return value;
    }

    // maybe use max value
    if (maxKeyInDB != null && key.compareTo(maxKeyInDB) >= 0 && containsKey(maxKeyInDB)) {
      return query().withFuture().getValue(maxKeyInDB);
    }
    return (V) null;
  }
コード例 #8
0
 private boolean eventuallyGetMinKeyInDB(final FDate key, final boolean force) {
   if (minKeyInDB == null || force) {
     final V minValue = readNewestValueFromDB(minKey());
     if (minValue != null) {
       final FDate minValueKey = extractKey(key, minValue);
       // min key must be kept intact if all values have been loaded from a later key
       if (minKeyInDB == null || minValueKey.compareTo(minKeyInDB) <= -1) {
         minKeyInDB = minValueKey;
         getValuesMap().put(minValueKey, minValue);
         return true;
       }
     }
   }
   return false;
 }
コード例 #9
0
  private V searchInFurtherValues(final FDate key) {
    // Take the first matching value from the sorted list
    // Search for the newest value
    V prevValue = (V) null;
    FDate prevKey = null;
    if (!lastValuesFromFurtherValues.isEmpty()) {
      // though maybe use the last one for smaller increments than the data itself is loaded
      for (final V lastValueFromFurtherValues : lastValuesFromFurtherValues) {
        final FDate keyLastValueFromFurtherValues = extractKey(key, lastValueFromFurtherValues);
        if (keyLastValueFromFurtherValues.isBeforeOrEqualTo(key)) {
          prevValue = lastValueFromFurtherValues;
          prevKey = keyLastValueFromFurtherValues;
        } else {
          // only go to further values if it might be possible that those are useable
          return prevValue;
        }
      }
    }

    final FDate earliestStartOfLoadFurtherValues = determineEaliestStartOfLoadFurtherValues(key);
    while (furtherValues.size() > 0) {
      final V newValue = furtherValues.getHead();
      final FDate newValueKey = extractKey(key, newValue);
      final int compare = key.compareTo(newValueKey);
      if (compare < 0) {
        // key < newValueKey
        // run over the key we wanted
        break;
      } else if (compare == 0) {
        // key == newValueKey
        // This is the value we searched for! It will later be added with the db key to the cache.
        pushLastValueFromFurtherValues();
        return newValue;
      } else {
        // key > newValueKey
        // put this value into the cache; gaps do not get filled here, so that the max size of the
        // cache does not get reached prematurely
        put(newValueKey, newValue, prevKey, prevValue);
        pushLastValueFromFurtherValues();
        // continue with the next one
        prevValue = newValue;
        prevKey = newValueKey;

        if (furtherValues.isEmpty()
            && newValueKey.isBefore(maxKeyInDB)
            && key.isBefore(maxKeyInDB)
            && maxKeyInDBFromLoadFurtherValues.isBefore(maxKeyInDB)) {
          final FDate timeForLoadFurtherValues =
              FDates.max(newValueKey, earliestStartOfLoadFurtherValues);
          Assertions.checkState(
              eventuallyLoadFurtherValues(
                  "searchInFurtherValues", newValueKey, timeForLoadFurtherValues, false, true));
          if (!furtherValues.isEmpty()) {
            pushLastValueFromFurtherValues();
            if (!timeForLoadFurtherValues.equals(newValue)) {
              // do not distort prev/next lookup when using earlisetStartOfLoadFurtherValues, thus
              // reset those
              prevValue = null;
              prevKey = null;
            }
          }
        }
      }
    }
    return prevValue;
  }