Tell if one object is less than or equal to the other.

@param obj2 object to compare this nodeset to

@return see this.compare(...)

@throws javax.xml.transform.TransformerException
504744
public boolean lessThanOrEqual(XObject obj2) throws javax.xml.transform.TransformerException
  {
    return compare(obj2, S_LTE);
  }
465436
public static <T extends Comparable<? super T>> boolean lessThanOrEquals(final T object,
            final T other) {

        return JudgeUtils.lessThanOrEquals(object, other);
    }
113431
public boolean notEquals(XObject obj2)
          throws javax.xml.transform.TransformerException
  {

    // In order to handle the 'all' semantics of 
    // nodeset comparisons, we always call the 
    // nodeset function.
    if (obj2.getType() == XObject.CLASS_NODESET)
      return obj2.notEquals(this);

    return !equals(obj2);
  }
296659
@Override
    public int compareTo(Object obj) throws ClassCastException {

        URI another = (URI) obj;
        if (!equals(_authority, another.getRawAuthority())) { 
            return -1;
        }
        return toString().compareTo(another.toString());
    }
373103
public Difference<BaseType> compareObjects(List<String> field1,
                                               ObjectType node1,
                                               List<String> field2,
                                               ObjectType node2)
            throws InvalidArrayIdentity, DuplicateArrayIdentity {
        Difference<BaseType> ret = new Difference<>();
        // Field by field comparison of obj1 to obj2. 
        for (Iterator<Map.Entry<String, BaseType>> fields = getFields(node1); fields.hasNext();) {
            Map.Entry<String, BaseType> field = fields.next();
            String fieldName = field.getKey();
            field1.add(fieldName);
            BaseType value1 = field.getValue();

            if (hasField(node2, fieldName)) {
                // If both obj1 and obj2 have the same field, compare recursively
                field2.add(fieldName);
                BaseType value2 = getField(node2, fieldName);
                ret.add(compareNodes(field1, value1, field2, value2));
                pop(field2);
            } else {
                // obj1.field1 exists, obj2.field1 does not, so it is removed
                ret.add(new Removal(field1, value1));
            }
            pop(field1);
        }
        // Now compare any new nodes added to obj2
        for (Iterator<Map.Entry<String, BaseType>> fields = getFields(node2); fields.hasNext();) {
            Map.Entry<String, BaseType> field = fields.next();
            String fieldName = field.getKey();
            if (!hasField(node1, fieldName)) {
                field2.add(fieldName);
                ret.add(new Addition(field2, field.getValue()));
                pop(field2);
            }
        }
        return ret;
    }
771608
@Override
    public int compare(Row row1, Row row2) {
        Columns columns1 = rowMapper.columns(row1);
        Columns columns2 = rowMapper.columns(row2);
        return comparatorChain.compare(columns1, columns2);
    }
470306
public static <T> int compare(T o1, T o2, Comparator<T> comparator) {
		if(o1 == null) {
			return o2 == null ? 0 : 1;
		} else if(o2 == null) {
			return -1;
		} else {
			return comparator.compare(o1, o2);
		}
	}
131310
final static boolean valEquals(final Object o1, final Object o2) {
    return (o1 == null ? o2 == null : o1.equals(o2));
  }
660015
public static <T extends Comparable<? super T>> boolean greaterThanOrEquals(final T object,
            final T other) {

        return JudgeUtils.greaterThanOrEquals(object, other);
    }
323867
public boolean matches(Object obj) {
        if (!(obj instanceof Exception))
            return false;

        Exception exception = (Exception) obj;

        return exception.getCause() == null;
    }
8059
private int compare(Object k1, Object k2) {
        return (mComparator==null ? ((Comparable)k1).compareTo(k2)
                : mComparator.compare(k1, k2));
    }
1162898
function isDeepEqual(obj1, obj2, isStrict) {
      if (typeof obj1 !== typeof obj2) return false;
      if (isArr(obj1) && isArr(obj2)) {
        if (obj1.length !== obj2.length) return false;
        for (var i = 0; i < obj1.length; i++) {
          if (!isDeepEqual(obj1[i], obj2[i], isStrict)) return false;
        }
        return true;
      }
      else if (isObj(obj1) && isObj(obj2)) {
        if (len(obj1) !== len(obj2)) return false;
        var ks = keys(obj1);
        if (isStrict && !isDeepEqual(ks, keys(obj2))) return false;
        for (var i = 0; i < ks.length; i++) {
          if (
            !has(obj2, ks[i]) || !isDeepEqual(obj1[ks[i]], obj2[ks[i]], isStrict)
          ) return false;
        }
        return true;
      }
      else return obj1 === obj2;
    }
15289
public int compare(Object o1, Object o2) {
        int m1 = ((int[])o1)[0];
        int m2 = ((int[])o2)[0];
        if (m1 < m2)
            return -1;
        if (m1 == m2)
            return 0;
        return 1;
    }
464548
public static boolean jsEquals(Object o1, Object o2) {
        
        // quick breakers
        if (o1 == o2) return true;
        if (o1 == null ^ o2 == null) return false;
        
        // Can we do a by-part comparison?
        if (o1 instanceof ScriptableObject && o2 instanceof ScriptableObject) {
            return jsScriptableObjectEqual((ScriptableObject) o1, (ScriptableObject) o2);
        }

        // Concatenated strings in Rhino have a different type. We need to manually
        // resolve to String semantics, which is what the following lines do.
        if (o1 instanceof ConsString) {
            o1 = o1.toString();
        }
        if (o2 instanceof ConsString) {
            o2 = o2.toString();
        }
        
        // default comparison (hopefully they have meaningful equals())
        return o1.equals(o2);
    }
478133
@Override
  public int compare(final Object o1, final Object o2) {
    return String.CASE_INSENSITIVE_ORDER.compare(String.valueOf(o1), String.valueOf(o2));
  }
171424
public int compare(Object objA, Object objB)
    {
        if (!(objA instanceof DefBase) || !(objB instanceof DefBase))
        {
            return 0;
        }
        else
        {
            return ((DefBase)objA).getName().compareTo(((DefBase)objB).getName());
        }
    }
385819
public boolean greaterThanOrEqual(XObject obj2)
          throws javax.xml.transform.TransformerException
  {
    return compare(obj2, S_GTE);
  }