/** * <p>Tests whether the specified <code>number</code> occurs within * this range using <code>int</code> comparison.</p> * * <p><code>null</code> is handled and returns <code>false</code>.</p> * * @param number the number to test, may be <code>null</code> * @return <code>true</code> if the specified number occurs within this range */ public boolean containsNumber(Number number) { if (number == null) { return false; } return containsInteger(number.intValue()); }
@NotNull private static IntRange expand(@Nullable IntRange range, int value) { IntRange expandedRange; if (range != null) { int minorMinimum = range.getMinimumInteger(); int minorMaximum = range.getMaximumInteger(); if (value < minorMinimum) { expandedRange = new IntRange(value, minorMaximum); } else if (minorMaximum < value) { expandedRange = new IntRange(minorMinimum, value); } else { expandedRange = range; } } else { expandedRange = new IntRange(value, value); } return expandedRange; }
} else { @NotNull IntRange minorRange = MINOR_RANGE_BY_MAJOR.get(major); int minorMinimum = minorRange.getMinimumInteger(); int minorMaximum = minorRange.getMaximumInteger();
private static boolean validPortRange(int port) { return new IntRange(MIN_PORT, MAX_PORT).containsInteger(port); } }
ranges[0] = new IntRange(0, twentyPercent); ranges[1] = new IntRange(ranges[0].getMaximumInteger() + 1, ranges[0].getMaximumInteger() + twentyPercent); ranges[2] = new IntRange(ranges[1].getMaximumInteger() + 1, ranges[1].getMaximumInteger() + twentyPercent); ranges[3] = new IntRange(ranges[2].getMaximumInteger() + 1, ranges[2].getMaximumInteger() + twentyPercent); ranges[4] = new IntRange(ranges[3].getMaximumInteger() + 1, numLines); if (ranges[rIter].containsInteger(lr.getLineNumber())) { if (LOG.isDebugEnabled()) { LOG.debug("Line: " + lr.getLineNumber() + " within range[" + rIter + "]: " + ranges[rIter].toString());
public int getMinimumInt() { return range.getMinimumInteger(); }
public int getMaximumInt() { return range.getMaximumInteger(); }
public String debug() { String debug = "range=" + range.toString() + "steps=" + steps + "posVal=" + positionVal; return debug; } }
List<IntRange> ranges = new ArrayList<IntRange>() {{ add(new IntRange(0, 2)); add(new IntRange(2, 6)); add(new IntRange(6, 0)); }}; public boolean inRange(int n, List<IntRange> ranges) { for (IntRange range : ranges) { if (range.containsInteger(n)) { return true; } } return false; }
public void init(DataGeneratorSpec spec) throws IOException { genSpec = spec; outDir = new File(genSpec.getOutputDir()); if (outDir.exists() && !genSpec.isOverrideOutDir()) { LOGGER.error("output directory already exists, and override is set to false"); throw new RuntimeException("output directory exists"); } if (outDir.exists()) { FileUtils.deleteDirectory(outDir); } outDir.mkdir(); for (final String column : genSpec.getColumns()) { DataType dataType = genSpec.getDataTypesMap().get(column); if (genSpec.getCardinalityMap().containsKey(column)) { generators.put(column, GeneratorFactory.getGeneratorFor(dataType, genSpec.getCardinalityMap().get(column))); } else if (genSpec.getRangeMap().containsKey(column)) { IntRange range = genSpec.getRangeMap().get(column); generators.put(column, GeneratorFactory.getGeneratorFor(dataType, range.getMinimumInteger(), range.getMaximumInteger())); } else { LOGGER.error("cardinality for this column does not exist : " + column); throw new RuntimeException("cardinality for this column does not exist"); } generators.get(column).init(); } }
public static ArrayList<IntRange> sortIntRangeList(ArrayList<IntRange> inlist){ for(int counter=0; counter < inlist.size() -1; counter++) { //Loop once for each element in the array. for(int index=0; index < inlist.size() -1 -counter; index++) { //Once for each element, minus the counter. if(inlist.get(index).getMinimumInteger() > inlist.get(index + 1).getMinimumInteger()) { //Test if need a swap or not. IntRange temp = inlist.get(index); //These three lines just swap the two elements: inlist.set(index, inlist.get(index + 1)); inlist.set(index+1, temp); } } } return inlist; }
/** * <p>Tests whether the specified range occurs entirely within this range * using <code>int</code> comparison.</p> * * <p><code>null</code> is handled and returns <code>false</code>.</p> * * @param range the range to test, may be <code>null</code> * @return <code>true</code> if the specified range occurs entirely within this range * @throws IllegalArgumentException if the range is not of this type */ public boolean containsRange(Range range) { if (range == null) { return false; } return containsInteger(range.getMinimumInteger()) && containsInteger(range.getMaximumInteger()); }
private void buildCardinalityRangeMaps(String file, HashMap<String, Integer> cardinality, HashMap<String, IntRange> range) throws IOException { if (file == null) { return; // Nothing to do here. } List<SchemaAnnotation> saList = JsonUtils.fileToObject(new File(file), List.class); for (SchemaAnnotation sa : saList) { String column = sa.getColumn(); if (sa.isRange()) { range.put(column, new IntRange(sa.getRangeStart(), sa.getRangeEnd())); } else { cardinality.put(column, sa.getCardinality()); } } }
IntRange range = new IntRange(min, max); if(range.containsInteger(length))
ranges.add(new IntRange(pageNum)); return Integer.valueOf(a.getMinimumInteger()).compareTo(b.getMinimumInteger()); while ( !ranges.isEmpty() ) { IntRange nextRange = ranges.remove(0); if ( range.getMaximumInteger() == nextRange.getMinimumInteger() - 1 ) { range = new IntRange(range.getMinimumInteger(), nextRange.getMaximumInteger()); } else { output.add(range);
RangeUtils.sortIntRangeList(allPos); for(IntRange range: allPos){ posN += " " + (range.getMinimumInteger() + 1) + "-" + (range.getMaximumInteger() + 1) + ""; RangeUtils.sortIntRangeList(allPos); for(IntRange range: allPos){ pos1 += " " + (range.getMinimumInteger() + 1) + "-" + (range.getMaximumInteger() + 1) + "\\3"; RangeUtils.sortIntRangeList(allPos); for(IntRange range: allPos){ pos2 += " " + (range.getMinimumInteger() + 1) + "-" + (range.getMaximumInteger() + 1) + "\\3"; RangeUtils.sortIntRangeList(allPos); for(IntRange range: allPos){ pos3 += " " + (range.getMinimumInteger() + 1) + "-" + (range.getMaximumInteger() + 1) + "\\3";
@Override public String toString() { String retVal = "" + range.getMinimumInteger() + "-" + getMaximumInt(); // if steps (other than 1) are defined then add it if(steps != 1){ retVal += "\\" + steps; } return retVal; }
/** * <p>Tests whether the specified range overlaps with this range * using <code>int</code> comparison.</p> * * <p><code>null</code> is handled and returns <code>false</code>.</p> * * @param range the range to test, may be <code>null</code> * @return <code>true</code> if the specified range overlaps with this range */ public boolean overlapsRange(Range range) { if (range == null) { return false; } return range.containsInteger(min) || range.containsInteger(max) || containsInteger(range.getMinimumInteger()); }