protected String nextDataPoint()

in core/src/main/java/site/ycsb/workloads/TimeSeriesWorkload.java [1175:1286]
104 lines of code
26 McCabe index (conditional complexity)

    protected String nextDataPoint(final Map<String, ByteIterator> map, final boolean isInsert) {
      final Random random = ThreadLocalRandom.current();
      int iterations = sparsity <= 0 ? 1 : random.nextInt((int) ((double) perKeyCardinality * sparsity));
      if (iterations < 1) {
        iterations = 1;
      }
      while (true) {
        iterations--;
        if (rollover) {
          timestampGenerator.nextValue();
          rollover = false;
        }
        String key = null;
        if (iterations <= 0) {
          final TreeMap<String, String> validationTags;
          if (dataintegrity) {
            validationTags = new TreeMap<String, String>();
          } else {
            validationTags = null;
          }
          key = keys[keyIdx];
          int overallIdx = keyIdx * cumulativeCardinality[0];
          for (int i = 0; i < tagPairs; ++i) {
            int tvidx = tagValueIdxs[i];
            map.put(tagKeys[i], new StringByteIterator(tagValues[tvidx]));
            if (dataintegrity) {
              validationTags.put(tagKeys[i], tagValues[tvidx]);
            }
            if (delayedSeries > 0) {
              overallIdx += (tvidx * cumulativeCardinality[i + 1]);
            }
          }
          
          if (!isInsert) {
            final long delta = (timestampGenerator.currentValue() - startTimestamp) / timestampInterval;
            final int intervals = random.nextInt((int) delta);
            map.put(timestampKey, new NumericByteIterator(startTimestamp + (intervals * timestampInterval)));
          } else if (delayedSeries > 0) {
            // See if the series falls in a delay bucket and calculate an offset earlier
            // than the current timestamp value if so.
            double pct = (double) overallIdx / (double) totalCardinality;
            if (pct < delayedSeries) {
              int modulo = overallIdx % delayedIntervals;
              if (modulo < 0) {
                modulo *= -1;
              }
              map.put(timestampKey, new NumericByteIterator(timestampGenerator.currentValue() - 
                  timestampInterval * modulo));
            } else {
              map.put(timestampKey, new NumericByteIterator(timestampGenerator.currentValue()));
            }
          } else {
            map.put(timestampKey, new NumericByteIterator(timestampGenerator.currentValue()));
          }
          
          if (dataintegrity) {
            map.put(valueKey, new NumericByteIterator(validationFunction(key, 
                timestampGenerator.currentValue(), validationTags)));
          } else {
            switch (valueType) {
            case INTEGERS:
              map.put(valueKey, new NumericByteIterator(random.nextInt()));
              break;
            case FLOATS:
              map.put(valueKey, new NumericByteIterator(random.nextDouble() * (double) 100000));
              break;
            case MIXED:
              if (random.nextBoolean()) {
                map.put(valueKey, new NumericByteIterator(random.nextInt()));
              } else {
                map.put(valueKey, new NumericByteIterator(random.nextDouble() * (double) 100000));
              }
              break;
            default:
              throw new IllegalStateException("Somehow we didn't have a value "
                  + "type configured that we support: " + valueType);
            }        
          }
        }
        
        boolean tagRollover = false;
        for (int i = tagCardinality.length - 1; i >= 0; --i) {
          if (tagCardinality[i] <= 1) {
            tagRollover = true; // Only one tag so needs roll over.
            continue;
          }
          
          if (tagValueIdxs[i] + 1 >= tagCardinality[i]) {
            tagValueIdxs[i] = 0;
            if (i == firstIncrementableCardinality) {
              tagRollover = true;
            }
          } else {
            ++tagValueIdxs[i];
            break;
          }
        }
        
        if (tagRollover) {
          if (keyIdx + 1 >= keyIdxEnd) {
            keyIdx = keyIdxStart;
            rollover = true;
          } else {
            ++keyIdx;
          }
        }
        
        if (iterations <= 0) {
          return key;
        }
      }
    }