Examples of matches()

• aQute.lib.osgi.Instruction.matches()
• aima.core.learning.inductive.DLTest.matches()
• br.com.objectos.way.ui.RequestURIGrep.matches()
• buildcraft.core.inventory.filters.ArrayStackFilter.matches()
• buildcraft.core.inventory.filters.StatementParameterStackFilter.matches()
• ca.odell.glazedlists.impl.matchers.PropertyEventNameMatcher.matches()
  {@inheritDoc}
• cbg.editor.jedit.Mode.matches()
  Answer true if the receiver can represent the filename.
• ch.entwine.weblounge.common.url.UrlMatcher.matches()
  Returns true if url matches the url space that is defined by this matcher. @param url the url to match against this url space @param flavor the request flavor @return true if url is within the defined urlspace
• ch.inftec.ju.util.RegexUtil.matches()
  Checks if a String matches the pattern. @param s String @return True if the string matches the pattern
• client.net.sf.saxon.ce.regex.ARegularExpression.matches()
  Determine whether the regular expression matches a given string in its entirety @param input the string to match @return true if the string matches, false otherwise
• com.aicontest.visualizer.js.tasks.EventExecutionUnit.matches()
• com.alexgilleran.icesoap.xpath.elements.XPathElement.matches()
• com.alibaba.citrus.webx.util.RequestURIFilter.matches()
• com.btaz.util.reader.xml.xmlpath.XmlPath.matches()
  Compare an XML node path with the path query @param nodePath XML data path @return {@code boolean} true if a match
• com.btaz.util.xml.xmlpath.XmlPath.matches()
  Compare an XML node path with the path query @param nodePath XML data path @return {@code boolean} true if a match
• com.calclab.emite.xtesting.matchers.IsPacketLike.matches()
• com.caucho.util.CharBuffer.matches()
• com.caucho.util.CharSegment.matches()
• com.cloudera.cdk.morphline.shaded.com.google.code.regexp.Matcher.matches()
  Attempts to match the entire region against the pattern.

  If the match succeeds then more information can be obtained via the start, end, and group methods.

  @return true if, and only if, the entire region sequencematches this matcher's pattern
• com.cloudera.cdk.morphline.shaded.org.apache.hadoop.fs.GlobPattern.matches()
  Match input against the compiled glob pattern @param s input chars @return true for successful matches
• com.codahale.metrics.MetricFilter.matches()
  Returns {@code true} if the metric matches the filter; {@code false} otherwise. @param name the metric's name @param metric the metric @return {@code true} if the metric matches the filter
• com.dci.intellij.dbn.language.common.psi.NamedPsiElement.matches()
• com.dci.intellij.dbn.object.common.DBObjectType.matches()
• com.dotcms.repackage.org.apache.oro.text.regex.Perl5Matcher.matches()
• com.flaptor.indextank.index.scorer.MatchFilter.matches()
• com.foundationdb.server.types.texpressions.Matcher.matches()
• com.google.apphosting.utils.config.WebXml.matches()
  Returns true if {@code url} matches one of the servlets orservlet filters listed in this web.xml.
• com.google.code.regexp.Matcher.matches()
• com.google.code.regexp.NamedMatcher.matches()
• com.google.greaze.definition.CallPath.matches()
• com.hp.hpl.jena.graph.Node.matches()
  Answer true iff this node accepts the other one as a match. The default is an equality test; it is over-ridden in subclasses to provide the appropriate semantics for literals, ANY, and variables. @param other a node to test for matching @return true iff this node accepts the other as a match
• com.jitlogic.zorka.common.util.StringMatcher.matches()
• com.mossle.bpm.rule.RuleMatcher.matches()
• com.mucommander.ui.quicksearch.QuickSearch.matches()
  Returns true if the current quick search string matches the given string. Always returns false when the quick search is inactive. @param string the string to test against the quick search string @return true if the current quick search string matches the given string
• com.mysema.query.types.path.StringPath.matches()
• com.omnicarecr.accounts.util.UnixCrypt.matches()
• com.openshift.client.cartridge.query.LatestVersionQuery.matches()
• com.projity.pm.graphic.spreadsheet.SpreadSheetSearchContext.matches()
• com.puppetlabs.geppetto.forge.model.Dependency.matches()
  @param metadata @return
• com.sun.enterprise.admin.common.CombinedPatternMatcher.matches()
• com.sun.enterprise.admin.util.IPatternMatcher.matches()
• com.sun.media.format.WavAudioFormat.matches()
• com.sun.messaging.jmq.jmsserver.core.PacketReference.matches()
• com.sun.org.apache.xerces.internal.impl.xpath.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• com.sun.star.tool.starjar.regex.PatternMatcher.matches()
• com.sun.star.tool.starjar.regex.Perl5Matcher.matches()
• com.sun.tools.javac.main.JavacOption.matches()
  Does argument string match option pattern? @param arg the command line argument string @return true if {@code arg} matches this option
• com.sun.tools.javac.main.JavacOption.Option.matches()
• com.tuenti.supernanny.repo.artifacts.Requirement.matches()
• com.volantis.styling.impl.engine.matchers.AttributeMatcher.matches()
• com.volantis.styling.impl.engine.matchers.DefaultNamespaceMatcher.matches()
• com.volantis.styling.impl.engine.matchers.LocalNameMatcher.matches()
• com.volantis.styling.impl.engine.matchers.Matcher.matches()
  @param context @return
• com.volantis.styling.impl.engine.matchers.NamespaceMatcher.matches()
• com.volantis.styling.impl.engine.matchers.NthChildMatcher.matches()
• com.volantis.testtools.mock.value.ExpectedValue.matches()
  Checks to see whether an object matches this value.

  Exactly what determines a match is defined by the implementations of this class, some will require exact matches, others will be more lenient.

  @param object The object to match. @return True if it does match and false otherwise.
• com.xmultra.util.Strings.matches()
  Returns true if "pattern" regular expression is found in the "input" string, false if it is not. @param pattern The pattern to search for. @param input The input string. @return True if the pattern is found in the input, false ifit is not.
• de.danielbechler.diff.path.NodePath.matches()
• de.desy.tine.stringUtils.WildcardMatch.matches()
• de.susebox.jtopas.impl.PatternMatcher.matches()
  This method checks if the start of a character range given through the {@link DataProvider} matches a pattern. See {@link PatternHandler#matches}for details. @param dataProvider the source to get the data from @param freePatternOnly if true only unbounded pattern should bechecked (pattern not enclosed in whitespaces, separators etc.) @return a {@link PatternHandler.Result} object or null if nomatch was found @throws TokenizerException generic exception @throws NullPointerException if no {@link DataProvider} is given
• de.susebox.jtopas.spi.PatternHandler.matches()
  This method checks if the start of a character range given through the {@link DataProvider} matches a pattern. An implementation should usea {@link de.susebox.jtopas.TokenizerException} to report problems.
  The method returns null if the beginning of the character range doesn't match a pattern known to the PatternHandler. Otherwise it returns an object with the implemented interface {@link PatternHandler.Result}.
  The pattern check is repeated if the method returns a match that is exactly as long as the given data range and more data is available. Since it is probably a rare case, that where are not enough data to find a complete or no match, the overhead of a repeated check on part of the data is neglected.
  If a pattern handler has more than one pattern that could be applied to the given data, it should return the longest possible match. @param dataProvider the source to get the data from @param lengthOfMatch if a match is found, the method places the length ofit into the first element of this array @return a {@link PatternHandler.Result} object or null if nomatch was found @throws TokenizerException generic exception @throws NullPointerException if no {@link DataProvider} is given
• de.willuhn.io.FileFinder.matches()
• de.willuhn.jameica.hbci.rmi.UmsatzTyp.matches()
  Prueft, ob der Umsatz diesem Pattern entspricht. Ist fuer den Umsatz-Typ kein Pattern definiert, liefert die Funktion immer false. @param umsatz zu pruefender Umsatz. @return true, wenn er dem Pattern entspricht. @throws RemoteException @throws PatternSyntaxException wird geworden, wenn es ein regulaerer Ausdruck mit Fehlern ist.
• devplugin.ProgramSearcher.matches()
  Checks whether a field of a program matches to the criteria of this searcher. @param prog The program to check. @param typeArr The fields to check. @return Whether at least one field of the program matches.
• edu.american.student.redis.hadoop.RedisBigTableKey.matches()
• edu.cmu.cs.fusion.constraint.operations.BeginOfMethodOp.matches()
• edu.cmu.cs.fusion.constraint.operations.ConstructorOp.matches()
• edu.cmu.cs.fusion.constraint.operations.EndOfMethodOp.matches()
• edu.cmu.cs.fusion.constraint.operations.MethodInvocationOp.matches()
• fitnesse.testsystems.slim.CustomComparator.matches()
  Compare two string representations, to determine whether the expected result matches the actual result. @param actual String representation of the actual result @param expected String representation of the expected result @return true if they match, false if they don't match @throws Throwable if an exception or error is thrown, the throwable message is appendedto the failure output
• freenet.io.Inet6AddressMatcher.matches()
• games.stendhal.common.parser.Expression.matches()
  Check if two Expressions match exactly. @param other Expression @return true if two expression match, false otherwise
• games.stendhal.server.entity.item.HouseKey.matches()
  Check if the key matches a portal. @param houseId identifier of the portal @param number number of the lock @return true if the key fits the lock, false otherwise
• gnu.javax.swing.text.html.parser.support.low.pattern.matches()
• gov.nasa.jpf.util.MethodSpec.matches()
• groovy.xml.QName.matches()
  Tests if this QName matches another object.

  If the given object is not a QName or String equivalent or is null then this method returns false.

  For two QNames to be considered matching requires that both localPart and namespaceURI must be equal or one of them is a wildcard. If the supplied object is a String, then it is split in two on the last colon and the first half is matched against the prefix || namespaceURI and the second half is matched against the localPart @param o the reference object with which to compare @return true if the given object matchesthis QName: false otherwise.

• hampi.constraints.Regexp.matches()
  Returns whether or not the given string matches this expression.
• invtweaks.InvTweaksItemTree.matches()
  Checks it given item ID matches a given keyword (either the item's name is the keyword, or it is in the keyword category) @param item @param keyword @return
• io.druid.query.filter.ValueMatcher.matches()
• io.fabric8.agent.resolver.RequirementImpl.matches()
• io.fabric8.gateway.support.UriTemplate.matches()
• io.fathom.cloud.openstack.client.dns.model.Recordset.matches()
• io.undertow.websockets.core.protocol.Handshake.matches()
  Return {@code true} if this implementation can be used to issue a handshake.
• io.undertow.websockets.jsr.handshake.JsrHybi13Handshake.matches()
• java.lang.String.matches()
  Tells whether or not this string matches the given regular expression.

  An invocation of this method of the form str.matches(regex) yields exactly the same result as the expression

  {@link java.util.regex.Pattern}. {@link java.util.regex.Pattern#matches(String,CharSequence) matches}(regex, str)

  @param regex the regular expression to which this string is to be matched @return true if, and only if, this string matches thegiven regular expression @throws PatternSyntaxException if the regular expression's syntax is invalid @see java.util.regex.Pattern @since 1.4 @spec JSR-51
• java.nio.file.PathMatcher.matches()
  Tells if given path matches this matcher's pattern. @param path the path to match @return {@code true} if, and only if, the path matches thismatcher's pattern
• java.util.Collection.matches()
• java.util.regex.Matcher.matches()
  Attempts to match the entire region against the pattern.

  If the match succeeds then more information can be obtained via the start, end, and group methods.

  @return true if, and only if, the entire region sequencematches this matcher's pattern
• javango.core.SubappUrl.matches()
• javax.media.Format.matches()
• javax.media.format.AudioFormat.matches()
• javax.media.format.H261Format.matches()
• javax.media.format.H263Format.matches()
• javax.media.format.IndexedColorFormat.matches()
• javax.media.format.JPEGFormat.matches()
• javax.media.format.RGBFormat.matches()
• javax.media.format.VideoFormat.matches()
• javax.media.format.YUVFormat.matches()
• javax.sound.sampled.AudioFormat.matches()
  Indicates whether this format matches the one specified. To match, two formats must have the same encoding, and consistent values of the number of channels, sample rate, sample size, frame rate, and frame size. The values of the property are consistent if they are equal or the specified format has the property value {@code AudioSystem.NOT_SPECIFIED}. The byte order (big-endian or little-endian) must be the same if the sample size is greater than one byte. @param format format to test for match @return {@code true} if this format matches the one specified,{@code false} otherwise.
• jmathexpr.arithmetic.op.Division.matches()
• jmathexpr.arithmetic.op.Exponentiation.matches()
• jmathexpr.arithmetic.op.Multiplication.matches()
• jmathexpr.arithmetic.op.Negation.matches()
• jmathexpr.arithmetic.pattern.FractionPattern.matches()
• jmathexpr.arithmetic.pattern.PolynomialTermPattern.matches()
• jmathexpr.util.pattern.ExpressionPattern.matches()
  Tests whether this pattern matches the given expression. Constants and variables in the pattern must be substituted if this method returns true. @param expr an arbitrary expression @return true if this pattern matches the given expression
• joshua.util.Regex.matches()
  Returns whether the input string matches this Regex.
• jregex.Matcher.matches()
  Tells whether a current target matches the whole pattern. For example the following yields the true:

   Pattern p=new Pattern("\\w+");  p.matcher("a").matches(); p.matcher("ab").matches(); p.matcher("abc").matches(); 

  and the following yields the false:

   p.matcher("abc def").matches(); p.matcher("bcd ").matches(); p.matcher(" bcd").matches(); p.matcher("#xyz#").matches(); 

  @return whether a current target matches the whole pattern.
• juzu.impl.router.Route.matches()
• mf.org.apache.xerces.impl.xpath.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• micdoodle8.mods.galacticraft.api.recipe.SpaceStationRecipe.matches()
• models.Rule.matches()
• net.glowstone.inventory.MaterialMatcher.matches()
  Returns true if the given {@link Material} matches the conditions of this MaterialMatcher. @param material the {@link Material} to check @return true if it matches, false otherwise
• net.mcft.copy.betterstorage.api.crafting.IRecipeInput.matches()
  Returns if the stack matches the input, ignores stack size.
• net.mcft.copy.betterstorage.misc.ItemIdentifier.matches()
  Returns if this item identifier matches the id, damage and data.
• net.minecraft.item.crafting.IRecipe.matches()
• net.sf.kpex.prolog.Term.matches()
  Tests if this term unifies with that. Bindings are trailed and undone after the test. This should be used with the shared term as this and the new term as that. Synchronization makes sure that side effects on the shared term are not interfering, i.e as in: SHARED.matches(NONSHARED,trail).
• net.sf.regain.crawler.config.UrlMatcher.matches()
  Checks whether a URL matches to the rules of this matcher. @param url The URL to check. @return Whether the given URL matches to the rules of this matcher.
• net.sf.saxon.pattern.ContentTypeTest.matches()
  Test whether this node test is satisfied by a given node @param nodeKind The type of node to be matched @param fingerprint identifies the expanded name of the node to be matched @param annotation The actual content type of the node
• net.sf.saxon.pattern.NodeTest.matches()
  Test whether this node test is satisfied by a given node on a TinyTree. The node must be a document, element, text, comment, or processing instruction node. This method is provided so that when navigating a TinyTree a node can be rejected without actually instantiating a NodeInfo object. The default implementation instantiates the node and then calls the method {@link #matches(NodeInfo)} @param tree the TinyTree containing the node @param nodeNr the number of the node within the TinyTree @return true if the node matches the NodeTest, otherwise false
• net.sf.saxon.regex.RegularExpression.matches()
  Determine whether the regular expression match a given string in its entirety @param input the string to match @return true if the string matches, false otherwise
• net.sourceforge.processdash.util.PatternList.matches()
• net.sourceforge.squirrel_sql.client.session.schemainfo.CatalogFilterMatcher.matches()
• net.sourceforge.squirrel_sql.client.session.schemainfo.ObjFilterMatcher.matches()
• net.sourceforge.squirrel_sql.client.session.schemainfo.SchemaFilterMatcher.matches()
• net.timewalker.ffmq3.common.message.MessageSelector.matches()
  Test the selector against a given message
• net.timewalker.ffmq3.security.Privilege.matches()
  Check if this privilege matches the given resource/action couple @param resourceName the resource name @param action the action name @return true if the privilege matches
• net.xeoh.plugins.diagnosis.local.util.conditions.matcher.Matcher.matches()
  Returns true if the matcher matches, false if not. @param object @return .
• nz.co.abrahams.asithappens.flow.Flow.matches()
  Compares this flow against another flow. @param other flow to compare against @return true if this flow matches the given flow
• org.aavso.tools.vstar.data.filter.MagnitudeFieldMatcher.matches()
• org.aavso.tools.vstar.data.filter.ObsCodeFieldMatcher.matches()
• org.aavso.tools.vstar.data.filter.ObservationFilter.matches()
  Does the specified observation satisfy all this filter's matchers? The matching process is short-circuited when one sub-filter fails. @param ob The observation under test. @return True or false. @precondition It only makes sense to call this method when 'matchers' isnon-empty, otherwise all observations will be filtered in.
• org.activemq.filter.Filter.matches()
  @return true if this filter matches the given JMS message
• org.activemq.message.ActiveMQDestination.matches()
  @param destination @return true if the given destination matches this destination; including wildcards
• org.antlr.v4.runtime.atn.Transition.matches()
• org.apache.abdera.i18n.lang.Lang.matches()
• org.apache.abdera.i18n.rfc4646.Range.matches()
  True if the lang tag matches this range
• org.apache.abdera.util.lang.Lang.matches()
• org.apache.activemq.apollo.filter.BooleanExpression.matches()
  @param message @return true if the expression evaluates to Boolean.TRUE. @throws FilterException
• org.apache.activemq.broker.region.Subscription.matches()
  Is the subscription interested in the message? @param node @param context @return @throws IOException
• org.apache.activemq.filter.BooleanExpression.matches()
  @param message @return true if the expression evaluates to Boolean.TRUE. @throws JMSException
• org.apache.activemq.filter.DestinationFilter.matches()
• org.apache.aries.application.VersionRange.matches()
  This method tests to see if the provided version is inside this range. @param version the version to test. @return true if the version matches, false otherwise.
• org.apache.aries.util.VersionRange.matches()
  This method checks that the provided version matches the desired version. @param version the version. @return true if the version matches, false otherwise.
• org.apache.avalon.meta.info.ReferenceDescriptor.matches()
  Determine if specified service will match this service. To match a service has to have same name and must comply with version. @param other the other ServiceInfo @return true if matches, false otherwise
• org.apache.avalon.meta.info.Service.matches()
  Determine if supplied reference will match this service. To match a service has to have same classname and must comply with version. @param reference the reference descriptor @return true if matches, false otherwise
• org.apache.camel.BinaryPredicate.matches()
• org.apache.camel.Predicate.matches()
  Evaluates the predicate on the message exchange and returns true if this exchange matches the predicate @param exchange the message exchange @return true if the predicate matches
• org.apache.camel.builder.NotifyBuilder.matches()
  Does all the expression match?

  This operation will return immediately which means it can be used for testing at this very moment. @return true if matching, false otherwise

• org.apache.camel.impl.scan.AnnotatedWithPackageScanFilter.matches()
• org.apache.camel.impl.scan.AssignableToPackageScanFilter.matches()
• org.apache.camel.spi.PackageScanFilter.matches()
  Does the given class match @param type the class @return true to include this class, false to skip it.
• org.apache.camel.support.XMLTokenExpressionIterator.AttributedQName.matches()
• org.apache.ftpserver.usermanager.PasswordEncryptor.matches()
  Matches an encrypted password with that stored @param passwordToCheck The encrypted password to check @param storedPassword The stored password @return true if the password match
• org.apache.geronimo.gbean.AbstractNameQuery.matches()
• org.apache.geronimo.gbean.GBeanName.matches()
  Determine if this name matches the supplied pattern. This performs a fast but simplistic pattern match which is true if:

  • The domains are equal
  • If this instance has all the supplied properties with equal values
  A null domain and a null or empty properties object are considered wildcards and always match; in other words GBeanName.match(null, new Properties()) will always evaluate to true. @param domain the domain to match @param pattern the set properties to match; a Map @return true if this instance matches the pattern
• org.apache.geronimo.kernel.repository.Artifact.matches()
  see if this artifact matches the other artifact (which is more specific than this one) @param otherArtifact the more specific artifact we are comparing with @return whether the other artifact is consistent with everything specified in this artifact.
• org.apache.harmony.pack200.AttributeLayout.matches()
• org.apache.harmony.unpack200.AttributeLayout.matches()
• org.apache.isis.runtimes.dflt.runtime.persistence.query.PersistenceQueryBuiltIn.matches()
  The built-in queries iterate over all instances.

  This is similar to the {@link Filter} interface in the applib, except thefiltering is done within the object store as opposed to be the {@link DomainObjectContainer}.

  Object store implementations do not necessarily need to rely on this method. For example, an RDBMS-based implementation may use an alternative mechanism to determine the matching results, for example using a WHERE clause in some SQL query.

• org.apache.isis.viewer.json.viewer.representations.LinkFollower.matches()
  Ensure that every key present in the provided map matches the criterium.

  Any keys in the criterium that are not present in the map will be ignored.

• org.apache.isis.viewer.restfulobjects.rendering.LinkFollowSpecs.matches()
  Ensure that every key present in the provided map matches the criterium.

  Any keys in the criterium are ignored (these were matched on during the {@link #follow(String,Object)} call).

• org.apache.ivy.plugins.matcher.MapMatcher.matches()
• org.apache.ivy.plugins.matcher.Matcher.matches()
  Check whether a given string is matched by this matcher. @param input the string to be matched. Cannot be null. @return true if the input string is matched, false otherwise.
• org.apache.ivy.plugins.matcher.ModuleIdMatcher.matches()
• org.apache.jackrabbit.core.security.authentication.CryptedSimpleCredentials.matches()
  Compares this instance with the given SimpleCredentials and returns true if both match. Successful match is defined to be the result of

  • Case-insensitive comparison of the UserIDs
  • Equality of the passwords if the password contained in the simple credentials is hashed with the algorithm defined in this credentials object.

  NOTE, that the simple credentials are exptected to contain the plain text password. @param credentials An instance of simple credentials. @return true if {@link SimpleCredentials#getUserID() UserID} and{@link SimpleCredentials#getPassword() Password} match. @throws NoSuchAlgorithmException @throws UnsupportedEncodingException
• org.apache.jackrabbit.mk.json.JsopReader.matches()
  Read a token which must match a given token type. @param type the token type @return true if there was a match
• org.apache.jackrabbit.mk.json.JsopTokenizer.matches()
  Read a token which must match a given token type. @param type the token type @return true if there was a match
• org.apache.jackrabbit.oak.commons.json.JsopReader.matches()
  Read a token which must match a given token type. @param type the token type @return true if there was a match
• org.apache.jackrabbit.oak.commons.json.JsopTokenizer.matches()
  Read a token which must match a given token type. @param type the token type @return true if there was a match
• org.apache.jackrabbit.oak.query.fulltext.LikePattern.matches()
• org.apache.jackrabbit.oak.spi.security.authentication.token.TokenInfo.matches()
  Returns {@code true} if the specified credentials can be successfullyvalidated against the information stored in this instance. @param tokenCredentials The credentials to validate. @return {@code true} if the specified credentials can be successfullyvalidated against the information stored in this instance; {@code false}otherwise.
• org.apache.lenya.cms.linking.LinkRewriter.matches()
  @param url The URL. @return If this rewriter feels responsible for the URL.
• org.apache.lenya.cms.linking.OutgoingLinkRewriter.matches()
• org.apache.marmotta.commons.http.ContentType.matches()
  Return true if the ContentType matches with another content type, not taking into account wildcards and possible "+" extensions. @param contentType @return
• org.apache.metamodel.util.WildcardPattern.matches()
• org.apache.muse.ws.dm.muws.Correlation.matches()
  @param epr The EPR of another resource which may be the same as this resource. @return True if the two resources are the same according to their WSDM ResourceId values or their WSDM CorrelatableProperties expressions. Note that if the method returns 'false', this does not guarantee that the two resources are actually different - you can only confirm this by checking with the hasNegativeAssertions() method. @throws SoapFault

  • If there is a problem reading the correlatable properties from either resource.
  • If the values or dialects of the correlatable properties are not supported. The built-in dialects are WSDM Property Boolean Match (PBM) and XPath 1.0.

  @see #hasNegativeAssertion()
• org.apache.muse.ws.dm.muws.Match.matches()
  @param epr The EPR to another resource which may be the same as this resource. @return True if the two resources are the same according to the conditional test executed by the Match.
• org.apache.nutch.util.mime.MimeType.matches()
• org.apache.openjpa.lib.util.SimpleRegex.matches()
• org.apache.oro.text.regex.PatternMatcher.matches()
  Determines if a string exactly matches a given pattern. If there is an exact match, a MatchResult instance representing the match is made accesible via {@link #getMatch()}.

  @param input The String to test for an exact match. @param pattern The Pattern to be matched. @return True if input matches pattern, false otherwise.

• org.apache.oro.text.regex.Perl5Matcher.matches()
  Determines if a string (represented as a char[]) exactly matches a given pattern. If there is an exact match, a MatchResult instance representing the match is made accesible via {@link #getMatch()}. The pattern must be a Perl5Pattern instance, otherwise a ClassCastException will be thrown. You are not required to, and indeed should NOT try to (for performance reasons), catch a ClassCastException because it will never be thrown as long as you use a Perl5Pattern as the pattern parameter.

  Note: matches() is not the same as sticking a ^ in front of your expression and a $ at the end of your expression in Perl5 and using the =~ operator, even though in many cases it will be equivalent. matches() literally looks for an exact match according to the rules of Perl5 expression matching. Therefore, if you have a pattern foo|foot and are matching the input foot it will not produce an exact match. But foot|foo will produce an exact match for either foot or foo. Remember, Perl5 regular expressions do not match the longest possible match. From the perlre manpage:

  Alternatives are tried from left to right, so the first alternative found for which the entire expression matches, is the one that is chosen. This means that alternatives are not necessarily greedy. For example: when matching foo|foot against "barefoot", only the "foo" part will match, as that is the first alternative tried, and it successfully matches the target string.

  @param input The char[] to test for an exact match. @param pattern The Perl5Pattern to be matched. @return True if input matches pattern, false otherwise. @exception ClassCastException If a Pattern instance other than aPerl5Pattern is passed as the pattern parameter.

• org.apache.poi.hssf.record.formula.functions.CountUtils.I_MatchPredicate.matches()
• org.apache.poi.ss.formula.functions.CountUtils.I_MatchPredicate.matches()
• org.apache.qpid.client.filter.JMSSelectorFilter.matches()
• org.apache.qpid.client.filter.MessageFilter.matches()
• org.apache.qpid.server.filter.MessageFilter.matches()
• org.apache.qpid.server.security.access.firewall.FirewallRule.matches()
• org.apache.servicemix.jbi.container.SubscriptionSpec.matches()
  Returns true if this subscription matches the given message exchange @param exchange the exchange to be matched @return true if this subscription matches the exchange
• org.apache.shiro.util.PatternMatcher.matches()
  Returns true if the given source matches the specified pattern, false otherwise. @param pattern the pattern to match against @param source the source to match @return true if the given source matches the specified pattern,false otherwise.
• org.apache.sirona.configuration.predicate.PredicateEvaluator.matches()
• org.apache.solr.search.DocList.matches()
  Returns the total number of matches for the search (as opposed to just the number collected according to offset() and size()). Hence it's always true that matches() >= size() @return number of matches for the search(query & any filters)
• org.apache.solr.search.DocSlice.matches()
• org.apache.synapse.config.xml.SwitchCase.matches()
  To evaluate regular expression pattern to a get switch case @param value value to be tested over the regular expression of match @return boolean value
• org.apache.tapestry.ioc.IdMatcher.matches()
  Returns true if the provided input id matches the pattern defined by this matcher instance. @param id the fully qualfied id @return true on match, false otherwise
• org.apache.tapestry.runtime.ComponentEvent.matches()
  Returns true if the event matches the provided criteria. @param eventType the type of event (case insensitive match) @param componentId component is to match against (case insensitive), or the empty string @param parameterCount minimum number of context values @return true if the event matches.
• org.apache.tapestry.util.RegexpMatcher.matches()
• org.apache.tapestry5.ioc.IdMatcher.matches()
  Returns true if the provided input id matches the pattern defined by this matcher instance. @param id the fully qualfied id @return true on match, false otherwise
• org.apache.tapestry5.runtime.ComponentEvent.matches()
  Returns true if the event matches the provided criteria and the event has not yet been aborted. @param eventType the type of event (case insensitive match) @param componentId component is to match against (case insensitive), or the empty string @param parameterCount minimum number of context values @return true if the event matches (and has not yet been aborted)
• org.apache.tomcat.bayeux.ChannelImpl.matches()
  Returns true if this channel matches the pattern to its id. The channel pattern can be a complete name like /service/mychannel or it can be a wild card pattern like /service/app2/** @param pattern String according to the Bayeux specification section 2.2.1 Channel Globbing, can not be null. @return boolean true if the id of this channel matches the pattern
• org.apache.tools.ant.util.regexp.Regexp.matches()
• org.apache.tools.ant.util.regexp.RegexpMatcher.matches()
  Does the given argument match the pattern?
• org.apache.tuscany.sca.assembly.Endpoint.matches()
  Tests if the URI of this endpoint matches the service URI @param serviceName the service URI to test @return true if the endpoint URI matches the service URI
• org.apache.wicket.request.target.coding.IRequestTargetUrlCodingStrategy.matches()
  Gets whether this mounter is applicable for the provided request target. @param requestTarget the request target @return whether this mounter is applicable for the provided requesttarget
• org.apache.wicket.util.parse.metapattern.parsers.CommaSeparatedVariableParser.matches()
• org.apache.wicket.util.parse.metapattern.parsers.IntegerVariableAssignmentParser.matches()
• org.apache.wicket.util.parse.metapattern.parsers.VariableAssignmentParser.matches()
• org.apache.wink.common.internal.uritemplate.UriTemplateMatcher.matches()
  Match the provided uri against the uri template of this processor. If the match was successful, then it is possible to get the variable values from the matched uri. @param uri the uri to match against the processor template @return true if the uri matches the pattern, false otherwise
• org.apache.xerces.impl.validation.datatypes.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• org.apache.xerces.impl.xpath.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• org.apache.xerces.utils.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• org.apache.xmlbeans.impl.regex.RegularExpression.matches()
  Checks whether the target text contains this pattern or not. @return true if the target is matched to this regular expression.
• org.apache.zookeeper.server.auth.AuthenticationProvider.matches()
  This method is called to see if the given id matches the given id expression in the ACL. This allows schemes to use application specific wild cards. @param id the id to check. @param aclExpr the expression to match ids against. @return true if the id can be matched by the expression.
• org.apache.zookeeper_voltpatches.server.auth.AuthenticationProvider.matches()
  This method is called to see if the given id matches the given id expression in the ACL. This allows schemes to use application specific wild cards. @param id the id to check. @param aclExpr the expression to match ids against. @return true if the id can be matched by the expression.
• org.aspectj.weaver.ConcreteTypeMunger.matches()
• org.aspectj.weaver.patterns.DeclareAnnotation.matches()
  For declare atConstructor, atMethod, atField
• org.aspectj.weaver.patterns.TypePattern.matches()
• org.aspectj.weaver.tools.JoinPointMatch.matches()
  True if the pointcut expression has matched at this join point, and false otherwise
• org.axonframework.common.annotation.ParameterResolver.matches()
  Indicates whether this resolver is capable of providing a value for the given message. @param message The message to evaluate @return true if this resolver can provide a value for the message, otherwise false
• org.beangle.web.filter.RequestMatcher.matches()
  Decides whether the rule implemented by the strategy matches the supplied request. @param request the request to check for a match @return true if the request matches, false otherwise
• org.boris.expr.util.Criteria.matches()
• org.cafesip.jiplet.mapping.CriteriaMatch.matches()
• org.candlepin.guice.HttpMethodMatcher.matches()
• org.codehaus.activemq.filter.Filter.matches()
  @return true if this filter matches the given JMS message
• org.codehaus.activemq.message.ActiveMQDestination.matches()
  Returns true if the given destination matches this destination; including wildcards
• org.codehaus.aspectwerkz.expression.regexp.TypePattern.matches()
  Matches a type name. @param typeName the name of the type @return true if we have a matche
• org.codehaus.aspectwerkz.pointcut.CallerSidePointcut.matches()
  Checks if the pointcut matches a certain join point. @param className the class name @param methodMetaData the meta-data for the method @return boolean
• org.codehaus.aspectwerkz.pointcut.FieldPointcut.matches()
  Checks if the pointcut matches a certain join point. @param classMetaData the class meta-data @param fieldMetaData the meta-data for the field @return boolean
• org.codehaus.aspectwerkz.pointcut.MethodPointcut.matches()
  Checks if the pointcut matches a certain join point. @param className the name of the class @param methodMetaData the meta-data for the method @return boolean
• org.codehaus.aspectwerkz.pointcut.ThrowsPointcut.matches()
  Checks if the pointcut matches a certain join point. @param classMetaData the class meta-data @param methodMetaData the method meta-data @return boolean
• org.codehaus.aspectwerkz.regexp.CallerSidePattern.matches()
  Matches a caller side pointcut. @param className the class name @return true if we have a matches
• org.codehaus.aspectwerkz.regexp.ClassPattern.matches()
  Matches a class name. @param className the name of the class @return true if we have a matches
• org.codehaus.plexus.util.MatchPatterns.matches()
  Checks these MatchPatterns against a specified string.

  Uses far less string tokenization than any of the alternatives. @param name The name to look for @param isCaseSensitive If the comparison is case sensitive @return true if any of the supplied patterns match

• org.codenarc.source.SourceCodeCriteria.matches()
• org.codenarc.util.WildcardPattern.matches()
• org.cometd.bayeux.ChannelId.matches()

  Tests whether this {@code ChannelId} matches the given {@code ChannelId}.

  If the given {@code ChannelId} is {@link #isWild() wild}, then it matches only if it is equal to this {@code ChannelId}.

  If this {@code ChannelId} is non-wild,then it matches only if it is equal to the given {@code ChannelId}.

  Otherwise, this {@code ChannelId} is either shallow or deep wild, andmatches {@code ChannelId}s with the same number of equal segments (if it is shallow wild), or {@code ChannelId}s with the same or a greater number of equal segments (if it is deep wild).

  @param channelId the channelId to match @return true if this {@code ChannelId} matches the given {@code ChannelId}
• org.dcm4che3.data.Attributes.matches()
• org.dom4j.NodeFilter.matches()

  matches returns true if the given node matches the filter condition.

  @param node DOCUMENT ME! @return true if this filter matches the given node
• org.dom4j.XPath.matches()

  matches returns true if the given node matches the XPath expression. To be more precise when evaluating this XPath expression on the given node the result set must include the node.

  @param node DOCUMENT ME! @return true if the given node matches this XPath expression
• org.dom4j.rule.Pattern.matches()
  DOCUMENT ME! @param node DOCUMENT ME! @return true if the pattern matches the given DOM4J node.
• org.dom4j.rule.Rule.matches()
  DOCUMENT ME! @param node DOCUMENT ME! @return true if the pattern matches the given DOM4J node.
• org.drools.core.util.index.RightTupleList.matches()
• org.drools.util.TupleIndexHashTable.FieldIndexEntry.matches()
• org.easymock.IArgumentMatcher.matches()
  Returns whether this matcher accepts the given argument.

  Like Object.equals(), it should be aware that the argument passed might be null and of any type. So you will usually start the method with an instanceof and/or null check.

  The method should never assert if the argument doesn't match. It should only return false. EasyMock will take care of asserting if the call is really unexpected. @param argument the argument @return whether this matcher accepts the given argument.

• org.easymock.internal.EqualsMatcher.matches()
• org.eclipse.core.commands.operations.IUndoContext.matches()
  Return whether the specified context is considered a match for the receiving context. When a context matches another context, operations that have the context are considered to also have the matching context. @param context the context to be checked against the receiving context. @return true if the receiving context can be considered amatch for the specified context, and false if it cannot.
• org.eclipse.core.runtime.IStatus.matches()
  Returns whether the severity of this status matches the given severity mask. Note that a status with severity OK will never match; use isOK instead to detect a status with a severity of OK. @param severityMask a mask formed by bitwise or'ing severity maskconstants (ERROR, WARNING, INFO, CANCEL) @return true if there is at least one match, false if there are no matches @see #getSeverity() @see #CANCEL @see #ERROR @see #WARNING @see #INFO
• org.eclipse.core.runtime.preferences.IPreferencesService.matches()
• org.eclipse.emf.transaction.NotificationFilter.matches()
• org.eclipse.jface.text.templates.Template.matches()
  Returns true if template is enabled and matches the context, false otherwise. @param prefix the prefix (e.g. inside a document) to match @param contextTypeId the context type id to match @return true if template is enabled and matches the context,false otherwise
• org.eclipse.nebula.widgets.nattable.ui.matcher.CellLabelMouseEventMatcher.matches()
• org.eclipse.swt.widgets.Text.matches()
• org.eclipse.ui.IEditorMatchingStrategy.matches()
  Returns whether the editor represented by the given editor reference matches the given editor input.

  Implementations should inspect the given editor input first, and try to reject it early before calling IEditorReference.getEditorInput(), since that method may be expensive.

  @param editorRef the editor reference to match against @param input the editor input to match @return true if the editor matches the given editor input,false if it does not match
• org.eclipse.ui.dialogs.SearchPattern.matches()
  Matches text with pattern. matching is determine by matchKind. @param text @return true if search pattern was matched with text false in other way
• org.elasticsearch.action.index.IndexResponse.matches()
  Returns the percolate queries matches. null if no percolation was requested.
• org.elasticsearch.action.percolate.PercolateResponse.matches()
• org.exolab.castor.xml.XMLFieldDescriptor.matches()
  Returns true if this descriptor can be used to handle elements or attributes with the given XML name. By default this method simply compares the given XML name with the internal XML name. This method can be overridden to provide more complex matching. @param xmlName the XML name to compare @return true if this descriptor can be used to handle elements orattributes with the given XML name.
• org.freeplane.features.filter.Filter.matches()
• org.fusesource.ide.fabric8.ui.navigator.ContainerNode.matches()
• org.fusesource.ide.jmx.fabric8.navigator.ContainerNode.matches()
• org.geomajas.service.TestRecorder.matches()
  Verify that the messages for a group match. Returns a message with the problem or the empty string when everything matches.

  Expected to use in a test like Assert.assertEquals("", recorder.matches(GROUP, "bla"); @param group group to test messages for @param messages messages to compare @return emptry string on match or message about problem

• org.geotools.geometry.iso.topograph2D.IntersectionMatrix.matches()
  Returns true if the dimension value satisfies the dimension symbol. @param actualDimensionValue a number that can be stored in the IntersectionMatrix . Possible values are {TRUE, FALSE, DONTCARE, 0, 1, 2}. @param requiredDimensionSymbol a character used in the string representation of an IntersectionMatrix. Possible values are {T, F, * , 0, 1, 2}. @return true if the dimension symbol encompasses the dimension value
• org.ggp.base.util.gdl.model.SentenceForm.matches()
  Returns true iff the given sentence is of this sentence form.
• org.glassfish.hk2.api.Filter.matches()
  Returns true if this filter matches the given object @param d The object to match againstthis filter. May not be null @return true if this filter matches the object
• org.gradle.api.internal.file.pattern.PatternStep.matches()
• org.grails.plugin.platform.events.ListenerId.matches()
• org.hamcrest.Matcher.matches()
  Evaluates the matcher for argument item.

  This method matches against Object, instead of the generic type T. This is because the caller of the Matcher does not know at runtime what the type is (because of type erasure with Java generics). It is down to the implementations to check the correct type. @param item the object against which the matcher is evaluated. @return true if item matches, otherwise false. @see BaseMatcher

• org.hdiv.regex.PatternMatcher.matches()
  Executes the regular expression over the input String. @param input text to match over the regular expression @return true if regular expression matches
• org.hornetq.core.postoffice.Address.matches()
• org.impalaframework.service.ServiceReferenceFilter.matches()
• org.jasypt.digest.StandardByteDigester.matches()

  Checks a message against a given digest.

  This method tells whether a message corresponds to a specific digest or not by getting the salt with which the digest was created and applying it to a digest operation performed on the message. If new and existing digest match, the message is said to match the digest.

  This method will be used, for instance, for password checking in authentication processes.

  A null message will only match a null digest.

  @param message the message to be compared to the digest. @param digest the digest. @return true if the specified message matches the digest, falseif not. @throws EncryptionOperationNotPossibleException if the digest matchingoperation fails, ommitting any further information about the cause for security reasons. @throws EncryptionInitializationException if initialization could notbe correctly done (for example, if the digest algorithm chosen cannot be used).
• org.jasypt.digest.StandardStringDigester.matches()

  Checks a message against a given digest.

  This method tells whether a message corresponds to a specific digest or not by getting the salt with which the digest was created and applying it to a digest operation performed on the message. If new and existing digest match, the message is said to match the digest.

  This method will be used, for instance, for password checking in authentication processes.

  A null message will only match a null digest.

  @param message the message to be compared to the digest. @param digest the digest. @return true if the specified message matches the digest, falseif not. @throws EncryptionOperationNotPossibleException if the digest matchingoperation fails, ommitting any further information about the cause for security reasons. @throws EncryptionInitializationException if initialization could notbe correctly done (for example, if the digest algorithm chosen cannot be used).
• org.jbehave.core.mock.Expectation.matches()
• org.jbehave.core.mock.Matcher.matches()
• org.jberet.job.model.ExceptionClassFilter.matches()
  Checks if an exception should be included or excluded. @param clazz the exception to check @return {@code true} if the exception should be include, otherwise {@code false}
• org.jboss.aop.array.ArrayReplacement.matches()
• org.jboss.aop.introduction.AnnotationIntroduction.matches()
• org.jboss.aop.introduction.InterfaceIntroduction.matches()
• org.jboss.aop.metadata.ClassMetaDataBinding.matches()
• org.jboss.aop.pointcut.DeclareDef.matches()
• org.jboss.aop.pointcut.PointcutStats.matches()
• org.jboss.aop.pointcut.ast.ClassExpression.matches()
• org.jboss.as.jdr.util.WildcardPattern.matches()
• org.jboss.dna.common.text.TokenStream.matches()
  Determine if the current token matches the expected value.

  The {@link #ANY_VALUE ANY_VALUE} constant can be used as a wildcard.

  @param expected the expected value of the current token token @return true if the current token did match, or false if the current token did not match @throws IllegalStateException if this method was called before the stream was {@link #start() started}
• org.jboss.dna.jcr.xpath.XPath.NameTest.matches()
• org.jboss.dna.sequencer.ddl.DdlTokenStream.matches()
• org.jboss.errai.forge.xml.XmlParser.matches()
• org.jboss.errai.reflections.util.SimplePackageFilter.matches()
  @param className The class name to be matched. @return True iff the class name matches a package filter.
• org.jboss.forge.shell.PromptType.matches()
• org.jboss.ide.eclipse.freemarker.lang.ParserUtils.matches()
  A shorthand for {@code input.charAt(offset) == ch}.

  When called with {@code checkEndOfInput == true}, then {@link #checkEndOfInput(String)} iscalled first and eventually a {@link ParseException} is thrown if we areat end of input.

  Should be called {@code checkEndOfInput == false}, only if you are sure that {@link #offset} is not at end of input, e.g. bycalling {@link #isAtEndOfInput()} before {@link #matches(char,boolean)}. @param ch @param checkEndOfInput see above @throws ParseException

• org.jboss.metadata.ejb.spec.ExcludeListMetaData.matches()
  Whether this matches @param methodName the method name @param params the parameters @param interfaceType the interface type @return true when it matches
• org.jboss.metadata.ejb.spec.MethodsMetaData.matches()
  Whether this matches @param methodName the method name @param params the parameters @param interfaceType the interface type @return true when it matches
• org.jitterbit.util.string.StringMatcher.matches()
• org.jitterbit.util.string.WildcardStringMatcher.matches()
• org.jnode.net.ipv4.IPv4Address.matches()
  Does this address matches a given mask? @param mask
• org.jrdf.util.boundary.RegexMatcher.matches()
• org.jwall.web.audit.rules.AuditEventRule.matches()
  This method checks whether the rule triggers for the given event. @param evt The event to test the rule on. @return true if the rule matches the given event, false otherwise.
• org.jwall.web.audit.rules.operators.ConditionEQ.matches()
• org.jwall.web.audit.rules.operators.ConditionGE.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionGT.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionIN.matches()
  @see org.jwall.web.audit.rules.operators.ConditionSX#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionLE.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionLT.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionPM.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionRX.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.audit.rules.operators.ConditionSX.matches()
  @see org.jwall.web.audit.rules.Condition#matches(java.lang.String,java.lang.String)
• org.jwall.web.policy.TreeNode.matches()
• org.kitesdk.morphline.shaded.com.google.code.regexp.Matcher.matches()
  Attempts to match the entire region against the pattern.

  If the match succeeds then more information can be obtained via the start, end, and group methods.

  @return true if, and only if, the entire region sequencematches this matcher's pattern
• org.kitesdk.morphline.shaded.org.apache.hadoop.fs.GlobPattern.matches()
  Match input against the compiled glob pattern @param s input chars @return true for successful matches
• org.lilyproject.indexer.model.indexerconf.TypePattern.matches()
• org.mockito.internal.matchers.Any.matches()
• org.mockserver.matchers.HttpRequestMatcher.matches()
• org.mockserver.matchers.HttpResponseMatcher.matches()
• org.mockserver.mock.Expectation.matches()
• org.mockserver.mockserver.MappedRequest.matches()
• org.modeshape.common.text.TokenStream.matches()
  Determine if the current token matches the expected value.

  The {@link #ANY_VALUE ANY_VALUE} constant can be used as a wildcard.

  @param expected the expected value of the current token token @return true if the current token did match, or false if the current token did not match @throws IllegalStateException if this method was called before the stream was {@link #start() started}
• org.modeshape.jcr.query.xpath.XPath.NameTest.matches()
• org.modeshape.jcr.sequencer.SequencerPathExpression.Matcher.matches()
• org.modeshape.sequencer.ddl.DdlTokenStream.matches()
• org.objectstyle.wolips.core.resources.pattern.IPattern.matches()
  match the given text with the pattern @param string @return true if matched eitherwise false
• org.ocpsoft.rewrite.param.ParameterizedPatternResult.matches()
  Returns true if the {@link ParameterizedPattern} matched the input value, false if not.
• org.ontoware.rdf2go.model.TriplePattern.matches()
  @param statement must not be null; with subject, predicated and object defined. @return true if this pattern matches the given statement. Ignorescontext. @since RDF2Go 4.4.2
• org.openbp.core.model.ModelQualifier.matches()
  Checks if two qualifier descriptors match. The qualifier descriptors are considered matching if:
  - They are equal
  - One or both itemtypes are null and the rest is equal
• org.opencastproject.mediapackage.MediaPackageElementFlavor.matches()
• org.opentripplanner.routing.core.FareRuleSet.matches()
• org.opentripplanner.routing.core.StopMatcher.matches()
  Function to determine whether this StopMatcher matches a particular stop. When a stop has a parent stop, it is also matched when its parent stop is matched. @param stop is the stop to match using its ID @return true when the stop is matched
• org.osgi.framework.Filter.matches()
  Filter using a {@code Map}. This {@code Filter} is executed using thespecified {@code Map}'s keys and values. The keys are looked up in a normal manner respecting case. @param map The {@code Map} whose key/value pairs are used in the match.Maps with {@code null} key or values are not supported. A{@code null} value is considered not present to the filter. @return {@code true} if the {@code Map}'s values match this filter; {@code false} otherwise. @since 1.6
• org.pdf4j.saxon.pattern.ContentTypeTest.matches()
  Test whether this node test is satisfied by a given node @param nodeKind The type of node to be matched @param fingerprint identifies the expanded name of the node to be matched @param annotation The actual content type of the node
• org.pdf4j.saxon.regex.RegularExpression.matches()
  Determine whether the regular expression match a given string in its entirety @param input the string to match @return true if the string matches, false otherwise
• org.pentaho.reporting.engine.classic.core.Group.matches()
• org.pf.text.StringPattern.matches()
  Tests if a specified string matches the pattern. @param probe The string to compare to the pattern @return true if and only if the probe matches the pattern, false otherwise.
• org.projectforge.user.UserRight.matches()
  If a right should match independent on the value set for the given user. Should only be called, if the UserRightDO or its value is set to null. @param userGroupCache @param user @param value @return false. @see UserGroupsRight#matches(UserGroupCache,PFUserDO,UserRightValue)
• org.serviceconnector.service.SubscriptionMask.matches()
  Matches. @param message the message @return true, if successful
• org.servicemix.jbi.container.SubscriptionSpec.matches()
  Returns true if this subscription matches the given message exchange @param exchange the exchange to be matched @return true if this subscription matches the exchange
• org.skyscreamer.jsonassert.Customization.matches()
  Return true if actual value matches expected value using this Customization's comparator. Calls to this method should be replaced by calls to matches(String prefix, Object actual, Object expected, JSONCompareResult result). @param actual JSON value being tested @param expected expected JSON value @return true if actual value matches expected value
• org.springframework.aop.ClassFilter.matches()
  Should the pointcut apply to the given interface or target class? @param clazz the candidate target class @return whether the advice should apply to the given target class
• org.springframework.aop.IntroductionAwareMethodMatcher.matches()
  Perform static checking whether the given method matches. This may be invoked instead of the 2-arg {@link #matches(java.lang.reflect.Method,Class)} methodif the caller supports the extended IntroductionAwareMethodMatcher interface. @param method the candidate method @param targetClass the target class (may be null, in which casethe candidate class must be taken to be the method's declaring class) @param hasIntroductions true if the object on whose behalf we areasking is the subject on one or more introductions; false otherwise @return whether or not this method matches statically
• org.springframework.aop.MethodMatcher.matches()
  Perform static checking whether the given method matches. If this returns false or if the {@link #isRuntime()} methodreturns false, no runtime check (i.e. no. {@link #matches(java.lang.reflect.Method,Class,Object[])} call) will be made. @param method the candidate method @param targetClass the target class (may be null, in which casethe candidate class must be taken to be the method's declaring class) @return whether or not this method matches statically
• org.springframework.aop.aspectj.AspectJExpressionPointcut.matches()
• org.springframework.data.mapping.context.AbstractMappingContext.PersistentPropertyFilter.PropertyMatch.matches()
• org.springframework.security.crypto.password.PasswordEncoder.matches()
  Verify the encoded password obtained from storage matches the submitted raw password after it too is encoded. Returns true if the passwords match, false if they do not. The stored password itself is never decoded. @param rawPassword the raw password to encode and match @param encodedPassword the encoded password from storage to compare with @return true if the raw password, after encoding, matches the encoded password from storage
• org.springframework.security.crypto.password.StandardPasswordEncoder.matches()
• org.springframework.security.web.util.AntPathRequestMatcher.matches()
  Returns true if the configured pattern (and HTTP-Method) match those of the supplied request. @param request the request to match against. The ant pattern will be matched against the{@code servletPath} + {@code pathInfo} of the request.
• org.springframework.security.web.util.RequestMatcher.matches()
  Decides whether the rule implemented by the strategy matches the supplied request. @param request the request to check for a match @return true if the request matches, false otherwise
• org.springframework.security.web.util.matcher.AntPathRequestMatcher.matches()
  Returns true if the configured pattern (and HTTP-Method) match those of the supplied request. @param request the request to match against. The ant pattern will be matched against the{@code servletPath} + {@code pathInfo} of the request.
• org.springframework.security.web.util.matcher.ELRequestMatcher.matches()
• org.springframework.security.web.util.matcher.IpAddressMatcher.matches()
• org.springframework.security.web.util.matcher.MediaTypeRequestMatcher.matches()
• org.springframework.security.web.util.matcher.RegexRequestMatcher.matches()
  Performs the match of the request URL ( {@code servletPath + pathInfo + queryString}) against the compiled pattern. If the query string is present, a question mark will be prepended. @param request the request to match @return true if the pattern matches the URL, false otherwise.
• org.springframework.security.web.util.matcher.RequestMatcher.matches()
  Decides whether the rule implemented by the strategy matches the supplied request. @param request the request to check for a match @return true if the request matches, false otherwise
• org.springframework.web.servlet.handler.MappedInterceptor.matches()
  Returns {@code true} if the interceptor applies to the given request path. @param lookupPath the current request path @param pathMatcher a path matcher for path pattern matching
• org.springframework.web.util.UriTemplate.matches()
  Indicate whether the given URI matches this template. @param uri the URI to match to @return true if it matches; false otherwise
• org.springsource.loaded.AnyTypePattern.matches()
• org.springsource.loaded.ExactTypePattern.matches()
• org.springsource.loaded.PrefixTypePattern.matches()
• org.worldbank.transport.tamt.client.util.Pattern.matches()
  Determines wether the specified regular expression is validated by the provided input. @param regex Regular expression @param input String to validate @return true if matched.
• org.wso2.uri.template.URITemplate.matches()
• org.xhtmlrenderer.css.sheet.MediaRule.matches()
• org.yaml.snakeyaml.nodes.Tag.matches()
  Check whether this tag matches the global tag for the Class @param clazz - Class to check @return true when the this tag can be used as a global tag for the Class
• proguard.util.StringMatcher.matches()
  Checks whether the given string matches. @param string the string to match. @return a boolean indicating whether the string matches the criterion.
• pt.opensoft.text.Regex.matches()
  Aten��o! N�o � thread-safe!!!
• reactor.event.selector.Selector.matches()
  Indicates whether this Selector matches the {@code key}. @param key The key to match @return {@code true} if there's a match, otherwise {@code false}.
• rocket.beans.rebind.aop.MethodMatcher.matches()
  Tests if a method matches the rules for this MethodMatcher @param method @return
• rocket.serialization.rebind.typematcher.TypeMatcher.matches()
• tvbrowser.extras.favoritesplugin.core.ActorSearcher.matches()
• wwutil.model.MaskMatcher.matches()