Matches this descriptor to another descriptor by all fields. No exceptions
are made.

@param descriptor the descriptor to match this one against.
@return true if descriptors match and false otherwise.

@see #match(Descriptor)
437955
public boolean exactMatch(Descriptor descriptor) {
		return exactMatchField(_group, descriptor.getGroup()) && exactMatchField(_type, descriptor.getType())
				&& exactMatchField(_kind, descriptor.getKind()) && exactMatchField(_name, descriptor.getName())
				&& exactMatchField(_version, descriptor.getVersion());
	}
1183760
@java.lang.SuppressWarnings({ "ConstantConditions" })
    public void setDescriptor(@NotNull TagDescriptor descriptor)
    {
        if (descriptor == null)
            throw new NullPointerException("cannot set a null descriptor");
        _descriptor = descriptor;
    }
87244
public boolean matches(ESigItem item) {
        if (selected != null && item.isSelected() != selected) {
            return false;
        }
        
        if (eSigType != null && !item.getESigType().equals(eSigType)) {
            return false;
        }
        
        if (session != null && !item.getSession().equals(session)) {
            return false;
        }
        
        if (ids != null && !ids.contains(item.getId())) {
            return false;
        }
        
        return true;
    }
1293362
public boolean contains(Matcher matcher) {
        return element.matcher == matcher || (parent != null && parent.contains(matcher));
    }
595750
static Matcher zeroOrMoreFalse(Matcher matcher) {
    if (matcher instanceof ZeroOrMoreMatcher) {
      ZeroOrMoreMatcher zm = matcher.as();
      if (zm.repeated() instanceof FalseMatcher || zm.next() instanceof FalseMatcher) {
        return zm.next();
      }
    }
    return matcher;
  }
1342959
public static <T> DecomposableMatchBuilder1<T, T> caseThat(org.hamcrest.Matcher<T> matcher) {
    @SuppressWarnings("unchecked")
    List<Matcher<Object>> matchers = Lists.of((Matcher<Object>) HamcrestMatcher.of(matcher));

    return new DecomposableMatchBuilder1<>(matchers, 0, new IdentityFieldExtractor<>());
  }
1146925
public static Matcher<PrintableResult> hasSingleFailureMatching(final Matcher<Throwable> matcher) {
        return new TypeSafeMatcher<PrintableResult>() {
            @Override
            public boolean matchesSafely(PrintableResult item) {
                return item.failureCount() == 1 && matcher.matches(item.failures().get(0).getException());
            }

            public void describeTo(Description description) {
                description.appendText("has failure with exception matching ");
                matcher.describeTo(description);
            }
        };
    }
1226430
@Override
    public final MatchResult matches(final List<String> lines) {
        for (int i = 0; i < lines.size(); i++) {
            if (matches(i + 1, lines.get(i))) return new MatchResult(true, this, i);
        }
        return NO_MATCH;
    }
1034131
def has_descriptor(self, descriptor):
        
        for p in self.descriptors:
            if p in descriptor:
                return True
        return False
711421
public static Matcher not(final Matcher matcher) {
    return new Matcher() {
      @Override public boolean matches(Node node, NodeMetadata metadata) {
        return !matcher.matches(node, metadata);
      }
    };
  }
1186125
public static PropertyIdentifier getIdentifier(final ConfigDescriptor descriptor)
    {
        checkNotNull(descriptor);
        return new PropertyIdentifierImpl(descriptor.getConfigName(), descriptor.getMethod().getDeclaringClass());
    }
1218975
private static final boolean match(Object o1, Object o2) {
        return o1 instanceof String[] && o2 instanceof String[]
                        ? Arrays.deepEquals((String[]) o1, (String[]) o2)
                        : AdapterUtil.match(o1, o2);
    }
424398
public boolean isMatching(SLProperties properties) {
        for (Map.Entry<String, String> matcher : matchers) {
            if (!properties.includesValues(matcher.getKey(), matcher.getValue())) {
                return false;
            }
        }
        return true;
    }
332605
public static <S,V> boolean the(S subject, Feature<? super S,V> feature, Matcher<? super V> criteria) {
        return criteria.matches(feature.of(subject));
    }
194968
public boolean matches(final Node node) {
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            return matches(((Element) node).getAttribute(ATTRIBUTE_NAME_CLASS));
        }
        return false;
    }
308991
public static boolean matches(Class<? extends Annotation> anno, String consName) {
		return VALIDATORS.get(anno).equals(consName);
	}
590217
public boolean filterMatches(AbstractItem item)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "filterMatches", item);

    /* Cast the incoming item to a PersistentStoreReferenceStream object. if it is not, an
     * exception will be thrown and the match will fail */

    SIMPReferenceStream rstream;

    if (item instanceof SIMPReferenceStream) {

      rstream = (SIMPReferenceStream) item;
    
      // Check for matching consumer dispatchers
      if (rstream == consumerDispatcher.getReferenceStream())
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "filterMatches", Boolean.TRUE);        
        return true;
      }      
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "filterMatches", Boolean.FALSE);
    return false;

  }