import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static List<Range> reduce(List<Range> ranges) {
    List<Range> list = Lists.newArrayList();
    Range previous = null;
    for (Range r : ranges) {
        if (previous != null) {
            if (previous.high() >= r.low() - 1) {
                // combine with previous because overlapping or contiguous
                previous = new Range(previous.low(), Math.max(previous.high(), r.high()));
            } else {
                list.add(previous);
                previous = r;
            }
        } else {
            previous = r;
        }
    }
    if (previous != null) {
        list.add(previous);
    }
    return list;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
Range toRange(Box box, BoxMinMaxIndexEstimationStrategy strategy) {
    Preconditions.checkNotNull(strategy, "strategy cannot be null");
    Visitor visitor = new Visitor();
    if (strategy == BoxMinMaxIndexEstimationStrategy.SCAN_ENTIRE_PERIMETER) {
        // brute force method of finding min and max values within box
        // min and max values must be on the perimeter of the box
        visitPerimeter(box, visitor);
    } else {
        // TODO ideally don't use brute force but this method not working yet
        // not a problem with visitVertices I don't think but perhaps the choice of
        // split indices
        // visitVertices(box, visitor);
        throw new RuntimeException("Unsupported strategy: " + strategy);
    }
    return visitor.getRange();
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
BigInteger toIndex(long... transposedIndex) {
    byte[] b = new byte[length];
    int bIndex = length - 1;
    long mask = 1L << (bits - 1);
    for (int i = 0; i < bits; i++) {
        for (int j = 0; j < transposedIndex.length; j++) {
            if ((transposedIndex[j] & mask) != 0) {
                b[length - 1 - bIndex / 8] |= 1 << (bIndex % 8);
            }
            bIndex--;
        }
        mask >>= 1;
    }
    // b is expected to be BigEndian
    return new BigInteger(1, b);
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void visitBox(Box box, Consumer<long[]> visitor) {
    int dimensions = box.a.length;
    long[] p = new long[dimensions];
    for (int i = 0; i < dimensions; i++) {
        p[i] = Math.min(box.a[i], box.b[i]);
    }
    visitBox(box, p, 0, visitor);
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void visitVertices(Box box, Consumer<long[]> visitor) {
    for (long i = 0; i < (1L << dimensions); i++) {
        long[] x = new long[box.a.length];
        for (int j = 0; j < box.dimensions(); j++) {
            if ((i & (1L << j)) != 0) {
                // if jth bit set
                x[j] = box.b[j];
            } else {
                x[j] = box.a[j];
            }
        }
        visitor.accept(x);
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * <p>
 * Given the axes (coordinates) of a point in N-Dimensional space, find the
 * distance to that point along the Hilbert curve. That distance will be
 * transposed; broken into pieces and distributed into an array.
 *
 * <p>
 * The number of dimensions is the length of the hilbertAxes array.
 *
 * <p>
 * Note: In Skilling's paper, this function is called AxestoTranspose.
 * 
 * @param mutate
 * 
 * @param point
 *            Point in N-space
 * @return The Hilbert distance (or index) as a transposed Hilbert index
 */
@VisibleForTesting
static long[] transposedIndex(int bits, long... point) {
    final long M = 1L << (bits - 1);
    final int n = point.length; // n: Number of dimensions
    final long[] x = Arrays.copyOf(point, n);
    long p, q, t;
    int i;
    // Inverse undo
    for (q = M; q > 1; q >>= 1) {
        p = q - 1;
        for (i = 0; i < n; i++)
            if ((x[i] & q) != 0)
                x[0] ^= p; // invert
            else {
                t = (x[0] ^ x[i]) & p;
                x[0] ^= t;
                x[i] ^= t;
            }
    } // exchange
      // Gray encode
    for (i = 1; i < n; i++)
        x[i] ^= x[i - 1];
    t = 0;
    for (q = M; q > 1; q >>= 1)
        if ((x[n - 1] & q) != 0)
            t ^= q - 1;
    for (i = 0; i < n; i++)
        x[i] ^= t;

    return x;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
Options(Callable<File> filefactory, int pageSizeBytes, Scheduler scheduler) {
    Preconditions.checkNotNull(filefactory);
    Preconditions.checkArgument(pageSizeBytes > 0, "bufferSizeBytes must be greater than 0");
    Preconditions.checkNotNull(scheduler);
    this.fileFactory = filefactory;
    this.pageSizeBytes = pageSizeBytes;
    this.scheduler = scheduler;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static void closeQuietly(Socket socket) {
    try {
        socket.close();
    } catch (IOException e) {
        // ignore exception
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public static void close(PagedQueue queue) {
    try {
        queue.close();
    } catch (Throwable err) {
        Exceptions.throwIfFatal(err);
        RxJavaPlugins.onError(err);
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static Method getMethod(Class<?> cls, String name, Class<?>... params) {
    Method m;
    try {
        m = cls.getDeclaredMethod(name, params);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    m.setAccessible(true);
    return m;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * Returns a capacity that is sufficient to keep the map from being resized
 * as long as it grows no larger than expectedSize and the load factor is >=
 * its default (0.75).
 */
@VisibleForTesting
static int capacity(int expectedSize) {
    if (expectedSize < 3) {
        checkNonnegative(expectedSize, "expectedSize");
        return expectedSize + 1;
    }
    if (expectedSize < MAX_POWER_OF_TWO) {
        return expectedSize + expectedSize / 3;
    }
    return Integer.MAX_VALUE; // any large value
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static int checkNonnegative(int value, String name) {
    if (value < 0) {
        throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static int computeArrayListCapacity(int arraySize) {
    Preconditions.checkArgument(arraySize >= 0, "arraySize must be non-negative");

    // TODO(kevinb): Figure out the right behavior, and document it
    return saturatedCast(5L + arraySize + (arraySize / 10));
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * Returns the {@code int} nearest in value to {@code value}.
 *
 * @param value
 *            any {@code long} value
 * @return the same value cast to {@code int} if it is in the range of the
 *         {@code int} type, {@link Integer#MAX_VALUE} if it is too large,
 *         or {@link Integer#MIN_VALUE} if it is too small
 */
@VisibleForTesting
static int saturatedCast(long value) {
    if (value > Integer.MAX_VALUE) {
        return Integer.MAX_VALUE;
    }
    if (value < Integer.MIN_VALUE) {
        return Integer.MIN_VALUE;
    }
    return (int) value;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
int height() {
    return height;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void visitPerimeter(Box box, Consumer<long[]> visitor) {
    for (int i = 0; i < box.dimensions(); i++) {
        visitPerimeter(box, i, visitor);
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public BufferToFileSubscriberFlowable(Subscriber<? super T> child, PagedQueue queue,
        Serializer<T> serializer, Worker worker) {
    super(child, queue, serializer, worker);
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
int searchPosition() {
    return searchPosition;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static Observable<TimedLeg> toLegs(Shapefile eezLine, Shapefile eezPolygon, Collection<Port> ports,
        Collection<EezWaypoint> eezWaypoints, Observable<Fix> fixes) {
    return Observable.defer(() -> //
    {
        State[] state = new State[1];
        state[0] = new State(null, null, EezStatus.UNKNOWN);
        return fixes //
                .flatMap(fix -> {
                    List<TimedLeg> legs = null; // only create when needed to reduce
                                                // allocations
                    boolean inEez = eezPolygon.contains(fix.lat(), fix.lon());
                    State current = state[0];
                    Preconditions.checkArgument(current.latestFix == null || fix.time() >= current.latestFix.time(),
                            "fixes out of time order!");
                    boolean crossed = (inEez && current.fixStatus == EezStatus.OUT)
                            || (!inEez && current.fixStatus == EezStatus.IN);
                    if (crossed) {
                        TimedWaypoint closestWaypoint = findClosestWaypoint(eezLine, eezWaypoints, fix, current);
                        if (current.timedWaypoint != null) {
                            if (legs == null) {
                                legs = new ArrayList<>(2);
                            }
                            legs.add(new TimedLeg(fix.mmsi(), current.timedWaypoint, closestWaypoint));
                        }
                        current = new State(closestWaypoint, fix, EezStatus.from(inEez));
                    }
                    // Note that may have detected eez crossing but also
                    // have arrived in port so may need to return both
                    // waypoints
                    if (inEez) {
                        Optional<Port> port = findPort(ports, fix.lat(), fix.lon());
                        if (port.isPresent()) {
                            TimedWaypoint portTimedWaypoint = new TimedWaypoint(port.get(), fix.time());
                            state[0] = new State(portTimedWaypoint, fix, EezStatus.IN);
                            if (current.fixStatus != EezStatus.UNKNOWN && current.timedWaypoint != null
                                    && current.timedWaypoint.waypoint != port.get()) {
                                if (current.timedWaypoint != null) {
                                    if (legs == null) {
                                        legs = new ArrayList<>(2);
                                    }
                                    legs.add(new TimedLeg(fix.mmsi(), current.timedWaypoint, portTimedWaypoint));
                                }
                            }
                        } else {
                            state[0] = new State(current.timedWaypoint, fix, EezStatus.IN);
                        }
                    } else {
                        state[0] = new State(current.timedWaypoint, fix, EezStatus.OUT);
                    }
                    if (legs == null) {
                        return Observable.empty();
                    } else {
                        return Observable.from(legs);
                    }

                });
    });

}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * Returns the transposed representation of the Hilbert curve index.
 * 
 * <p>
 * The Hilbert index is expressed internally as an array of transposed bits.
 * 
 * <pre>
  Example: 5 bits for each of n=3 coordinates.
     15-bit Hilbert integer = A B C D E F G H I J K L M N O is stored
     as its Transpose                        ^
     X[0] = A D G J M                    X[2]|  7
     X[1] = B E H K N        &lt;-------&gt;       | /X[1]
     X[2] = C F I L O                   axes |/
            high low                         0------&gt; X[0]
 * </pre>
 * 
 * @param index
 *            index to be tranposed
 * @return transposed index
 */
@VisibleForTesting
long[] transpose(BigInteger index) {
    long[] x = new long[dimensions];
    transpose(index, x);
    return x;
}