public double[] getInterval(int key) {
double[] output = new double[2];
RangeHolder holder = new RangeHolder(key, key + 1);
int pos = VectorUtil.binarySearch(ranges, holder, rangeComparator, true) - 1;
// System.err.println("ranges = "+ranges);
if (ranges.size() == 0) {
output[0] = Double.NEGATIVE_INFINITY;
output[1] = Double.POSITIVE_INFINITY;
return output;
}
if (pos < 0) {
output[0] = Double.NEGATIVE_INFINITY;
output[1] = (double) ((Range) ranges.elementAt(0)).getLow() - 1;
return output;
}
if (pos >= ranges.size()) {
output[0] = (double) ((Range) ranges.elementAt(ranges.size() - 1)).getHigh() + 1;
output[1] = Double.POSITIVE_INFINITY;
return output;
}
Range rh = (Range) ranges.elementAt(pos);
if (contains(rh, key)) {
output[0] = (double) rh.getLow();
output[1] = (double) rh.getHigh();
} else {
output[0] = (double) rh.getHigh() + 1;
if (pos < ranges.size() - 1) output[1] = ((Range) ranges.elementAt(pos + 1)).getLow() - 1;
else output[1] = Double.POSITIVE_INFINITY;
}
return output;
}
public Vector put(Range holder, Object value) {
int pos = VectorUtil.binarySearch(ranges, holder, rangeComparator, true);
if (pos == -1) {
pos = 0;
}
Vector output = new Vector();
int posHigh =
VectorUtil.binarySearch(
ranges, new RangeHolder(holder.getHigh(), holder.getHigh()), rangeComparator, true);
Vector purged = new Vector();
boolean positionRemoved = false;
for (int i = (pos - 1 >= 0 ? pos - 1 : 0); i < posHigh && i < ranges.size(); i++) {
Range clobberMe = (Range) ranges.elementAt(i);
if (overlaps(clobberMe, holder)) {
if (i == pos - 1) positionRemoved = true;
output.addElement(data.remove(clobberMe));
purged.addElement(clobberMe);
}
}
for (int i = 0; i < purged.size(); i++) ranges.removeElement(purged.elementAt(i));
if (positionRemoved) pos = pos - 1;
ranges.insertElementAt(holder, pos);
data.put(holder, value);
return output;
}
/**
* Calculate set of the difference ranges of given two ranges (as current (A, B] and rhs is (C,
* D]) which node will need to fetch when moving to a given new token
*
* @param rhs range to calculate difference
* @return set of difference ranges
*/
public Set<Range> differenceToFetch(Range rhs) {
Set<Range> difference = new HashSet<Range>();
int comparisonAC = Range.compare(left, rhs.left);
if (comparisonAC == 0) // (A, B] & (A, C]
{
if (Range.compare(right, rhs.right) < 0) // B < C
{
difference.add(new Range(right, rhs.right));
}
} else if (comparisonAC > 0) // (A, B] & (C, D] where C < A (A > C)
{
difference.add(new Range(rhs.left, left)); // first interval will be (C, A]
if (Range.compare(rhs.right, right) > 0) // D > B
{
difference.add(new Range(rhs.right, right)); // (D, B]
}
} else // (A, B] & (C, D] where C > A (mean that comparisonAC < 0)
{
Token newLeft =
(Range.compare(rhs.left, right) > 0) ? rhs.left : right; // C > B ? (C, D] : (B, D]
difference.add(new Range(newLeft, rhs.right));
}
return difference;
}
/**
* Removes the EXACT range defined by (low,high). If no range is defined on exactly those
* coordinates, no elements are removed
*/
public Object remove(int low, int high) {
RangeHolder holder = new RangeHolder(low, high);
int pos = VectorUtil.binarySearch(ranges, holder, rangeComparator, false);
Range found = (Range) ranges.elementAt(pos);
if (found.equals(holder)) return data.remove(holder);
else return null;
}
private void readOneScan(
Cinrad2Record[] mapScan, Range radialRange, Range gateRange, int datatype, IndexIterator ii)
throws IOException {
for (int i = radialRange.first(); i <= radialRange.last(); i += radialRange.stride()) {
Cinrad2Record r = mapScan[i];
readOneRadial(r, datatype, gateRange, ii);
}
}
private static Set<Range> intersectionOneWrapping(Range wrapping, Range other) {
Set<Range> intersection = new HashSet<Range>(2);
if (other.contains(wrapping.right)) intersection.add(new Range(other.left, wrapping.right));
// need the extra compareto here because ranges are asymmetrical; wrapping.left _is not_
// contained by the wrapping range
if (other.contains(wrapping.left) && wrapping.left.compareTo(other.right) < 0)
intersection.add(new Range(wrapping.left, other.right));
return Collections.unmodifiableSet(intersection);
}
private void readOneRadial(Cinrad2Record r, int datatype, Range gateRange, IndexIterator ii)
throws IOException {
if (r == null) {
for (int i = gateRange.first(); i <= gateRange.last(); i += gateRange.stride())
ii.setByteNext(Cinrad2Record.MISSING_DATA);
return;
}
r.readData(volScan.raf, datatype, gateRange, ii);
}
public static boolean isTokenInRanges(Token token, Iterable<Range> ranges) {
assert ranges != null;
for (Range range : ranges) {
if (range.contains(token)) {
return true;
}
}
return false;
}
public String toString() {
StringBuffer out = new StringBuffer("(");
for (int i = 0; i < ranges.size(); i++) {
Range r = (Range) ranges.elementAt(i);
Object o = data.get(r);
if (i > 0) out.append(", ");
out.append("{[" + r.getLow() + ", " + r.getHigh() + "] = " + o.toString() + "}");
}
out.append(")");
return out.toString();
}
public int[] getDefinedInterval(int key) {
RangeHolder holder = new RangeHolder(key, key);
int pos = VectorUtil.binarySearch(ranges, holder, rangeComparator, true) - 1;
if (pos < 0 || pos >= ranges.size()) return null;
Range r = (Range) ranges.elementAt(pos);
if (r.getLow() <= key && r.getHigh() >= key) {
int[] out = new int[2];
out[0] = r.getLow();
out[1] = r.getHigh();
return out;
} else return null;
}
public Array readData(Variable v2, Section section) throws IOException, InvalidRangeException {
Vgroup vgroup = (Vgroup) v2.getSPobject();
Range scanRange = section.getRange(0);
Range radialRange = section.getRange(1);
Range gateRange = section.getRange(2);
Array data = Array.factory(v2.getDataType().getPrimitiveClassType(), section.getShape());
IndexIterator ii = data.getIndexIterator();
for (int i = scanRange.first(); i <= scanRange.last(); i += scanRange.stride()) {
Cinrad2Record[] mapScan = vgroup.map[i];
readOneScan(mapScan, radialRange, gateRange, vgroup.datatype, ii);
}
return data;
}
private void readNames(int base) {
pos = base;
int nextra = readInt(2);
names = new String[nextra];
// safenames= new String[nextra];
for (int i = 0; i < nextra; i++) {
Range r = getIndexEntry(base, i);
names[i] = new String(data, r.getStart(), r.getLen());
System.out.println(
"Read name: "
+ i
+ " from "
+ r.getStart()
+ " to "
+ r.getEnd()
+ ": "
+ safe(names[i]));
}
}
private void readDict(Range r) {
// System.out.println("reading dictionary from "+r.getStart()+" to "+r.getEnd());
pos = r.getStart();
while (pos < r.getEnd()) {
int cmd = readCommand(false);
if (cmd == 1006) { // charstringtype, default=2
charstringtype = (int) stack[0];
} else if (cmd == 1007) { // fontmatrix
if (stackptr == 4) {
at =
new AffineTransform(
(float) stack[0], (float) stack[1], (float) stack[2], (float) stack[3], 0, 0);
} else {
at =
new AffineTransform(
(float) stack[0],
(float) stack[1],
(float) stack[2],
(float) stack[3],
(float) stack[4],
(float) stack[5]);
}
} else if (cmd == 15) { // charset
charsetbase = (int) stack[0];
} else if (cmd == 16) { // encoding
encodingbase = (int) stack[0];
} else if (cmd == 17) { // charstrings
charstringbase = (int) stack[0];
} else if (cmd == 18) { // private
privatesize = (int) stack[0];
privatebase = (int) stack[1];
} else if (cmd == 19) { // subrs (in Private dict)
lsubrbase = (int) stack[0];
lsubrsoffset = calcoffset(lsubrbase);
} else if (cmd == 20) { // defaultWidthX (in Private dict)
defaultWidthX = (int) stack[0];
} else if (cmd == 21) { // nominalWidthX (in Private dict)
nominalWidthX = (int) stack[0];
}
stackptr = 0;
}
}
/**
* @param that
* @return the intersection of the two Ranges. this can be two disjoint Ranges if one is wrapping
* and one is not. say you have nodes G and M, with query range (D,T]; the intersection is
* (M-T] and (D-G]. If there is no intersection, an empty list is returned.
*/
public Set<Range> intersectionWith(Range that) {
if (that.contains(this)) return rangeSet(this);
if (this.contains(that)) return rangeSet(that);
boolean thiswraps = isWrapAround(left, right);
boolean thatwraps = isWrapAround(that.left, that.right);
if (!thiswraps && !thatwraps) {
// neither wraps. the straightforward case.
if (!(left.compareTo(that.right) < 0 && that.left.compareTo(right) < 0))
return Collections.emptySet();
return rangeSet(
new Range(
(Token) ObjectUtils.max(this.left, that.left),
(Token) ObjectUtils.min(this.right, that.right)));
}
if (thiswraps && thatwraps) {
// if the starts are the same, one contains the other, which we have already ruled out.
assert !this.left.equals(that.left);
// two wrapping ranges always intersect.
// since we have already determined that neither this nor that contains the other, we have 2
// cases,
// and mirror images of those case.
// (1) both of that's (1, 2] endpoints lie in this's (A, B] right segment:
// ---------B--------A--1----2------>
// (2) only that's start endpoint lies in this's right segment:
// ---------B----1---A-------2------>
// or, we have the same cases on the left segement, which we can handle by swapping this and
// that.
return this.left.compareTo(that.left) < 0
? intersectionBothWrapping(this, that)
: intersectionBothWrapping(that, this);
}
if (thiswraps && !thatwraps) return intersectionOneWrapping(this, that);
assert (!thiswraps && thatwraps);
return intersectionOneWrapping(that, this);
}
/**
* Create a new GeoGrid that is a logical subset of this GeoGrid.
*
* @param t_range subset the time dimension, or null if you want all of it
* @param z_range subset the vertical dimension, or null if you want all of it
* @param bbox a lat/lon bounding box, or null if you want all x,y
* @param z_stride use only if z_range is null, then take all z with this stride (1 means all)
* @param y_stride use this stride on the y coordinate (1 means all)
* @param x_stride use this stride on the x coordinate (1 means all)
* @return subsetted GeoGrid
* @throws InvalidRangeException if bbox does not intersect GeoGrid
*/
public GeoGrid subset(
Range t_range, Range z_range, LatLonRect bbox, int z_stride, int y_stride, int x_stride)
throws InvalidRangeException {
if ((z_range == null) && (z_stride > 1)) {
Dimension zdim = getZDimension();
if (zdim != null) z_range = new Range(0, zdim.getLength() - 1, z_stride);
}
Range y_range = null, x_range = null;
if (bbox != null) {
List yx_ranges = gcs.getRangesFromLatLonRect(bbox);
y_range = (Range) yx_ranges.get(0);
x_range = (Range) yx_ranges.get(1);
}
if (y_stride > 1) {
if (y_range == null) {
Dimension ydim = getYDimension();
y_range = new Range(0, ydim.getLength() - 1, y_stride);
} else {
y_range = new Range(y_range.first(), y_range.last(), y_stride);
}
}
if (x_stride > 1) {
if (x_range == null) {
Dimension xdim = getXDimension();
x_range = new Range(0, xdim.getLength() - 1, x_stride);
} else {
x_range = new Range(x_range.first(), x_range.last(), x_stride);
}
}
return subset(t_range, z_range, y_range, x_range);
}
public void parseGlyph(Range r, GlyphData gp, FlPoint pt) {
pos = r.getStart();
int i;
float x1, y1, x2, y2, x3, y3, ybase;
int hold;
int stemhints = 0;
gp.setAdvance(defaultWidthX);
while (pos < r.getEnd()) {
int cmd = readCommand(true);
hold = 0;
switch (cmd) {
case 1: // hstem
case 3: // vstem
if ((stackptr & 1) == 1) {
gp.setAdvance(nominalWidthX + stack[0]);
}
stackptr = 0;
break;
case 4: // vmoveto
if (stackptr > 1) { // this is the first call, arg1 is width
gp.setAdvance(nominalWidthX + stack[0]);
stack[0] = stack[1];
}
pt.y += stack[0];
if (pt.open) {
gp.closePath();
}
pt.open = false;
gp.moveTo(pt.x, pt.y);
stackptr = 0;
break;
case 5: // rlineto
for (i = 0; i < stackptr; ) {
pt.x += stack[i++];
pt.y += stack[i++];
gp.lineTo(pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 6: // hlineto
for (i = 0; i < stackptr; ) {
if ((i & 1) == 0) {
pt.x += stack[i++];
} else {
pt.y += stack[i++];
}
gp.lineTo(pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 7: // vlineto
for (i = 0; i < stackptr; ) {
if ((i & 1) == 0) {
pt.y += stack[i++];
} else {
pt.x += stack[i++];
}
gp.lineTo(pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 8: // rrcurveto
for (i = 0; i < stackptr; ) {
x1 = pt.x + stack[i++];
y1 = pt.y + stack[i++];
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2 + stack[i++];
pt.y = y2 + stack[i++];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 10: // callsubr
hold = pos;
i = (int) stack[--stackptr] + lsubrsoffset;
Range lsubr = getIndexEntry(lsubrbase, i);
parseGlyph(lsubr, gp, pt);
pos = hold;
break;
case 11: // return
return;
case 14: // endchar
if (stackptr == 5) {
buildAccentChar(stack[1], stack[2], stack[3], stack[4], gp);
}
if (pt.open) {
gp.closePath();
}
pt.open = false;
stackptr = 0;
return;
case 18: // hstemhm
if ((stackptr & 1) == 1) {
gp.setAdvance(nominalWidthX + stack[0]);
}
stemhints += stackptr / 2;
stackptr = 0;
break;
case 19: // hintmask
case 20: // cntrmask
if ((stackptr & 1) == 1) {
gp.setAdvance(nominalWidthX + stack[0]);
}
stemhints += stackptr / 2;
System.out.println(
"Added "
+ stackptr
+ " extra bits; skipping "
+ ((stemhints - 1) / 8 + 1)
+ " from "
+ stemhints);
pos += (stemhints - 1) / 8 + 1;
stackptr = 0;
break;
case 21: // rmoveto
if (stackptr > 2) {
gp.setAdvance(nominalWidthX + stack[0]);
stack[0] = stack[1];
stack[1] = stack[2];
}
pt.x += stack[0];
pt.y += stack[1];
if (pt.open) {
gp.closePath();
}
gp.moveTo(pt.x, pt.y);
pt.open = false;
stackptr = 0;
break;
case 22: // hmoveto
if (stackptr > 1) {
gp.setAdvance(nominalWidthX + stack[0]);
stack[0] = stack[1];
}
pt.x += stack[0];
if (pt.open) {
gp.closePath();
}
gp.moveTo(pt.x, pt.y);
pt.open = false;
stackptr = 0;
break;
case 23: // vstemhm
if ((stackptr & 1) == 1) {
gp.setAdvance(nominalWidthX + stack[0]);
}
stemhints += stackptr / 2;
stackptr = 0;
break;
case 24: // rcurveline
for (i = 0; i < stackptr - 2; ) {
x1 = pt.x + stack[i++];
y1 = pt.y + stack[i++];
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2 + stack[i++];
pt.y = y2 + stack[i++];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
}
pt.x += stack[i++];
pt.y += stack[i++];
gp.lineTo(pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
case 25: // rlinecurve
for (i = 0; i < stackptr - 6; ) {
pt.x += stack[i++];
pt.y += stack[i++];
gp.lineTo(pt.x, pt.y);
}
x1 = pt.x + stack[i++];
y1 = pt.y + stack[i++];
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2 + stack[i++];
pt.y = y2 + stack[i++];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
case 26: // vvcurveto
i = 0;
if ((stackptr & 1) == 1) { // odd number of arguments
pt.x += stack[i++];
}
while (i < stackptr) {
x1 = pt.x;
y1 = pt.y + stack[i++];
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2;
pt.y = y2 + stack[i++];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 27: // hhcurveto
i = 0;
if ((stackptr & 1) == 1) { // odd number of arguments
pt.y += stack[i++];
}
while (i < stackptr) {
x1 = pt.x + stack[i++];
y1 = pt.y;
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2 + stack[i++];
pt.y = y2;
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 29: // callgsubr
hold = pos;
i = (int) stack[--stackptr] + gsubrsoffset;
Range gsubr = getIndexEntry(gsubrbase, i);
parseGlyph(gsubr, gp, pt);
pos = hold;
break;
case 30: // vhcurveto
hold = 4;
case 31: // hvcurveto
for (i = 0; i < stackptr; ) {
boolean hv = (((i + hold) & 4) == 0);
x1 = pt.x + (hv ? stack[i++] : 0);
y1 = pt.y + (hv ? 0 : stack[i++]);
x2 = x1 + stack[i++];
y2 = y1 + stack[i++];
pt.x = x2 + (hv ? 0 : stack[i++]);
pt.y = y2 + (hv ? stack[i++] : 0);
if (i == stackptr - 1) {
if (hv) {
pt.x += stack[i++];
} else {
pt.y += stack[i++];
}
}
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
}
pt.open = true;
stackptr = 0;
break;
case 1003: // and
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = ((x1 != 0) && (y1 != 0)) ? 1 : 0;
break;
case 1004: // or
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = ((x1 != 0) || (y1 != 0)) ? 1 : 0;
break;
case 1005: // not
x1 = stack[--stackptr];
stack[stackptr++] = (x1 == 0) ? 1 : 0;
break;
case 1009: // abs
stack[stackptr - 1] = Math.abs(stack[stackptr - 1]);
break;
case 1010: // add
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = x1 + y1;
break;
case 1011: // sub
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = y1 - x1;
break;
case 1012: // div
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = y1 / x1;
break;
case 1014: // neg
stack[stackptr - 1] = -stack[stackptr - 1];
break;
case 1015: // eq
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = (x1 == y1) ? 1 : 0;
break;
case 1018: // drop
stackptr--;
break;
case 1020: // put
i = (int) stack[--stackptr];
x1 = stack[--stackptr];
temps[i] = x1;
break;
case 1021: // get
i = (int) stack[--stackptr];
stack[stackptr++] = temps[i];
break;
case 1022: // ifelse
if (stack[stackptr - 2] > stack[stackptr - 1]) {
stack[stackptr - 4] = stack[stackptr - 3];
}
stackptr -= 3;
break;
case 1023: // random
stack[stackptr++] = (float) Math.random();
break;
case 1024: // mul
x1 = stack[--stackptr];
y1 = stack[--stackptr];
stack[stackptr++] = y1 * x1;
break;
case 1026: // sqrt
stack[stackptr - 1] = (float) Math.sqrt(stack[stackptr - 1]);
break;
case 1027: // dup
x1 = stack[stackptr - 1];
stack[stackptr++] = x1;
break;
case 1028: // exch
x1 = stack[stackptr - 1];
stack[stackptr - 1] = stack[stackptr - 2];
stack[stackptr - 2] = x1;
break;
case 1029: // index
i = (int) stack[stackptr - 1];
if (i < 0) {
i = 0;
}
stack[stackptr - 1] = stack[stackptr - 2 - i];
break;
case 1030: // roll
i = (int) stack[--stackptr];
int n = (int) stack[--stackptr];
// roll n number by i (+ = upward)
if (i > 0) {
i = i % n;
} else {
i = n - (-i % n);
}
// x x x x i y y y -> y y y x x x x i (where i=3)
if (i > 0) {
float roll[] = new float[n];
System.arraycopy(stack, stackptr - 1 - i, roll, 0, i);
System.arraycopy(stack, stackptr - 1 - n, roll, i, n - i);
System.arraycopy(roll, 0, stack, stackptr - 1 - n, n);
}
break;
case 1034: // hflex
x1 = pt.x + stack[0];
y1 = ybase = pt.y;
x2 = x1 + stack[1];
y2 = y1 + stack[2];
pt.x = x2 + stack[3];
pt.y = y2;
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
x1 = pt.x + stack[4];
y1 = pt.y;
x2 = x1 + stack[5];
y2 = ybase;
pt.x = x2 + stack[6];
pt.y = y2;
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
case 1035: // flex
x1 = pt.x + stack[0];
y1 = pt.y + stack[1];
x2 = x1 + stack[2];
y2 = y1 + stack[3];
pt.x = x2 + stack[4];
pt.y = y2 + stack[5];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
x1 = pt.x + stack[6];
y1 = pt.y + stack[7];
x2 = x1 + stack[8];
y2 = y1 + stack[9];
pt.x = x2 + stack[10];
pt.y = y2 + stack[11];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
case 1036: // hflex1
ybase = pt.y;
x1 = pt.x + stack[0];
y1 = pt.y + stack[1];
x2 = x1 + stack[2];
y2 = y1 + stack[3];
pt.x = x2 + stack[4];
pt.y = y2;
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
x1 = pt.x + stack[5];
y1 = pt.y;
x2 = x1 + stack[6];
y2 = y1 + stack[7];
pt.x = x2 + stack[8];
pt.y = ybase;
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
case 1037: // flex1
ybase = pt.y;
float xbase = pt.x;
x1 = pt.x + stack[0];
y1 = pt.y + stack[1];
x2 = x1 + stack[2];
y2 = y1 + stack[3];
pt.x = x2 + stack[4];
pt.y = y2 + stack[5];
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
x1 = pt.x + stack[6];
y1 = pt.y + stack[7];
x2 = x1 + stack[8];
y2 = y1 + stack[9];
if (Math.abs(x2 - xbase) > Math.abs(y2 - ybase)) {
pt.x = x2 + stack[10];
pt.y = ybase;
} else {
pt.x = xbase;
pt.y = y2 + stack[10];
}
gp.curveTo(x1, y1, x2, y2, pt.x, pt.y);
pt.open = true;
stackptr = 0;
break;
default:
System.out.println("ERROR! TYPE1C CHARSTRING CMD IS " + cmd);
break;
}
}
}
protected static boolean equals(Range a, Range b) {
return a.getLow() == b.getLow() && a.getHigh() == b.getHigh();
}
protected static int compare(Range a, Range b) {
if (a.getLow() < b.getLow()) return -1;
else if (a.getLow() > b.getLow()) return 1;
else return 0;
}
protected static boolean contains(Range r, int value) {
return value >= r.getLow() && value <= r.getHigh();
}
protected static boolean overlaps(Range a, Range b) {
return (contains(a, b.getLow())
|| contains(a, b.getHigh())
|| contains(b, a.getLow())
|| contains(b, a.getHigh()));
}