com.google.common.collect.TreeRangeMap Java Examples

/** Construct replacements to fix unused imports. */
private static RangeMap<Integer, String> buildReplacements(
    String contents,
    JCCompilationUnit unit,
    Set<String> usedNames,
    Multimap<String, Range<Integer>> usedInJavadoc) {
  RangeMap<Integer, String> replacements = TreeRangeMap.create();
  for (JCImport importTree : unit.getImports()) {
    String simpleName = getSimpleName(importTree);
    if (!isUnused(unit, usedNames, usedInJavadoc, importTree, simpleName)) {
      continue;
    }
    // delete the import
    int endPosition = importTree.getEndPosition(unit.endPositions);
    endPosition = Math.max(CharMatcher.isNot(' ').indexIn(contents, endPosition), endPosition);
    String sep = Newlines.guessLineSeparator(contents);
    if (endPosition + sep.length() < contents.length()
        && contents.subSequence(endPosition, endPosition + sep.length()).toString().equals(sep)) {
      endPosition += sep.length();
    }
    replacements.put(Range.closedOpen(importTree.getStartPosition(), endPosition), "");
  }
  return replacements;
}
 

/** Applies replacements to the given string. */
private static String applyReplacements(
    String javaInput, TreeRangeMap<Integer, String> replacementMap) throws FormatterException {
  // process in descending order so the replacement ranges aren't perturbed if any replacements
  // differ in size from the input
  Map<Range<Integer>, String> ranges = replacementMap.asDescendingMapOfRanges();
  if (ranges.isEmpty()) {
    return javaInput;
  }
  StringBuilder sb = new StringBuilder(javaInput);
  for (Map.Entry<Range<Integer>, String> entry : ranges.entrySet()) {
    Range<Integer> range = entry.getKey();
    sb.replace(range.lowerEndpoint(), range.upperEndpoint(), entry.getValue());
  }
  return sb.toString();
}
 

public static void main(String[] args) {

		// define rages for checks
		RangeMap<Integer, Double> checkFee = TreeRangeMap.create();
		checkFee.put(Range.closed(0, 19), .1);
		checkFee.put(Range.closed(20, 39), .8);
		checkFee.put(Range.closed(40, 59), .6);
		checkFee.put(Range.closed(60, Integer.MAX_VALUE), .4);

		// Create a Scanner object for keyboard input.
		Scanner keyboard = new Scanner(System.in);

		// Get the number of checks written.
		System.out.print("Enter the number of checks written " + "this month: ");
		int numChecks = keyboard.nextInt();

		//close scanner
		keyboard.close();

		// calculate total fee
		double total = BASE_FEE + (checkFee.get(numChecks) * numChecks); 
		
		// Display the total bank fees.
		System.out.printf("The total fees are $%.2f\n", total);
	}
 

@Test
public void givenRangeMap_whenSubRangeMapIsCalled_returnsSubRangeSucessfully() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(8, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
    final RangeMap<Integer, String> experiencedSubRangeDesignationMap = experienceRangeDesignationMap.subRangeMap(Range.closed(4, 14));

    assertNull(experiencedSubRangeDesignationMap.get(3));
    assertTrue(experiencedSubRangeDesignationMap.asMapOfRanges().values()
        .containsAll(Arrays.asList("Executive Director", "Vice President", "Executive Director")));
    
}
 

@Test
public void givenRangeMap_whenRemoveRangeIsCalled_removesSucessfully() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
    experienceRangeDesignationMap.remove(Range.closed(8, 15));
    experienceRangeDesignationMap.remove(Range.closed(20, 26));

    assertNull(experienceRangeDesignationMap.get(9));
    assertEquals("Managing Director", experienceRangeDesignationMap.get(16));
    assertEquals("Managing Director", experienceRangeDesignationMap.get(30));
    assertNull(experienceRangeDesignationMap.get(25));
}
 

static
private RangeMap<Double, Object> parseDiscretize(Discretize discretize){
	RangeMap<Double, Object> result = TreeRangeMap.create();

	List<DiscretizeBin> discretizeBins = discretize.getDiscretizeBins();
	for(DiscretizeBin discretizeBin : discretizeBins){
		Interval interval = discretizeBin.getInterval();
		if(interval == null){
			throw new MissingElementException(discretizeBin, PMMLElements.DISCRETIZEBIN_INTERVAL);
		}

		Range<Double> range = toRange(interval);

		Object binValue = discretizeBin.getBinValue();
		if(binValue == null){
			throw new MissingAttributeException(discretizeBin, PMMLAttributes.DISCRETIZEBIN_BINVALUE);
		}

		result.put(range, binValue);
	}

	return result;
}
 

/**
 * Create {@link HomRefBlock}s which will collectively accept variants of any genotype quality
 *
 * Each individual block covers a band of tumor LODs with the splits between bands occurring at values in {@code gqPartitions}.
 * There will be {@code gqPartitions.size() +1} bands produced
 *
 * @param gqPartitions proposed TLOD partitions as Doubles in LOD-space
 * @return a list of HomRefBlocks accepting bands of genotypes qualities split at the points specified in gqPartitions
 */
@Override
@VisibleForTesting
RangeMap<Integer,Range<Integer>> parsePartitions(final List<Number> gqPartitions) {
    partitionPrecision = calculatePartitionPrecision(gqPartitions);
    Utils.nonEmpty(gqPartitions);
    Utils.containsNoNull(gqPartitions, "The list of TLOD partitions contains a null integer");
    final RangeMap<Integer, Range<Integer>> result = TreeRangeMap.create();
    int lastThreshold = Integer.MIN_VALUE;
    for (final Number num : gqPartitions) {
        final double value = num.doubleValue();
        final int intThreshold = convertLODtoInt(value, partitionPrecision);
        result.put(Range.closedOpen(lastThreshold, intThreshold), Range.closedOpen(lastThreshold, intThreshold));
        lastThreshold = intThreshold;
    }
    result.put(Range.closedOpen(lastThreshold, Integer.MAX_VALUE), Range.closedOpen(lastThreshold, Integer.MAX_VALUE));
    return result;
}
 

/** Applies replacements to the given string. */
private static JavaInput applyReplacements(
    JavaInput javaInput, TreeRangeMap<Integer, String> replacementMap) throws FormatterException {
  // process in descending order so the replacement ranges aren't perturbed if any replacements
  // differ in size from the input
  Map<Range<Integer>, String> ranges = replacementMap.asDescendingMapOfRanges();
  if (ranges.isEmpty()) {
    return javaInput;
  }
  StringBuilder sb = new StringBuilder(javaInput.getText());
  for (Entry<Range<Integer>, String> entry : ranges.entrySet()) {
    Range<Integer> range = entry.getKey();
    sb.replace(range.lowerEndpoint(), range.upperEndpoint(), entry.getValue());
  }
  return new JavaInput(sb.toString());
}
 

/**
 * Applies replacements to the given string.
 */
private static JavaInput applyReplacements(
        JavaInput javaInput, TreeRangeMap<Integer, String> replacementMap) throws FormatterException {
    // process in descending order so the replacement ranges aren't perturbed if any replacements
    // differ in size from the input
    Map<Range<Integer>, String> ranges = replacementMap.asDescendingMapOfRanges();
    if (ranges.isEmpty()) {
        return javaInput;
    }
    StringBuilder sb = new StringBuilder(javaInput.getText());
    for (Entry<Range<Integer>, String> entry : ranges.entrySet()) {
        Range<Integer> range = entry.getKey();
        sb.replace(range.lowerEndpoint(), range.upperEndpoint(), entry.getValue());
    }
    return new JavaInput(sb.toString());
}
 

/** Constructs an empty Distribution with the specified {@link DistributionFitter}. */
public MutableDistribution(DistributionFitter distributionFitter) {
  this.distributionFitter = checkNotNull(distributionFitter);
  ImmutableSortedSet<Double> boundaries = distributionFitter.boundaries();

  checkArgument(boundaries.size() > 0);
  checkArgument(Ordering.natural().isOrdered(boundaries));

  this.intervalCounts = TreeRangeMap.create();

  double[] boundariesArray = Doubles.toArray(distributionFitter.boundaries());

  // Add underflow and overflow intervals
  this.intervalCounts.put(Range.lessThan(boundariesArray[0]), 0L);
  this.intervalCounts.put(Range.atLeast(boundariesArray[boundariesArray.length - 1]), 0L);

  // Add finite intervals
  for (int i = 1; i < boundariesArray.length; i++) {
    this.intervalCounts.put(Range.closedOpen(boundariesArray[i - 1], boundariesArray[i]), 0L);
  }
}
 

/**
 * Applies replacements to the given string.
 */
private static JavaInput applyReplacements(
        JavaInput javaInput, TreeRangeMap<Integer, String> replacementMap) throws FormatterException {
    // process in descending order so the replacement ranges aren't perturbed if any replacements
    // differ in size from the input
    Map<Range<Integer>, String> ranges = replacementMap.asDescendingMapOfRanges();
    if (ranges.isEmpty()) {
        return javaInput;
    }
    StringBuilder sb = new StringBuilder(javaInput.getText());
    for (Entry<Range<Integer>, String> entry : ranges.entrySet()) {
        Range<Integer> range = entry.getKey();
        sb.replace(range.lowerEndpoint(), range.upperEndpoint(), entry.getValue());
    }
    return new JavaInput(sb.toString());
}
 

public RegionCache(ReadOnlyPDClient pdClient) {
  regionCache = new HashMap<>();
  storeCache = new HashMap<>();

  keyToRegionIdCache = TreeRangeMap.create();
  this.pdClient = pdClient;
}
 

@Test
public void google_guava_range_map_example () {

	RangeMap<Integer, String> gradeScale = TreeRangeMap.create();
	gradeScale.put(Range.closed(0, 60), "F");
	gradeScale.put(Range.closed(61, 70), "D");
	gradeScale.put(Range.closed(71, 80), "C");
	gradeScale.put(Range.closed(81, 90), "B");
	gradeScale.put(Range.closed(91, 100), "A");
	
	String grade = gradeScale.get(77);
	
	assertEquals("C", grade);
}
 

/**
 * Reflows string literals in the given Java source code that extend past the given column limit.
 */
static String wrap(final int columnLimit, String input, Formatter formatter)
    throws FormatterException {
  if (!longLines(columnLimit, input)) {
    // fast path
    return input;
  }

  TreeRangeMap<Integer, String> replacements = getReflowReplacements(columnLimit, input);
  String firstPass = formatter.formatSource(input, replacements.asMapOfRanges().keySet());

  if (!firstPass.equals(input)) {
    // If formatting the replacement ranges resulted in a change, recalculate the replacements on
    // the updated input.
    input = firstPass;
    replacements = getReflowReplacements(columnLimit, input);
  }

  String result = applyReplacements(input, replacements);

  {
    // We really don't want bugs in this pass to change the behaviour of programs we're
    // formatting, so check that the pretty-printed AST is the same before and after reformatting.
    String expected = parse(input, /* allowStringFolding= */ true).toString();
    String actual = parse(result, /* allowStringFolding= */ true).toString();
    if (!expected.equals(actual)) {
      throw new FormatterException(
          String.format(
              "Something has gone terribly wrong. Please file a bug: "
                  + "https://github.com/google/google-java-format/issues/new"
                  + "\n\n=== Actual: ===\n%s\n=== Expected: ===\n%s\n",
              actual, expected));
    }
  }

  return result;
}
 

public RegionCache(ReadOnlyPDClient pdClient) {
  regionCache = new HashMap<>();
  storeCache = new HashMap<>();

  keyToRegionIdCache = TreeRangeMap.create();
  this.pdClient = pdClient;
}
 

/**
 * Create {@link HomRefBlock}s which will collectively accept variants of any genotype quality
 *
 * Each individual block covers a band of genotype qualities with the splits between bands occurring at values in {@code gqPartitions}.
 * There will be {@code gqPartitions.size() +1} bands produced covering the entire possible range of genotype qualities from 0 to {@link VCFConstants#MAX_GENOTYPE_QUAL}.
 *
 * Note that this has to return a RangeMap with concrete types because Numbers aren't Comparable
 *
 * @param gqPartitions proposed GQ partitions
 * @return a list of HomRefBlocks accepting bands of genotypes qualities split at the points specified in gqPartitions
 */
@VisibleForTesting
RangeMap<Integer,Range<Integer>> parsePartitions(final List<Number> gqPartitions) {
    Utils.nonEmpty(gqPartitions);
    Utils.containsNoNull(gqPartitions, "The list of GQ partitions contains a null integer");
    final RangeMap<Integer, Range<Integer>> result = TreeRangeMap.create();
    int lastThreshold = 0;
    for (final Number num : gqPartitions) {
        final int value = num.intValue();
        if (value < 0) {
            throw new IllegalArgumentException("The list of GQ partitions contains a non-positive integer.");
        } else if (value > MAX_GENOTYPE_QUAL + 1) {
            throw new IllegalArgumentException(String.format("The value %d in the list of GQ partitions is greater than VCFConstants.MAX_GENOTYPE_QUAL + 1 = %d.", value, MAX_GENOTYPE_QUAL + 1));
        } else if (value < lastThreshold) {
            throw new IllegalArgumentException(String.format("The list of GQ partitions is out of order. Previous value is %d but the next is %d.", lastThreshold, value));
        } else if (value == lastThreshold) {
            throw new IllegalArgumentException(String.format("The value %d appears more than once in the list of GQ partitions.", value));
        }

        result.put(Range.closedOpen(lastThreshold, value), Range.closedOpen(lastThreshold, value));
        lastThreshold = value;
    }

    if (lastThreshold <= MAX_GENOTYPE_QUAL) {
        result.put(Range.closedOpen(lastThreshold, MAX_GENOTYPE_QUAL + 1), Range.closedOpen(lastThreshold,MAX_GENOTYPE_QUAL + 1));
    }

    return result;
}
 

private DescriptionBasedDiff(JCCompilationUnit compilationUnit) {
  this.compilationUnit = checkNotNull(compilationUnit);
  this.sourcePath = compilationUnit.getSourceFile().toUri().getPath();
  this.importsToAdd = new HashSet<>();
  this.importsToRemove = new HashSet<>();
  this.endPosMap = JDKCompatible.getEndPosMap(compilationUnit);
  this.replacements = TreeRangeMap.create();
}
 

@Test
public void givenRangeMap_whenGetEntryIsCalled_returnsEntrySucessfully() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(20, 30), "Managing Director");
    final Map.Entry<Range<Integer>, String> experiencEntry = experienceRangeDesignationMap.getEntry(10);

    assertEquals(Range.closed(9, 15), experiencEntry.getKey());
    assertEquals("Executive Director", experiencEntry.getValue());
}
 

@Test
public void givenRangeMap_whenVerifying_thenShouldBeCorrect() throws Exception {
    final TreeRangeMap<Integer, String> map = TreeRangeMap.create();

    map.put(Range.closed(0, 60), "F");
    map.put(Range.closed(61, 70), "D");

    assertThat(map).isNotEmpty().containsKeys(0).contains(MapEntry.entry(34, "F"));
}
 

@Test
public void givenRangeMap_whenQueryWithinRange_returnsSucessfully() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");

    assertEquals("Vice President", experienceRangeDesignationMap.get(6));
    assertEquals("Executive Director", experienceRangeDesignationMap.get(15));
}
 

@Test
public void givenRangeMap_whenQueryOutsideRange_returnsNull() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");

    assertNull(experienceRangeDesignationMap.get(31));
}
 

@Test
public void givenRangeMap_whenSpanIsCalled_returnsSucessfully() {
    final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();

    experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
    experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
    experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
    experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
    experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
    final Range<Integer> experienceSpan = experienceRangeDesignationMap.span();

    assertEquals(0, experienceSpan.lowerEndpoint().intValue());
    assertEquals(30, experienceSpan.upperEndpoint().intValue());
}
 

/**
 * Reorders all modifiers in the given text and within the given character ranges to be in JLS
 * order.
 */
static JavaInput reorderModifiers(JavaInput javaInput, Collection<Range<Integer>> characterRanges)
        throws FormatterException {
    if (javaInput.getTokens().isEmpty()) {
        // There weren't any tokens, possible because of a lexing error.
        // Errors about invalid input will be reported later after parsing.
        return javaInput;
    }
    RangeSet<Integer> tokenRanges = javaInput.characterRangesToTokenRanges(characterRanges);
    Iterator<? extends Token> it = javaInput.getTokens().iterator();
    TreeRangeMap<Integer, String> replacements = TreeRangeMap.create();
    while (it.hasNext()) {
        Token token = it.next();
        if (!tokenRanges.contains(token.getTok().getIndex())) {
            continue;
        }
        Modifier mod = asModifier(token);
        if (mod == null) {
            continue;
        }

        List<Token> modifierTokens = new ArrayList<>();
        List<Modifier> mods = new ArrayList<>();

        int begin = token.getTok().getPosition();
        mods.add(mod);
        modifierTokens.add(token);

        int end = -1;
        while (it.hasNext()) {
            token = it.next();
            mod = asModifier(token);
            if (mod == null) {
                break;
            }
            mods.add(mod);
            modifierTokens.add(token);
            end = token.getTok().getPosition() + token.getTok().length();
        }

        if (!Ordering.natural().isOrdered(mods)) {
            Collections.sort(mods);
            StringBuilder replacement = new StringBuilder();
            for (int i = 0; i < mods.size(); i++) {
                if (i > 0) {
                    addTrivia(replacement, modifierTokens.get(i).getToksBefore());
                }
                replacement.append(mods.get(i).toString());
                if (i < (modifierTokens.size() - 1)) {
                    addTrivia(replacement, modifierTokens.get(i).getToksAfter());
                }
            }
            replacements.put(Range.closedOpen(begin, end), replacement.toString());
        }
    }
    return applyReplacements(javaInput, replacements);
}
 

/**
 * 以Guava TreeRangeMap实现的, 一段范围的Key指向同一个Value的Map
 */
@SuppressWarnings("rawtypes")
public static <K extends Comparable, V> TreeRangeMap<K, V> createRangeMap() {
	return TreeRangeMap.create();
}
 

/**
 * 以Guava TreeRangeMap实现的, 一段范围的Key指向同一个Value的Map
 */
@SuppressWarnings("rawtypes")
public static <K extends Comparable, V> TreeRangeMap<K, V> createRangeMap() {
	return TreeRangeMap.create();
}
 

private MetricRetention(String function) {
    this.function = function;
    this.ranges = TreeRangeMap.create();
}
 

/**
 * Reorders all modifiers in the given text and within the given character ranges to be in JLS
 * order.
 */
static JavaInput reorderModifiers(JavaInput javaInput, Collection<Range<Integer>> characterRanges)
    throws FormatterException {
  if (javaInput.getTokens().isEmpty()) {
    // There weren't any tokens, possible because of a lexing error.
    // Errors about invalid input will be reported later after parsing.
    return javaInput;
  }
  RangeSet<Integer> tokenRanges = javaInput.characterRangesToTokenRanges(characterRanges);
  Iterator<? extends Token> it = javaInput.getTokens().iterator();
  TreeRangeMap<Integer, String> replacements = TreeRangeMap.create();
  while (it.hasNext()) {
    Token token = it.next();
    if (!tokenRanges.contains(token.getTok().getIndex())) {
      continue;
    }
    Modifier mod = asModifier(token);
    if (mod == null) {
      continue;
    }

    List<Token> modifierTokens = new ArrayList<>();
    List<Modifier> mods = new ArrayList<>();

    int begin = token.getTok().getPosition();
    mods.add(mod);
    modifierTokens.add(token);

    int end = -1;
    while (it.hasNext()) {
      token = it.next();
      mod = asModifier(token);
      if (mod == null) {
        break;
      }
      mods.add(mod);
      modifierTokens.add(token);
      end = token.getTok().getPosition() + token.getTok().length();
    }

    if (!Ordering.natural().isOrdered(mods)) {
      Collections.sort(mods);
      StringBuilder replacement = new StringBuilder();
      for (int i = 0; i < mods.size(); i++) {
        if (i > 0) {
          addTrivia(replacement, modifierTokens.get(i).getToksBefore());
        }
        replacement.append(mods.get(i).toString());
        if (i < (modifierTokens.size() - 1)) {
          addTrivia(replacement, modifierTokens.get(i).getToksAfter());
        }
      }
      replacements.put(Range.closedOpen(begin, end), replacement.toString());
    }
  }
  return applyReplacements(javaInput, replacements);
}
 

/**
 * Reorders all modifiers in the given text and within the given character ranges to be in JLS
 * order.
 */
static JavaInput reorderModifiers(JavaInput javaInput, Collection<Range<Integer>> characterRanges)
        throws FormatterException {
    if (javaInput.getTokens().isEmpty()) {
        // There weren't any tokens, possible because of a lexing error.
        // Errors about invalid input will be reported later after parsing.
        return javaInput;
    }
    RangeSet<Integer> tokenRanges = javaInput.characterRangesToTokenRanges(characterRanges);
    Iterator<? extends Token> it = javaInput.getTokens().iterator();
    TreeRangeMap<Integer, String> replacements = TreeRangeMap.create();
    while (it.hasNext()) {
        Token token = it.next();
        if (!tokenRanges.contains(token.getTok().getIndex())) {
            continue;
        }
        Modifier mod = asModifier(token);
        if (mod == null) {
            continue;
        }

        List<Token> modifierTokens = new ArrayList<>();
        List<Modifier> mods = new ArrayList<>();

        int begin = token.getTok().getPosition();
        mods.add(mod);
        modifierTokens.add(token);

        int end = -1;
        while (it.hasNext()) {
            token = it.next();
            mod = asModifier(token);
            if (mod == null) {
                break;
            }
            mods.add(mod);
            modifierTokens.add(token);
            end = token.getTok().getPosition() + token.getTok().length();
        }

        if (!Ordering.natural().isOrdered(mods)) {
            Collections.sort(mods);
            StringBuilder replacement = new StringBuilder();
            for (int i = 0; i < mods.size(); i++) {
                if (i > 0) {
                    addTrivia(replacement, modifierTokens.get(i).getToksBefore());
                }
                replacement.append(mods.get(i).toString());
                if (i < (modifierTokens.size() - 1)) {
                    addTrivia(replacement, modifierTokens.get(i).getToksAfter());
                }
            }
            replacements.put(Range.closedOpen(begin, end), replacement.toString());
        }
    }
    return applyReplacements(javaInput, replacements);
}