Java CompareOp.GREATER_OR_EQUAL屬性代碼示例

/**
* Takes a compareOperator symbol as a byte array and returns the corresponding CompareOperator
* <p>
* @param compareOpAsByteArray the comparatorOperator symbol as a byte array
* @return the Compare Operator
*/
 public static CompareFilter.CompareOp createCompareOp (byte [] compareOpAsByteArray) {
   ByteBuffer compareOp = ByteBuffer.wrap(compareOpAsByteArray);
   if (compareOp.equals(ParseConstants.LESS_THAN_BUFFER))
     return CompareOp.LESS;
   else if (compareOp.equals(ParseConstants.LESS_THAN_OR_EQUAL_TO_BUFFER))
     return CompareOp.LESS_OR_EQUAL;
   else if (compareOp.equals(ParseConstants.GREATER_THAN_BUFFER))
     return CompareOp.GREATER;
   else if (compareOp.equals(ParseConstants.GREATER_THAN_OR_EQUAL_TO_BUFFER))
     return CompareOp.GREATER_OR_EQUAL;
   else if (compareOp.equals(ParseConstants.NOT_EQUAL_TO_BUFFER))
     return CompareOp.NOT_EQUAL;
   else if (compareOp.equals(ParseConstants.EQUAL_TO_BUFFER))
     return CompareOp.EQUAL;
   else
     throw new IllegalArgumentException("Invalid compare operator");
 }
 

@Test
public void testDependentColumnFilter() throws Exception {
  // null column qualifier/family
  DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null);
  assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
    ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));

  // non-null column qualifier/family
  dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"),
    Bytes.toBytes("qual"), true, CompareOp.GREATER_OR_EQUAL,
    new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR));
  assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
    ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
}
 

/**
 * Set end type for end value.
 * @param stopType - can only be LESS , LESS_OR_EQUAL or NO_OP
 */
public void setStopType(CompareOp stopType) {
  if (stopType == CompareOp.EQUAL || stopType == CompareOp.GREATER
      || stopType == CompareOp.GREATER_OR_EQUAL || stopType == CompareOp.NOT_EQUAL) {
    throw new IllegalArgumentException("Illegal end type: " + stopType.toString());
  }

  this.stopType = stopType;
}
 

/**
 * Construct a Range whose start value and end value are null.
 *
 * @param column
 */
public Range(byte[] baseTable, byte[] column) {
  this.baseTable = baseTable;
  setColumn(column);
  this.startValue = null;
  this.endValue = null;
  this.startType = CompareOp.GREATER_OR_EQUAL;
  this.endType = CompareOp.LESS_OR_EQUAL;
}
 

/**
 * Set start type for start value.
 *
 * @param startType - can only be EQUAL, GREATER or GREATER_OR_EQUAL
 */
public void setStartType(CompareOp startType) {
  if (startType == CompareOp.EQUAL || startType == CompareOp.GREATER
      || startType == CompareOp.GREATER_OR_EQUAL) {
    this.startType = startType;
  } else {
    this.startType = startType;
    //			throw new IllegalArgumentException("Illegal start type: "
    //					+ startType.toString());
  }
}
 

private Filter basicFilterNew() {
  return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
    CompareOp.GREATER_OR_EQUAL, VAL_2);
}
 

public Range getOpsite() {
  Range ran = new Range();
  ran.column = this.column;
  ran.valueType = this.valueType;
  ran.startValue = this.endValue;
  ran.endValue = this.startValue;
  ran.setStartTs(startTs);
  ran.setEndTs(endTs);
  ran.setLatestVersionOnly(latestVersionOnly);
  ran.setFilterIfMissing(filterIfMissing);

  if (ran.valueType == DataType.BOOLEAN) {
    if (Bytes.toString(this.startValue).equals("true")) {
      ran.startValue = Bytes.toBytes("false");
    } else if (Bytes.toString(this.startValue).equals("false")) {
      ran.startValue = Bytes.toBytes("true");
    }
    ran.startType = CompareOp.EQUAL;
    return ran;
  }
  if (this.startValue != null && this.startValue.length != 0) {
    switch (this.startType) {
    case EQUAL:
      ran.startType = CompareOp.GREATER;
      ran.startValue = this.startValue;
      ran.endValue = this.startValue;
      ran.endType = CompareOp.LESS;
      break;
    case GREATER_OR_EQUAL:
      ran.endType = CompareOp.LESS;
      break;
    case GREATER:
      ran.endType = CompareOp.LESS_OR_EQUAL;
      break;
    default:
      break;
    }
  }
  if (this.endValue != null && this.endValue.length != 0) {
    switch (this.endType) {
    case LESS:
      ran.startType = CompareOp.GREATER_OR_EQUAL;
      break;
    case LESS_OR_EQUAL:
      ran.startType = CompareOp.GREATER;
      break;
    default:
      break;
    }
  }

  return ran;
}