Check if two {@link CharSequence}s are keyword identical.

This method is an alias of {@link #equals(CharSequence, CharSequence)}.

@param a the first char sequence
@param b the second char sequence
@return `true` if `a` and `b` are keyword identical
170145
public static boolean eq(CharSequence a, CharSequence b) {
        return of(a).equals(of(b));
    }
90364
public static boolean isEqualIgnoringCaseAndUnderscores(@NotNull String s1, @NotNull String s2) {
        int index1 = 0;
        int index2 = 0;
        int length1 = s1.length();
        int length2 = s2.length();

        while (index1 < length1 && index2 < length2) {
            char nameChar = s1.charAt(index1++);
            if (nameChar == '_') continue;

            char memberNameChar = s2.charAt(index2++);
            if (memberNameChar == '_') {
                index1--;
                continue;
            }

            if (toLowerCase(nameChar) != toLowerCase(memberNameChar))
                return false;
        }

        // Skip trailing underscores
        while (index1 < length1 && s1.charAt(index1) == '_') index1++;
        while (index2 < length2 && s2.charAt(index2) == '_') index2++;

        return index1 == length1 && index2 == length2;
    }
1124417
public boolean equalsIgnoreCase(CharSequence x) {
        if (x == this) return true;
        if (null == x || size() != x.length()) return false;
        if (isEmpty() && x.length() == 0) return true;
        return regionMatches(true, 0, x, 0, size());
    }
1360422
public static boolean areEqual(final String left, final String right)
   {
      if ((left == null) && (right == null))
      {
         return true;
      }
      else if ((left == null) || (right == null))
      {
         return false;
      }
      return left.equals(right);
   }
284758
public boolean precedesOrEqualsForAllOffsetTypesInBoth(final OffsetGroup other) {
    return charOffset().precedesOrEquals(other.charOffset())
        && edtOffset().precedesOrEquals(other.edtOffset())
        && (!byteOffset().isPresent() || !other.byteOffset().isPresent()
                || byteOffset().get().precedesOrEquals(other.byteOffset().get()))
        && (!asrTime().isPresent() || !other.asrTime().isPresent()
                || asrTime().get().precedesOrEquals(other.asrTime().get()));
  }
731624
@Override
    public boolean compareTokens(String a, String b) {
        if (isSignedToken()) {
            return crypto.compareSignedTokens(a, b);
        } else {
            return crypto.constantTimeEquals(a, b);
        }
    }
1091910
private boolean tagEquals(String tag1, String tag2) {
        if (caseSensitive) {
            return tag1.equals(tag2);
        }

        return tag1.equalsIgnoreCase(tag2);
    }
544249
@Override
  public boolean doIsEquals(NormalAnnotationExpr first, NormalAnnotationExpr second) {

    boolean equals = true;

    if (!first.getName().equals(second.getName())) equals = false;

    if (equals == true) {

      if (first.getPairs() == null) return second.getPairs() == null;

      if (!isSmallerHasEqualsInBigger(first.getPairs(), second.getPairs(), true)) return false;

    }

    return equals;
  }
898684
public static boolean isEqual(byte ba1[], byte ba2[]) {
		if(ba1.length!=ba2.length)return false;
		for(int i = 0;i<ba1.length; ++i) {
			if(ba1[i]!=ba2[i])return false;
		}
		return true;
	}
147785
public boolean sameComponent(V a, V b) {
        return componentOf(a).equals(componentOf(b));
    }
693134
protected function tokensEqual($a, $b)
    {
        if (is_string($a) && is_string($b)) {
            return $a === $b;
        } elseif (isset($a[0], $a[1], $b[0], $b[1])) {
            return $a[0] === $b[0] && $a[1] == $b[1];
        }

        return false;
    }
745164
public static boolean isMatch(Method methodA, Method methodB)
  {
    if (! methodA.getName().equals(methodB.getName()))
      return false;

    return isMatch(methodA.getParameterTypes(),
                   methodB.getParameterTypes());
  }
1175474
private static boolean samePattern(String value1, String value2) {
        if (value1.length() == 0) {
            return value2.length() == 0;
        }
        if (value1.charAt(0) == '{') {
            return value2.length() > 0 && value2.charAt(0) == '{';
        }
        return value1.equals(value2);
    }
1200755
private boolean areTypeNamesEqual(String name1, String name2) {
    return name1.replace('$', '.').equals(name2.replace('$', '.'));
  }
950952
private boolean isEqual(Object a, Object b) {

        if (a == null) {
            return (b == null);
        }
        if (b == null) {
            return false;
        }
        return a.equals(b);
    }
1179743
@Deprecated
    public static int matchAfter(CharSequence a, CharSequence b, int aIndex, int bIndex) {
        int i = aIndex, j = bIndex;
        int alen = a.length();
        int blen = b.length();
        for (; i < alen && j < blen; ++i, ++j) {
            char ca = a.charAt(i);
            char cb = b.charAt(j);
            if (ca != cb) {
                break;
            }
        }
        // if we failed a match make sure that we didn't match half a character
        int result = i - aIndex;
        if (result != 0 && !onCharacterBoundary(a, i) && !onCharacterBoundary(b, j)) {
            --result; // backup
        }
        return result;
    }
1095198
public static boolean safeEquals(String a, String b) {
        if (a.length() != b.length()) {
            return false;
        } else {
            char equal = 0;
            for (int i = 0; i < a.length(); i++) {
                equal |= a.charAt(i) ^ b.charAt(i);
            }
            return equal == 0;
        }
    }