Created
November 7, 2021 13:40
-
-
Save junwen12221/5c2e98cae463b7b375c9ae7925e06209 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package io.mycat.router.range; | |
import lombok.AllArgsConstructor; | |
import java.math.BigDecimal; | |
import java.math.BigInteger; | |
import java.sql.Date; | |
import java.time.*; | |
import java.time.temporal.TemporalAmount; | |
import java.util.ArrayList; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Optional; | |
import java.util.stream.IntStream; | |
import java.util.stream.LongStream; | |
public abstract class Enumerator<T,U> { | |
final int size; | |
final T start; | |
final T end; | |
final U unit; | |
final boolean cycle; | |
final int enumSize; | |
public Enumerator(int size, T start, T end, U unit, boolean cycle, int enumSize) { | |
this.size = size; | |
this.start = start; | |
this.end = end; | |
this.unit = unit; | |
this.cycle = cycle; | |
this.enumSize = enumSize; | |
} | |
abstract public Optional<Iterable<T>> rangeClosed(T left, T right); | |
public Optional<Iterable<T>> range(T left, T right) { | |
if (left instanceof Integer && right instanceof Integer) { | |
return (Optional) rangeClosedInt((Integer) left, (Integer) right); | |
} | |
if (left instanceof Long && right instanceof Long) { | |
return (Optional) rangeClosedLong((Long) left, (Long) right); | |
} | |
if (left instanceof Byte && right instanceof Byte) { | |
return (Optional) rangeClosedByte((Byte) left, (Byte) right); | |
} | |
if (left instanceof Character && right instanceof Character) { | |
return (Optional) rangeClosedCharacter((Character) left, (Character) right); | |
} | |
if (left instanceof Short && right instanceof Short) { | |
return (Optional) rangeClosedShort((Short) left, (Short) right); | |
} | |
if (left instanceof Float && right instanceof Float) { | |
return (Optional) rangeClosedFloat((Float) left, (Float) right); | |
} | |
if (left instanceof Double && right instanceof Double) { | |
return (Optional) rangeClosedDouble((Double) left, (Double) right); | |
} | |
if (left instanceof BigInteger && right instanceof BigInteger) { | |
return (Optional) rangeClosedBigInteger((BigInteger) left, (BigInteger) right); | |
} | |
if (left instanceof BigDecimal && right instanceof BigDecimal) { | |
return (Optional) rangeClosedBigDecimal((BigDecimal) left, (BigDecimal) right); | |
} | |
if (left instanceof LocalDate && right instanceof LocalDate) { | |
return (Optional) rangeClosedLocalDate((LocalDate) left, (LocalDate) right); | |
} | |
if (left instanceof LocalDateTime && right instanceof LocalDateTime) { | |
return (Optional) rangeClosedLocalDateTime((LocalDateTime) left, (LocalDateTime) right); | |
} | |
if (left instanceof LocalTime && right instanceof LocalTime) { | |
return (Optional) rangeClosedLocalTime((LocalTime) left, (LocalTime) right); | |
} | |
if (left instanceof java.sql.Date && right instanceof Date ) { | |
return (Optional) rangeClosedLocalDate( ((Date) left).toLocalDate(), ((Date) right).toLocalDate()); | |
} | |
if (left instanceof java.sql.Time && right instanceof java.sql.Time ) { | |
return (Optional) rangeClosedLocalTime( ((java.sql.Time) left).toLocalTime(), ((java.sql.Time) right).toLocalTime()); | |
} | |
if (left instanceof java.sql.Timestamp && right instanceof java.sql.Timestamp ) { | |
return (Optional) rangeClosedLocalDateTime( ((java.sql.Timestamp) left).toLocalDateTime(), ((java.sql.Timestamp) right).toLocalDateTime()); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<LocalTime>> rangeClosedLocalTime(LocalTime left, LocalTime right) { | |
TemporalAmount temporalAmount = (this.unit == null)? Duration.ofSeconds(1):(TemporalAmount)this.unit; | |
if (right.compareTo(left)>0){ | |
LocalTime cur = left; | |
ArrayList<LocalTime> res = new ArrayList<>(); | |
for (int i = 0; i <= size; i++) { | |
res.add(cur); | |
cur.plus(temporalAmount); | |
} | |
return Optional.ofNullable(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<LocalDateTime>> rangeClosedLocalDateTime(LocalDateTime left, LocalDateTime right) { | |
TemporalAmount temporalAmount = (this.unit == null)?Period.ofDays(1):(TemporalAmount)this.unit; | |
if (right.compareTo(left)>0){ | |
LocalDateTime cur = left; | |
ArrayList<LocalDateTime> res = new ArrayList<>(); | |
for (int i = 0; i <= size; i++) { | |
res.add(cur); | |
cur.plus(temporalAmount); | |
} | |
return Optional.ofNullable(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<LocalDate>> rangeClosedLocalDate(LocalDate left, LocalDate right) { | |
TemporalAmount temporalAmount = (this.unit == null)?Period.ofDays(1):(TemporalAmount)this.unit; | |
if (right.compareTo(left)>0){ | |
LocalDate cur = left; | |
ArrayList<LocalDate> res = new ArrayList<>(); | |
for (int i = 0; i <= size; i++) { | |
res.add(cur); | |
cur.plus(temporalAmount); | |
} | |
return Optional.ofNullable(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<BigInteger>> rangeClosedBigInteger(BigInteger left, BigInteger right) { | |
int limit = right.intValue(); | |
int start = left.intValue(); | |
int diff = -left.intValue(); | |
if (start > 0 && limit > 0 && size > diff && diff > 0) { | |
ArrayList<BigInteger> res = new ArrayList<>(); | |
for (int i = 0; i <= diff; i++) { | |
res.add(left.add(BigInteger.ONE)); | |
} | |
return Optional.of(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<BigDecimal>> rangeClosedBigDecimal(BigDecimal left, BigDecimal right) { | |
int limit = right.intValue(); | |
int start = left.intValue(); | |
int diff = -left.intValue(); | |
if (start > 0 && limit > 0 && size > diff && diff > 0) { | |
ArrayList<BigDecimal> res = new ArrayList<>(); | |
for (int i = 0; i <= diff; i++) { | |
res.add(left.add(BigDecimal.ONE)); | |
} | |
return Optional.of(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Float>> rangeClosedFloat(Float left, Float right) { | |
double diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
ArrayList<Float> res = new ArrayList<>(); | |
for (float i = left; i <= right; i++) { | |
res.add(i); | |
} | |
return Optional.of(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Double>> rangeClosedDouble(Double left, Double right) { | |
double diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
ArrayList<Double> res = new ArrayList<>(); | |
for (double i = left; i <= right; i++) { | |
res.add(i); | |
} | |
return Optional.of(res); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Short>> rangeClosedShort(Short left, Short right) { | |
long diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
return Optional.of(() -> (Iterator) IntStream.rangeClosed(left, right).mapToObj(i -> Short.valueOf((short) i)).iterator()); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Character>> rangeClosedCharacter(Character left, Character right) { | |
long diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
return Optional.of(() -> (Iterator) IntStream.rangeClosed(left, right).mapToObj(i -> Character.valueOf((char) i)).iterator()); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Byte>> rangeClosedByte(byte left, byte right) { | |
long diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
return Optional.of(() -> (Iterator) IntStream.rangeClosed(left, right).mapToObj(i -> Byte.valueOf((byte) i)).iterator()); | |
} | |
return Optional.empty(); | |
} | |
private Optional<Iterable<Byte>> rangeClosedLong(long left, long right) { | |
long diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
return Optional.of(() -> (Iterator) LongStream.rangeClosed(left, right).boxed().iterator()); | |
} | |
return Optional.empty(); | |
} | |
public Optional<Iterable<Byte>> rangeClosedInt(int left, int right) { | |
int diff = right - left; | |
if (left > 0 && right > 0 && size > diff && diff > 0) { | |
return Optional.of(() -> (Iterator) IntStream.rangeClosed(left, right).boxed().iterator()); | |
} | |
return Optional.empty(); | |
} | |
public Optional<List<Integer>> range(int left, int right) { | |
int diff = right - left; | |
if (size > diff && diff > 0) { | |
ArrayList<Integer> res = new ArrayList<>(); | |
for (int i = left; i <= right; i++) { | |
res.add(i); | |
} | |
return Optional.of(res); | |
} | |
return Optional.empty(); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment