Compares if 'this' is greater than vid

@param vid        TODO
@param allowEqual TODO
@return TODO
555354
private boolean isGreaterThanOrEqualHelper( VersionID vid, boolean allowEqual )
    {

        if ( _isCompound )
        {
            if ( !_rest.isGreaterThanOrEqualHelper( vid, allowEqual ) )
            {
                return false;
            }
        }
        // Normalize the two strings
        String[] t1 = normalize( _tuple, vid._tuple.length );
        String[] t2 = normalize( vid._tuple, _tuple.length );

        for ( int i = 0; i < t1.length; i++ )
        {
            // Compare current element
            Object e1 = getValueAsObject( t1[i] );
            Object e2 = getValueAsObject( t2[i] );
            if ( e1.equals( e2 ) )
            {
                // So far so good
            }
            else
            {
                if ( e1 instanceof Integer && e2 instanceof Integer )
                {
                    return (Integer) e1 > (Integer) e2;
                }
                else
                {
                    String s1 = t1[i];
                    String s2 = t2[i];
                    return s1.compareTo( s2 ) > 0;
                }

            }
        }
        // If we get here, they are equal
        return allowEqual;
    }
104886
public Filter<T> greaterThan(T value) {
		return new ComparableFilter<T>(this, value, Operator.GREATER_THAN);
	}
1251684
function devModeEqual(a, b) {
    var /** @type {?} */ isListLikeIterableA = isListLikeIterable(a);
    var /** @type {?} */ isListLikeIterableB = isListLikeIterable(b);
    if (isListLikeIterableA && isListLikeIterableB) {
        return areIterablesEqual(a, b, devModeEqual);
    }
    else {
        var /** @type {?} */ isAObject = a && (typeof a === 'object' || typeof a === 'function');
        var /** @type {?} */ isBObject = b && (typeof b === 'object' || typeof b === 'function');
        if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {
            return true;
        }
        else {
            return looseIdentical(a, b);
        }
    }
}
369227
@Override
  public int compareTo(Comparable<?> other) {
    if (other instanceof Region) {
      Region r = (Region) other;
      if (this.start < r.start) {
        return -1;
      } else if (this.end > r.end) {
        return 1;
      } else {
        return 0;
      }
    } else if (other instanceof Long) {
      Long l = (Long) other;
      if (l > end) {
          return -1;
      } else if (l < start) {
          return 1;
      } else {
          return 0;
      }
    } else {
      throw new AssertionError();
    }
  }
914524
@Override
    public <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> lhs,
            Expression<? extends Y> rhs)
    {

        return new ComparisonPredicate(lhs, rhs, ConditionalOperator.GT);
    }
822322
function(val, desc){
        this.assert(
            val.valueOf() === this.obj
            , function(){ return 'expected ' + this.inspect + ' to equal ' + i(val) + (desc ? " | " + desc : "") }
            , function(){ return 'expected ' + this.inspect + ' to not equal ' + i(val) + (desc ? " | " + desc : "") }
            , val);
        return this;
    }
1080477
@Override
    public int compareTo(Vulnerability v) {
        return new CompareToBuilder()
                .append(this.name, v.name)
                .toComparison();
    }
401803
public AVIMConversationsQuery whereNotEqualsTo(String key, Object value) {
    conditions.whereNotEqualTo(key, value);
    return this;
  }
749739
function( value, comparator ) {
			var error;
			if ( value <= parseFloat( comparator ) ) {
				error = {
					"rule": "greater_than",
					"message": "ERROR:provided value [" + value + "] is not greater than " + parseFloat( comparator )
				};
				return [ error ];
			}
			return;
		}
1813
@Override
    public boolean isEqual(Object o) {
        if (o == this) {
            return true;
        }
        if (!(o instanceof TemporalParameter)) {
            return false;
        }

        TemporalParameter p = (TemporalParameter) o;
        return super.isEqual(p)
                && (this.value == p.value
                || (this.value != null && this.value.equals(p.value)));
    }
889808
@Override
  public void isEqualTo(@NullableDecl Object expected) {
    // TODO(user): Do better here when MessageLite descriptors are available.
    if (Objects.equal(actual(), expected)) {
      return;
    }

    if (actual() == null || expected == null) {
      super.isEqualTo(expected);
    } else if (actual().getClass() != expected.getClass()) {
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that (%s) %s is equal to the expected (%s) object. "
                      + "They are not of the same class.",
                  actual().getClass().getName(),
                  internalCustomName() != null ? internalCustomName() + " (proto)" : "proto",
                  expected.getClass().getName())));
    } else {
      /*
       * TODO(cpovirk): If we someday let subjects override formatActualOrExpected(), change this
       * class to do so, and make this code path always delegate to super.isEqualTo().
       */
      String ourString = getTrimmedToString(actual());
      String theirString = getTrimmedToString((MessageLite) expected);
      if (!ourString.equals(theirString)) {
        check().that(ourString).isEqualTo(theirString); // fails
      } else {
        // This will include the Object.toString() headers.
        super.isEqualTo(expected);
      }
    }
  }
664968
public boolean greaterThan(XObject obj2) throws javax.xml.transform.TransformerException
  {
    return compare(obj2, S_GT);
  }
993863
public boolean greaterThan(Object left, Object right) {
    if ((left == right) || left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">") > 0;
    }
  }
396936
@Override
  public void isEqualTo(@NullableDecl Object other) {
    if (Objects.equal(actual(), other)) {
      return;
    }

    // Fail but with a more descriptive message:

    if (!(other instanceof Map)) {
      super.isEqualTo(other);
      return;
    }

    boolean mapEquals = containsEntriesInAnyOrder((Map<?, ?>) other, "is equal to", false);
    if (mapEquals) {
      failWithoutActual(
          simpleFact(
              lenientFormat(
                  "Not true that %s is equal to <%s>. It is equal according to the contract of "
                      + "Map.equals(Object), but this implementation returned false",
                  actualAsString(), other)));
    }
  }
167917
public static <T extends Comparable<? super T>> ComparisonChain compare(T left, T right) {
        return new ComparisonChain().compare(left, right);
    }
1170023
public final void mNOT_EQUAL() throws RecognitionException {
        try {
            int _type = NOT_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src/riemann/Query.g:10:11: ( '!=' )
            // src/riemann/Query.g:10:13: '!='
            {
            match("!="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
545073
@VisibleForTesting
  static boolean isGreaterThanOrEqualTo(Version first, Version second) {
    if ((first.getMajor() > second.getMajor())
        || (first.getMajor() == second.getMajor() && first.getMinor() >= second.getMinor())) {
      return true;
    }
    return false;
  }