Checks to see if two artifacts are of the same type (but not necessarily the same version)

@param first  An Artifact
@param second A comparison Artifact
@return true if the Artifacts match, false if they don't
189497
public static boolean artifactsAreMatchingTypes(Artifact first, Artifact second) {
        return first.getGroupId().equals(second.getGroupId()) &&
                first.getArtifactId().equals(second.getArtifactId()) &&
                first.getExtension().equals(second.getExtension()) &&
                first.getClassifier().equals(second.getClassifier());
    }
1289156
public static boolean areObjectsEqual(Object obj1, Object obj2) {
        boolean equal = false;
        if(obj1 == null && obj2 == null) {
            equal = true;
        } else {
            if(obj1 != null) {
                if(obj1.equals(obj2)) {
                    equal = true;
                }
            }
        }
        return equal;
    }
317149
public static boolean overlaps(final Map.Entry<Double, Double> first,
                                   final Map.Entry<Double, Double> second) {
        return second.getValue() > first.getKey() && second.getKey() < first.getValue();
    }
137100
public boolean equal(final Object o1,
                         final Object o2) {
        if ( o1 instanceof InternalFactHandle ) {
            return ((InternalFactHandle) o1).getId() == ((InternalFactHandle) o2).getId();
        }
        Object left = o1;
        final InternalFactHandle handle = ((InternalFactHandle) o2);

        if ( left == handle.getObject() ) {
            return true;
        } else if ( handle.getTraitType() == TraitTypeEnum.WRAPPED_TRAITABLE ) {
            return left == ( (CoreWrapper) handle.getObject() ).getCore();
        } else {
            return false;
        }
    }
1018397
public boolean isMatch(Endpoint other) {
        assert isMarker() : "isMatch can only be used on marker end-points";

        // Same structure as compareTo, except that nulls 'match' IDs (not <)
        int ans = 0;

        // A null edgeLabel implies that all endpoints of that vertex must be
        // matched
        if (edgeLabel == null) {
            return true;
        }

        if (other.getEdgeLabel() == null) {
            // This is not a match because the existing Endpoint no label, but
            // the marker does
            return false;
        }

        ans = edgeLabel.compareTo(other.getEdgeLabel());
        if (ans != 0) {
            return false;
        }

        // A null edgeId implies the 'first' edge for the given vertex for the
        // given edgeLabel
        if (edgeId == null) {
            return true;
        }

        return (edgeId.compareTo(other.getEdgeId()) == 0);
    }
523415
protected boolean isMatchingFirstParameterDeepCheck(JvmOperation feature) {
		if (isMatchingFirstParameter(feature)) {
			if (isResolvedReceiverType()) {
				LightweightTypeReference parameterType = argumentType.getOwner().toLightweightTypeReference(feature.getParameters().get(0).getParameterType());
				if (isResolvedOrKnownTypeParam(parameterType) && !parameterType.isAssignableFrom(argumentType)) {
					return false;
				}
			}
			return true;
		}
		return false;
	}
500501
public static boolean isEqualSeq(final String first, final String second, final String delimiter) {
    if (isNotEmpty(first) && isNotEmpty(second)) {
      String[] firstWords = split(first, delimiter);
      Set<String> firstSet = CollectUtils.newHashSet();
      for (int i = 0; i < firstWords.length; i++) {
        firstSet.add(firstWords[i]);
      }
      String[] secondWords = split(second, delimiter);
      Set<String> secondSet = CollectUtils.newHashSet();
      for (int i = 0; i < secondWords.length; i++) {
        secondSet.add(secondWords[i]);
      }
      return firstSet.equals(secondSet);
    } else {
      return isEmpty(first) & isEmpty(second);
    }
  }
203238
public boolean match(MimeType other) {
	if (this == other) return true;
	if (type != null && other.type != null && !type.equals(other.type)) return false;
	if (subtype != null && other.subtype != null && !subtype.equals(other.subtype)) return false;
	return true;
    }
1056117
private List<String> diff(Collection<String> first, Collection<String> second) {
        final ArrayList<String> list = new ArrayList<String>(first);
        list.removeAll(second);
        return list;
    }
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;
  }
565399
public boolean areUnified(E e1, E e2) {
	return find(e1).equals(find(e2));
    }
276684
@Override
    public boolean areEndPointsEqual(Object ep1, Object ep2)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "areEndPointsEqual", new Object[] { ep1, ep2 });

        boolean isEqual = false;

        if (ep1 instanceof CFEndPoint && ep2 instanceof CFEndPoint)
        {
            CFEndPoint cfEp1 = (CFEndPoint) ep1;
            CFEndPoint cfEp2 = (CFEndPoint) ep2;

            // The CFW does not provide an equals method for its endpoints.
            // We need to manually equals the important bits up
            isEqual = isEqual(cfEp1.getAddress(), cfEp2.getAddress()) &&
                      isEqual(cfEp1.getName(), cfEp2.getName()) &&
                      cfEp1.getPort() == cfEp2.getPort() &&
                      cfEp1.isLocal() == cfEp2.isLocal() &&
                      cfEp1.isSSLEnabled() == cfEp2.isSSLEnabled();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "areEndPointsEqual", Boolean.valueOf(isEqual));
        return isEqual;
    }
965865
public static boolean isGreater(BigDecimal bigNum1, BigDecimal bigNum2) {
		Assert.notNull(bigNum1);
		Assert.notNull(bigNum2);
		return bigNum1.compareTo(bigNum2) > 0;
	}
426272
public static Type getMoreSpecificType(final Type one, final Type two) {
        return isMoreSpecific(one, two) ? one : two;
    }
344225
public boolean match( Artifact artifact )
        throws InvalidVersionSpecificationException
    {
        for ( Pattern pattern : patterns )
        {
            if ( pattern.match( artifact ) )
            {
                for ( Pattern ignorePattern : ignorePatterns )
                {
                    if ( ignorePattern.match( artifact ) )
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }
155569
private boolean compareRelation(RCCConstraint first,
			RCCConstraint second) {
		
		boolean existed = false;
		for (int i = 0; i < first.types.length; i++) {
			existed = false;
			for (int j = 0; j < second.types.length; j++) {
				if(first.types[i] == second.types[j])
					existed = true;
			}
			if(!existed) return false;
		}
		
		return true;
	}
870039
public static boolean typeInsnEqual(TypeInsnNode insn1, TypeInsnNode insn2)
	{
		if (insn1.desc.equals("~") || insn2.desc.equals("~"))
			return true;

		return insn1.desc.equals(insn2.desc);
	}