Example usage for com.google.common.collect Range hasUpperBound

Introduction

In this page you can find the example usage for com.google.common.collect Range hasUpperBound.

Prototype

public boolean hasUpperBound() 

Source Link

Document

Returns true if this range has an upper endpoint.

Usage

From source file:org.apache.kylin.common.util.RangeUtil.java

public static String formatTsRange(Range<Long> tsRange) {
    if (tsRange == null)
        return null;

    StringBuilder sb = new StringBuilder();
    if (tsRange.hasLowerBound()) {
        if (tsRange.lowerBoundType() == BoundType.CLOSED) {
            sb.append("[");
        } else {/*w  w  w. j  ava 2s .  co  m*/
            sb.append("(");
        }
        sb.append(DateFormat.formatToTimeStr(tsRange.lowerEndpoint()));
    } else {
        sb.append("(-");
    }

    sb.append("~");

    if (tsRange.hasUpperBound()) {
        sb.append(DateFormat.formatToTimeStr(tsRange.upperEndpoint()));
        if (tsRange.upperBoundType() == BoundType.CLOSED) {
            sb.append("]");
        } else {
            sb.append(")");
        }
    } else {
        sb.append("+)");
    }
    return sb.toString();
}

---

From source file:com.stackframe.collect.RangeUtilities.java

/**
 * Build an expression suitable for passing to JDBC as part of an SQL query from a date range.
 *
 * @param column the name of the column/*from  ww w .j a va  2 s.  c  om*/
 * @param dateRange the Range
 * @return a String containing the expression
 */
public static String toSQL(String column, Range<Date> dateRange) {
    StringBuilder buf = new StringBuilder();
    if (dateRange.hasLowerBound()) {
        BoundType lowerBound = dateRange.lowerBoundType();
        String operator;
        switch (lowerBound) {
        case CLOSED:
            operator = ">=";
            break;
        case OPEN:
            operator = ">";
            break;
        default:
            throw new AssertionError("unexpected bound type " + lowerBound);
        }

        Date lowerEndpoint = dateRange.lowerEndpoint();
        java.sql.Date lowerDate = convert(lowerEndpoint);
        buf.append(String.format("%s %s '%s'", column, operator, lowerDate.toString()));
        if (dateRange.hasUpperBound()) {
            buf.append(" AND ");
        }
    }

    if (dateRange.hasUpperBound()) {
        BoundType upperBound = dateRange.upperBoundType();
        String operator;
        switch (upperBound) {
        case CLOSED:
            operator = "<=";
            break;
        case OPEN:
            operator = "<";
            break;
        default:
            throw new AssertionError("unexpected bound type " + upperBound);
        }

        Date upperEndpoint = dateRange.upperEndpoint();
        java.sql.Date upperDate = convert(upperEndpoint);
        buf.append(String.format("%s %s '%s'", column, operator, upperDate.toString()));
    }

    return buf.toString();
}

---

From source file:com.tinspx.util.io.callbacks.FileChannelCallback.java

/**
 * Normalizes lower bound to a closed bound type (if exists) and the
 * upper bound to an open bound type (if exists). Missing bounds remain
 * missing. Lower bound must be non-negative and upper bound must be
 * positive. The range cannot be empty./*from w w  w.j  ava2s  .  c  om*/
 */
static Range<Long> checkAndNormalize(Range<Long> range) {
    checkArgument(!range.isEmpty(), "range %s is empty", range);
    boolean make = false;
    long lower = -1;
    long upper = -1;

    if (range.hasLowerBound()) {
        lower = range.lowerEndpoint();
        if (range.lowerBoundType() == BoundType.OPEN) {
            make = true;
            lower++;
        }
        checkArgument(lower >= 0, "closed lower bound (%s) may not be negative", lower);
    }
    if (range.hasUpperBound()) {
        upper = range.upperEndpoint();
        if (range.upperBoundType() == BoundType.CLOSED) {
            make = true;
            upper++;
        }
        checkArgument(upper > 0, "open upper bound (%s) must be positive", upper);
    }
    if (make) {
        if (lower >= 0) {
            if (upper > 0) {
                range = Range.closedOpen(lower, upper);
            } else {
                range = Range.atLeast(lower);
            }
        } else {
            assert upper > 0 : upper;
            range = Range.lessThan(upper);
        }
        checkArgument(!range.isEmpty(), "normalized range %s is empty", range);
    }
    return range;
}

---

From source file:org.apache.hadoop.hive.ql.optimizer.calcite.druid.DruidIntervalUtils.java

protected static List<Range> condenseRanges(List<Range> ranges) {
    if (ranges.size() <= 1) {
        return ranges;
    }//ww w  .j  a  va  2s. co  m

    Comparator<Range> startThenEnd = new Comparator<Range>() {
        @Override
        public int compare(Range lhs, Range rhs) {
            int compare = 0;
            if (lhs.hasLowerBound() && rhs.hasLowerBound()) {
                compare = lhs.lowerEndpoint().compareTo(rhs.lowerEndpoint());
            } else if (!lhs.hasLowerBound() && rhs.hasLowerBound()) {
                compare = -1;
            } else if (lhs.hasLowerBound() && !rhs.hasLowerBound()) {
                compare = 1;
            }
            if (compare != 0) {
                return compare;
            }
            if (lhs.hasUpperBound() && rhs.hasUpperBound()) {
                compare = lhs.upperEndpoint().compareTo(rhs.upperEndpoint());
            } else if (!lhs.hasUpperBound() && rhs.hasUpperBound()) {
                compare = -1;
            } else if (lhs.hasUpperBound() && !rhs.hasUpperBound()) {
                compare = 1;
            }
            return compare;
        }
    };

    TreeSet<Range> sortedIntervals = Sets.newTreeSet(startThenEnd);
    sortedIntervals.addAll(ranges);

    List<Range> retVal = Lists.newArrayList();

    Iterator<Range> intervalsIter = sortedIntervals.iterator();
    Range currInterval = intervalsIter.next();
    while (intervalsIter.hasNext()) {
        Range next = intervalsIter.next();
        if (currInterval.encloses(next)) {
            continue;
        }
        if (mergeable(currInterval, next)) {
            currInterval = currInterval.span(next);
        } else {
            retVal.add(currInterval);
            currInterval = next;
        }
    }
    retVal.add(currInterval);

    return retVal;
}

---

From source file:org.apache.kylin.metadata.realization.SQLDigestUtil.java

private static TupleFilter createFilterForRealtime(TupleFilter originFilter, TblColRef partitionColRef,
        Range<Long> tsRange) {
    DataType type = partitionColRef.getColumnDesc().getType();

    String startTimeStr, endTimeStr;
    CompareTupleFilter startFilter = null, endFilter = null;
    if (tsRange.hasLowerBound()) {
        startTimeStr = formatTimeStr(type, tsRange.lowerEndpoint());
        if (tsRange.lowerBoundType() == BoundType.CLOSED) {
            startFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.GTE);
        } else {/*from  ww w .j av  a2 s .  c om*/
            startFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.GT);
        }
        ColumnTupleFilter columnTupleFilter = new ColumnTupleFilter(partitionColRef);
        ConstantTupleFilter constantTupleFilter = new ConstantTupleFilter(startTimeStr);
        startFilter.addChild(columnTupleFilter);
        startFilter.addChild(constantTupleFilter);
    }

    if (tsRange.hasUpperBound()) {
        endTimeStr = formatTimeStr(type, tsRange.upperEndpoint());
        if (tsRange.upperBoundType() == BoundType.CLOSED) {
            endFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.LTE);
        } else {
            endFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.LT);
        }
        ColumnTupleFilter columnTupleFilter = new ColumnTupleFilter(partitionColRef);
        ConstantTupleFilter constantTupleFilter = new ConstantTupleFilter(endTimeStr);
        endFilter.addChild(columnTupleFilter);
        endFilter.addChild(constantTupleFilter);
    }

    if (originFilter == null) {
        if (endFilter == null) {
            return startFilter;
        }
        if (startFilter == null) {
            return endFilter;
        }
    }

    LogicalTupleFilter logicalTupleFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND);

    if (originFilter != null) {
        logicalTupleFilter.addChild(originFilter);
    }
    if (startFilter != null) {
        logicalTupleFilter.addChild(startFilter);
    }
    if (endFilter != null) {
        logicalTupleFilter.addChild(endFilter);
    }

    return logicalTupleFilter;
}

---

From source file:com.axemblr.provisionr.api.network.RuleBuilder.java

public RuleBuilder ports(Range<Integer> ports) {
    checkArgument(ports.hasUpperBound(), "ports should have a closed upper bound");
    checkArgument(ports.hasLowerBound(), "ports should have a closed lower bound ");

    checkArgument(ports.lowerEndpoint() > 0, "ports should be a positive range");
    checkArgument(ports.upperEndpoint() < 65535, "ports upper bound should less than 65535");

    this.ports = checkNotNull(ports, "ports is null");
    return this;
}

---

From source file:org.apache.provisionr.api.network.RuleBuilder.java

public RuleBuilder ports(Range<Integer> ports) {
    checkArgument(ports.hasUpperBound(), "ports should have a closed upper bound");
    checkArgument(ports.hasLowerBound(), "ports should have a closed lower bound ");

    checkArgument(ports.lowerEndpoint() > 0, "ports should be a positive range");
    checkArgument(ports.upperEndpoint() < Machine.MAX_PORT_NUMBER, "ports upper bound should less than 65535");

    this.ports = checkNotNull(ports, "ports is null");
    return this;
}

---

From source file:org.openmhealth.shimmer.common.transformer.FixedTimeZoneDateTimeRangeTransformer.java

@Override
public Range<OffsetDateTime> transformRange(Range<OffsetDateTime> inputRange) {

    if (inputRange.hasLowerBound() && inputRange.hasUpperBound()) {
        return Range.closedOpen(toFixedTimeZone(inputRange.lowerEndpoint()),
                toFixedTimeZone(inputRange.upperEndpoint()));
    }/*w  ww .j a v  a 2s. c  o m*/

    if (inputRange.hasLowerBound()) {
        return Range.atLeast(toFixedTimeZone(inputRange.lowerEndpoint()));
    }

    if (inputRange.hasUpperBound()) {
        return Range.lessThan(toFixedTimeZone(inputRange.upperEndpoint()));
    }

    return Range.all();

}

---

From source file:org.openmhealth.dsu.repository.MongoDataPointRepositoryImpl.java

void addCreationTimestampCriteria(Query query, Range<OffsetDateTime> timestampRange) {

    if (timestampRange.hasLowerBound() || timestampRange.hasUpperBound()) {

        Criteria timestampCriteria = where("header.creation_date_time");

        if (timestampRange.hasLowerBound()) {
            if (timestampRange.lowerBoundType() == CLOSED) {
                timestampCriteria = timestampCriteria.gte(timestampRange.lowerEndpoint());
            } else {
                timestampCriteria = timestampCriteria.gt(timestampRange.lowerEndpoint());
            }/*from ww w. j a v a2s  . c om*/
        }

        if (timestampRange.hasUpperBound()) {
            if (timestampRange.upperBoundType() == CLOSED) {
                timestampCriteria = timestampCriteria.lte(timestampRange.upperEndpoint());
            } else {
                timestampCriteria = timestampCriteria.lt(timestampRange.upperEndpoint());
            }
        }

        query.addCriteria(timestampCriteria);
    }
}

---

From source file:com.google.eclipse.protobuf.model.util.IndexedElements.java

private long findMaxIndex(Iterable<? extends EObject> elements) {
    long maxIndex = 0;

    for (EObject element : elements) {
        if (element instanceof OneOf) {
            maxIndex = max(maxIndex, findMaxIndex(((OneOf) element).getElements()));
        } else if (element instanceof IndexedElement) {
            maxIndex = max(maxIndex, indexOf((IndexedElement) element));
            if (element instanceof Group) {
                maxIndex = max(maxIndex, findMaxIndex(((Group) element).getElements()));
            }//from  www  . j a va 2 s . c o m
        } else if (element instanceof Reserved) {
            for (IndexRange indexRange : Iterables.filter(((Reserved) element).getReservations(),
                    IndexRange.class)) {
                try {
                    Range<Long> range = indexRanges.toLongRange(indexRange);
                    if (range.hasUpperBound()) {
                        maxIndex = max(maxIndex, range.upperEndpoint());
                    }
                } catch (BackwardsRangeException e) {
                    // Do not consider reserved ranges that are invalid.
                }
            }
        }
    }

    return maxIndex;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• »