private Compare getGremlinPredicate(ComparisionOperator op) {
    switch (op) {
        case EQUAL:
            return Compare.EQUAL;
        case GREATER_THAN:
            return Compare.GREATER_THAN;
        case GREATER_THAN_EQUAL:
            return Compare.GREATER_THAN_EQUAL;
        case LESS_THAN:
            return Compare.LESS_THAN;
        case LESS_THAN_EQUAL:
            return Compare.LESS_THAN_EQUAL;
        case NOT_EQUAL:
            return Compare.NOT_EQUAL;
        default:
            throw new RuntimeException("Unsupported comparison operator:" + op);
    }
}
 

public static Predicate mapPredicate(final T t) {
    if (t.equals(T.eq))
        return Compare.EQUAL;
    else if (t.equals(T.neq))
        return Compare.NOT_EQUAL;
    else if (t.equals(T.lt))
        return Compare.LESS_THAN;
    else if (t.equals(T.lte))
        return Compare.LESS_THAN_EQUAL;
    else if (t.equals(T.gt))
        return Compare.GREATER_THAN;
    else if (t.equals(T.gte))
        return Compare.GREATER_THAN_EQUAL;
    else if (t.equals(T.in))
        return Contains.IN;
    else if (t.equals(T.notin))
        return Contains.NOT_IN;
    else
        throw new IllegalArgumentException(t.toString() + " is an unknown filter type");
}
 

@Override
public void has(String propertyName, QueryOperator op, Object value) {
    TitanPredicate pred;
    if (op instanceof ComparisionOperator) {
        Compare c = getGremlinPredicate((ComparisionOperator) op);
        pred = TitanPredicate.Converter.convert(c);
    } else {
        pred = getGremlinPredicate((MatchingOperator) op);
    }
    query.has(propertyName, pred, value);
}
 

public S processNextStart() {
    while (true) {
        final S s = this.starts.next();
        final Object value = s.getProperty(key);
        if (null == value)
            continue;
        else {
            if (Compare.GREATER_THAN_EQUAL.evaluate(value, this.startValue) && Compare.LESS_THAN.evaluate(value, this.endValue))
                return s;
        }
    }
}
 

protected Pipe getNotDeletedPipe() {
    return new PropertyFilterPipe(Constants.STATE_PROPERTY_KEY, Compare.EQUAL,
            Id.EntityState.ACTIVE.name());
}
 

public PropertyFilteredIterable(final String key, final Object value, final Iterable<T> iterable) {
    this.iterable = iterable;
    this.hasContainer = new HasContainer(key, Compare.EQUAL, value);
}