Examples of compare()

• Framework.TextData.compare()
  Compare - compare the given string with this string

  This returns 0 if they are equal, < 0 if the string is less than source and> 0 if the string is > source. If the ignorecase boolean is TRUE, don't pay attention to case sensitivity. This functionality is used to build isGreaterThan etc. @return int - return value @param ignorecase -boolean - true if case is to be ignored. @param source -the string to be compared with this string

• ariba.util.core.ArithmeticOperations.compare()
• ca.coolman.util.Comparator.compare()
  Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second. The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.) The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0. Finally, the implementer must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z. It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals." @param lvalue the first object to be compared. @param rvalue - the second object to be compared. @return a negative integer, zero, or a positive integer as the firstargument is less than, equal to, or greater than the second. @throws ClassCastException - if the arguments' types prevent them frombeing compared by this Comparator.
• ca.coolman.util.StringComparator.compare()
• ch.njol.skript.classes.Comparator.compare()
  Compares the given objects which may not be null. Returning GREATER/SMALLER means that the first parameter is greater/smaller. @param o1 Non-null object @param o2 Non-null object @return the relation of the objects. Should neither return GREATER_OR_EQUAL nor SMALLER_OR_EQUAL.
• client.net.sf.saxon.ce.expr.sort.LocalOrderComparer.compare()
• com.NLP.Tester.Test.compare()
• com.browseengine.bobo.sort.DocComparator.compare()
• com.caucho.quercus.env.ArrayValue.KeyComparator.compare()
• com.caucho.quercus.env.ArrayValue.ValueComparator.compare()
• com.clarkparsia.pellet.datatypes.OWLRealInterval.compare()
• com.clarkparsia.pellet.datatypes.types.real.ContinuousRealInterval.compare()
• com.cloud.network.security.SecurityGroupManagerImpl.CidrComparator.compare()
• com.cloudera.cdk.data.FieldPartitioner.compare()
• com.daveayan.mirage.comparator.Comparator.compare()
• com.deltaxml.core.PipelinedComparator.compare()
• com.dtrules.interpreter.RName.compare()
• com.dtrules.testsupport.ChangeReport.compare()
• com.fasterxml.sort.std.ByteArrayComparator.compare()
• com.foundationdb.ais.util.TableChangeValidator.compare()
• com.foundationdb.server.collation.AkCollator.compare()
  Compare two string values: Comparable
• com.foundationdb.server.types.TComparison.compare()
• com.google.common.collect.ComparisonChain.compare()
  Compares two comparable objects as specified by {@link Comparable#compareTo}, if the result of this comparison chain has not already been determined.
• com.google.dexmaker.Code.compare()
  Compare ints or references. If the comparison is true, execution jumps to {@code trueLabel}. If it is false, execution continues to the next instruction.
• com.googlecode.openbeans.Statement.MethodComparator.compare()
• com.hazelcast.map.MapService.compare()
• com.hazelcast.map.MapServiceContext.compare()
• com.hazelcast.map.impl.MapServiceContext.compare()
• com.hp.hpl.jena.datatypes.xsd.XSDDuration.compare()
• com.ibm.icu.text.Collator.compare()

  Compares the source text String to the target text String according to this Collator's rules, strength and decomposition mode. Returns an integer less than, equal to or greater than zero depending on whether the source String is less than, equal to or greater than the target String. See the Collator class description for an example of use.

  @param source the source String. @param target the target String. @return Returns an integer value. Value is less than zero if source isless than target, value is zero if source and target are equal, value is greater than zero if source is greater than target. @see CollationKey @see #getCollationKey @exception NullPointerException thrown if either arguments is null.IllegalArgumentException thrown if either source or target is not of the class String. @stable ICU 2.8
• com.ibm.icu.text.RuleBasedCollator.compare()
  Compares the source text String to the target text String according to the collation rules, strength and decomposition mode for this RuleBasedCollator. Returns an integer less than, equal to or greater than zero depending on whether the source String is less than, equal to or greater than the target String. See the Collator class description for an example of use.

  General recommendation:
  If comparison are to be done to the same String multiple times, it would be more efficient to generate CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If speed performance is critical and object instantiation is to be reduced, further optimization may be achieved by generating a simpler key of the form RawCollationKey and reusing this RawCollationKey object with the method RuleBasedCollator.getRawCollationKey. Internal byte representation can be directly accessed via RawCollationKey and stored for future use. Like CollationKey, RawCollationKey provides a method RawCollationKey.compareTo for key comparisons. If the each Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better performance.

  @param source the source text String. @param target the target text String. @return Returns an integer value. Value is less than zero if source isless than target, value is zero if source and target are equal, value is greater than zero if source is greater than target. @see CollationKey @see #getCollationKey @stable ICU 2.8
• com.liferay.util.xml.ElementComparator.compare()
• com.mobixess.jodb.core.plugin.IClassProcessor.compare()
• com.mucommander.commons.file.util.FileComparator.compare()
• com.niacin.metaheuristic.FitnessComparator.compare()
• com.niacin.metaheuristic.SimpleFitnessComparator.compare()
• com.opengamma.util.beancompare.BeanCompare.compare()
  Compares two beans of the same class and returns details of any differences. If any of the bean properties* are beans themselves they are compared recursively. @param bean1 the first bean, not null @param bean2 the second bbean of the same type, not null @return the differences between the beans or an empty list if they are identical @throws IllegalArgumentException if the beans' classes are different
• com.orientechnologies.orient.core.db.tool.ODatabaseCompare.compare()
• com.orientechnologies.orient.core.record.impl.ODocumentComparator.compare()
• com.projity.pm.calendar.WorkCalendar.compare()
• com.projity.pm.calendar.WorkingCalendar.compare()
• com.sun.speech.freetts.lexicon.LexiconImpl.compare()
  Tests to see if this lexicon is identical to the other for debugging purposes. @param other the other lexicon to compare to @return true if lexicons are identical
• com.webobjects.foundation.NSComparator.compare()
• convwatch.PRNCompare.compare()
• daveayan.mirage.comparator.Comparator.compare()
• de.danielbechler.diff.ObjectDiffer.compare()
  Recursively inspects the given objects and returns a node representing their differences. Both objects have be have the same type. @param working This object will be treated as the successor of the `base` object. @param base This object will be treated as the predecessor of the working object. @return A node representing the differences between the given objects.
• de.danielbechler.diff.comparison.ComparisonStrategy.compare()
• edu.stanford.bmir.protege.web.server.frame.PropertyValueComparator.compare()
• eu.planets_project.pp.plato.services.characterisation.xcl.XCLComparator.compare()
  evaluates to XCDL files @param tempDir @param inFile @param outFile @return
• eu.planets_project.services.compare.Compare.compare()
  @param first The first of the two digital objects to compare @param second The second of the two digital objects to compare @param config A configuration parameter list @return A list of result properties, the result of comparing the givendigital object, wrapped in a result object
• eu.planets_project.tb.impl.services.wrappers.CompareWrapper.compare()
• gnu.testlet.runner.compare.ReportComparator.compare()
• gov.nasa.jpf.conformanceChecker.comparators.FieldInfoComparator.compare()
• hermes.browser.model.tree.HermesTreeNodeComparator.compare()
• htsjdk.variant.variantcontext.VariantContextComparator.compare()
• hudson.model.DependencyGraph.compare()
  Compare to Projects based on the topological order defined by this Dependency Graph
• infovis.Column.compare()
• java.beans.Statement.MethodComparator.compare()
• java.text.Collator.compare()
  Compares the source string to the target string according to the collation rules for this Collator. Returns an integer less than, equal to or greater than zero depending on whether the source String is less than, equal to or greater than the target string. See the Collator class description for an example of use.

  For a one time comparison, this method has the best performance. If a given String will be involved in multiple comparisons, CollationKey.compareTo has the best performance. See the Collator class description for an example using CollationKeys. @param source the source string. @param target the target string. @return Returns an integer value. Value is less than zero if source is less thantarget, value is zero if source and target are equal, value is greater than zero if source is greater than target. @see java.text.CollationKey @see java.text.Collator#getCollationKey

• java.text.RuleBasedCollator.compare()
  Compares the character data stored in two different strings based on the collation rules. Returns information about whether a string is less than, greater than or equal to another string in a language. This can be overriden in a subclass.
• java.util.Comparator.compare()
  Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

  In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

  The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

  The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

  Finally, the implementor must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

  It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals." @param o1 the first object to be compared. @param o2 the second object to be compared. @return a negative integer, zero, or a positive integer as thefirst argument is less than, equal to, or greater than the second. @throws ClassCastException if the arguments' types prevent them frombeing compared by this comparator.

• javax.xml.datatype.XMLGregorianCalendar.compare()
  3.org/TR/xmlschema-2/#dateTime-order">W3C XML Schema 1.0 Part 2, Section 3.2.7.3, Order relation on dateTime.

  xsd:dateTime datatype field mapping to accessors of this class are defined in date/time field mapping table.

  @param xmlGregorianCalendar Instance of XMLGregorianCalendar to compare @return The relationship between this XMLGregorianCalendar andthe specified xmlGregorianCalendar as {@link DatatypeConstants#LESSER}, {@link DatatypeConstants#EQUAL}, {@link DatatypeConstants#GREATER} or{@link DatatypeConstants#INDETERMINATE}. @throws NullPointerException if xmlGregorianCalendar is null.
• liquibase.diff.ObjectDifferences.compare()
• lupos.datastructures.items.TripleComparator.compare()
• net.sf.robocode.util.AlphanumericComparator.compare()
  Compares two alphanumeric strings. @param str1 the first string to be compared. @param str2 the second string to be compared. @return a negative integer, zero, or a positive integer as the first string is less than, equal to, or greaterthan the second.
• net.sf.saxon.sort.AtomicComparer.compare()
  Compare two AtomicValue objects according to the rules for their data type. UntypedAtomic values are compared as if they were strings; if different semantics are wanted, the conversion must be done by the caller. @param a the first object to be compared. It is intended that this should be an instanceof AtomicValue, though this restriction is not enforced. If it is a StringValue, the collator is used to compare the values, otherwise the value must implement the java.util.Comparable interface. @param b the second object to be compared. This must be comparable with the first object: forexample, if one is a string, they must both be strings. @return <0 if a0 if a>b @throws ClassCastException if the objects are not comparable
• net.sf.saxon.sort.GlobalOrderComparer.compare()
• net.sf.saxon.sort.LocalOrderComparer.compare()
• net.sf.uadetector.internal.util.AlphanumComparator.compare()
• net.yacy.kelondro.order.ByteOrder.compare()
• netscape.ldap.LDAPConnection.compare()
• no.priv.garshol.duke.Processor.compare()
  Compares two records and returns the probability that they represent the same real-world entity.
• no.priv.garshol.duke.comparators.WeightedLevenshtein.compare()
• ns.foundation.NSTimestamp.compare()
• org.acegisecurity.ldap.LdapTemplate.compare()
  Performs an LDAP compare operation of the value of an attribute for a particular directory entry. @param dn the entry who's attribute is to be used @param attributeName the attribute who's value we want to compare @param value the value to be checked against the directory value @return true if the supplied value matches that in the directory
• org.apache.accumulo.core.security.ColumnVisibility.NodeComparator.compare()
• org.apache.ace.client.repository.stateful.impl.LogEventComparator.compare()
• org.apache.axiom.om.impl.llom.util.XMLComparator.compare()
• org.apache.axiom.testutils.stax.XMLStreamReaderComparator.compare()
• org.apache.axis2.XMLComparatorInterop.compare()
• org.apache.axis2.om.impl.llom.util.XMLComparator.compare()
• org.apache.bookkeeper.versioning.Version.compare()
• org.apache.camel.util.ExpressionComparator.compare()
• org.apache.cassandra.db.IClock.compare()
  @param other Compare these two clocks. @return The relationship between the two clocks,lets us know if reconciliation will have to take place.
• org.apache.cassandra.db.composites.CellNameType.compare()
• org.apache.cassandra.db.marshal.AbstractType.compare()
• org.apache.cassandra.db.marshal.TimeUUIDType.compare()
• org.apache.cloudstack.network.contrail.model.VirtualMachineModel.compare()
• org.apache.commons.collections.comparators.NullComparator.compare()
  Perform a comparison between two objects. If both objects are null, a 0 value is returned. If one object is null and the other is not, the result is determined on whether the Comparator was constructed to have nulls as higher or lower than other objects. If neither object is null, an underlying comparator specified in the constructor (or the default) is used to compare the non-null objects. @param o1 the first object to compare @param o2 the object to compare it to. @return -1 if o1 is "lower" than (less than,before, etc.) o2; 1 if o1 is "higher" than (greater than, after, etc.) o2; or 0 if o1 and o2 are equal.
• org.apache.commons.configuration.ConfigurationComparator.compare()
  Compare two configuration objects. @param a the first configuration @param b the second configuration @return true if the two configurations are identical according tothe implemented rules
• org.apache.commons.configuration.StrictConfigurationComparator.compare()
  Compare two configuration objects. @param a the first configuration @param b the second configuration @return true if keys from a are found in b and keys from b arefound in a and for each key in a, the corresponding value is the sale in for the same key in b
• org.apache.commons.configuration2.ConfigurationComparator.compare()
  Compare two configuration objects. @param a the first configuration @param b the second configuration @return true if the two configurations are identical according tothe implemented rules
• org.apache.commons.configuration2.StrictConfigurationComparator.compare()
  Compare two configuration objects. @param a the first configuration @param b the second configuration @return true if keys from a are found in b and keys from b arefound in a and for each key in a, the corresponding value is the sale in for the same key in b
• org.apache.ddlutils.alteration.ModelComparator.compare()
  Compares the two models and returns the changes necessary to create the second model from the first one. @param sourceModel The source model @param targetModel The target model @return The changes
• org.apache.derby.iapi.services.io.FormatableBitSet.compare()
  Bit comparison. Compare this with other. Will always do a byte by byte compare. Given 2 similar bits of unequal lengths (x and y), where x.getLength() < y.getLength() but where: x[0..x.getLength()] == y[0..x.getLength()] then x < y. @param other the other bit to compare to @return -1 - if other < this0 - if other== this 1 - if other> this
• org.apache.derby.iapi.types.DataValueDescriptor.compare()
  Compare this Orderable with a given Orderable for the purpose of index positioning. This method treats nulls as ordered values - that is, it treats SQL null as equal to null and greater than all other values. @param other The Orderable to compare this one to. @return <0 - this Orderable is less than other.0 - this Orderable equals other.>0 - this Orderable is greater than other. The code should not explicitly look for -1, or 1. @exception StandardException Thrown on error
• org.apache.derby.iapi.types.SQLLongint.compare()
• org.apache.directory.ldap.client.api.LdapConnection.compare()
  Compares whether a given attribute's value matches that of the existing value of the attribute present in the entry with the given Dn. @param dn the target entry's String Dn @param attributeName the attribute's name @param value a String value with which the target entry's attribute value to be compared with @return compare operation's response @throws LdapException if some error occurred
• org.apache.directory.ldap.client.api.LdapNetworkConnection.compare()
  {@inheritDoc}
• org.apache.directory.mavibot.btree.RevisionNameComparator.compare()
  {@inheritDoc}
• org.apache.directory.mavibot.btree.comparator.BooleanArrayComparator.compare()
  Compare two boolean arrays. @param booleanArray1 First boolean array @param booleanArray2 Second boolean array @return 1 if booleanArray1 > booleanArray2, 0 if booleanArray1 == booleanArray2, -1 if booleanArray1 < booleanArray2
• org.apache.directory.mavibot.btree.comparator.BooleanComparator.compare()
  Compare two booleans. @param boolean1 First boolean @param boolean2 Second boolean @return 1 if boolean1 > boolean2, 0 if boolean1 == boolean2, -1 if boolean1 < boolean2
• org.apache.directory.mavibot.btree.comparator.ByteArrayComparator.compare()
  Compare two byte arrays. @param byteArray1 First byteArray @param byteArray2 Second byteArray @return 1 if byteArray1 > byteArray2, 0 if byteArray1 == byteArray2, -1 if byteArray1 < byteArray2
• org.apache.directory.mavibot.btree.comparator.ByteComparator.compare()
  Compare two bytes. @param byte1 First byte @param byte2 Second byte @return 1 if byte1 > byte2, 0 if byte1 == byte2, -1 if byte1 < byte2
• org.apache.directory.mavibot.btree.comparator.CharArrayComparator.compare()
  Compare two char arrays. @param charArray1 First char array @param charArray2 Second char array @return 1 if charArray1 > charArray2, 0 if charArray1 == charArray2, -1 if charArray1 < charArray2
• org.apache.directory.mavibot.btree.comparator.CharComparator.compare()
  Compare two chars. @param char1 First char @param char2 Second char @return 1 if char1 > char2, 0 if char1 == char2, -1 if char1 < char2
• org.apache.directory.mavibot.btree.comparator.IntArrayComparator.compare()
  Compare two long arrays. @param intArray1 First int array @param intArray2 Second int array @return 1 if intArray1 > intArray2, 0 if intArray1 == intArray2, -1 if intArray1 < intArray2
• org.apache.directory.mavibot.btree.comparator.IntComparator.compare()
  Compare two integers. @param integer1 First integer @param integer2 Second integer @return 1 if integer1 > integer2, 0 if integer1 == integer2, -1 if integer1 < integer2
• org.apache.directory.mavibot.btree.comparator.LongArrayComparator.compare()
  Compare two long arrays. @param longArray1 First long array @param longArray2 Second long array @return 1 if longArray1 > longArray2, 0 if longArray1 == longArray2, -1 if longArray1 < longArray2
• org.apache.directory.mavibot.btree.comparator.LongComparator.compare()
  Compare two longs. @param long1 First long @param long2 Second long @return 1 if long1 > long2, 0 if long1 == long2, -1 if long1 < long2
• org.apache.directory.mavibot.btree.comparator.ShortArrayComparator.compare()
  Compare two short arrays. @param shortArray1 First short array @param shortArray2 Second short array @return 1 if shortArray1 > shortArray2, 0 if shortArray1 == shortArray2, -1 if shortArray1 < shortArray2
• org.apache.directory.mavibot.btree.comparator.ShortComparator.compare()
  Compare two shorts. @param short1 First short @param short2 Second short @return 1 if short1 > short2, 0 if short1 == short2, -1 if short1 < short2
• org.apache.directory.mavibot.btree.comparator.StringComparator.compare()
  Compare two Strings. @param string1 First String @param string2 Second String @return 1 if string1 > String2, 0 if string1 == String2, -1 if string1 < String2
• org.apache.directory.server.core.CoreSession.compare()
  Checks to see if an attribute in an entry contains a value. @param dn the distinguished name of the entry to check @param oid the OID of the attribute to check for the value @param value the value to check for @throws Exception if there are failures while comparing
• org.apache.directory.server.core.OperationManager.compare()
  TODO document after determining if this method should be here.
• org.apache.directory.server.core.api.CoreSession.compare()
  Checks to see if an attribute in an entry contains a value. @param dn the distinguished name of the entry to check @param oid the OID of the attribute to check for the value @param value the value to check for @throws Exception if there are failures while comparing
• org.apache.directory.server.core.api.OperationManager.compare()
  TODO document after determining if this method should be here.
• org.apache.directory.server.core.api.interceptor.Interceptor.compare()
  Filters {@link DefaultPartitionNexus#compare(CompareOperationContext)} call.
• org.apache.directory.server.core.interceptor.InterceptorChain.compare()
• org.apache.directory.server.core.jndi.ServerLdapContext.compare()
  Explicitly exposes an LDAP compare operation which JNDI does not directly provide. All normalization and schema checking etcetera is handled by this call. @param name the name of the entri @param oid the name or object identifier for the attribute to compare @param value the value to compare the attribute to @return true if the entry has the value for the attribute, false otherwise @throws NamingException if the backing store cannot be accessed, orpermission is not allowed for this operation or the oid is not recognized, or the attribute is not present in the entry ... you get the picture.
• org.apache.fop.layoutmgr.Keep.compare()
  Compare this Keep instance to another one, and return the stronger one if the context is the same @param other the instance to compare to @return the winning Keep instance
• org.apache.hadoop.cli.util.ComparatorBase.compare()
  Compare method for the comparator class. @param actual output. can be null @param expected output. can be null @return true if expected output compares with the actual output, elsereturn false. If actual or expected is null, return false
• org.apache.hadoop.hbase.KeyValue.KVComparator.compare()
• org.apache.hadoop.hbase.KeyValue.KeyComparator.compare()
• org.apache.hadoop.hbase.KeyValue.MetaComparator.compare()
• org.apache.hadoop.hbase.master.CatalogJanitor.SplitParentFirstComparator.compare()
• org.apache.hadoop.hbase.util.Bytes.ByteArrayComparator.compare()
• org.apache.hadoop.io.BytesWritable.Comparator.compare()
• org.apache.hadoop.io.RawComparator.compare()
• org.apache.hadoop.io.WritableComparator.compare()
  Optimization hook. Override this to make SequenceFile.Sorter's scream.

  The default implementation reads the data into two {@link WritableComparable}s (using {@link Writable#readFields(DataInput)}, then calls {@link #compare(WritableComparable,WritableComparable)}.

• org.apache.hadoop.mapred.lib.KeyFieldBasedComparator.compare()
• org.apache.hadoop.util.DataChecksum.compare()
  Compares the checksum located at buf[offset] with the current checksum. @return true if the checksum matches and false otherwise.
• org.apache.http.cookie.CookieIdentityComparator.compare()
• org.apache.ivy.plugins.version.VersionMatcher.compare()
  Compares a dynamic revision (askedMrid) with a static one (foundMrid) to indicate which one should be considered the greater. If there is not enough information to know which one is the greater, the dynamic one should be considered greater and this method should return 0. This method should never be called with a askdeMrid for which isDynamic returns false. @param askedMrid the dynamic revision to compare @param foundMrid the static revision to compare @param staticComparator a comparator which can be used to compare static revisions @return 0 if it's not possible to know which one is greater, greater than 0 if askedMrid should be considered greater, lower than 0 if it can't be consider greater
• org.apache.jackrabbit.mongomk.Revision.RevisionComparator.compare()
• org.apache.jackrabbit.oak.plugins.document.Revision.RevisionComparator.compare()
• org.apache.jackrabbit.oak.plugins.mongomk.Revision.RevisionComparator.compare()
• org.apache.jackrabbit.vault.util.PathComparator.compare()
  {@inheritDoc}Compared to the {@link String#compareTo(String)} it handles the '/'differently giving it the highest priority so that: "/a" < "/b" "/a1foo" < "/a/foo"
• org.apache.juddi.v3.client.compare.TModelInstanceDetailsComparator.compare()
  Compares two non-null instances of TModelInstanceDetails by only comparing the field designated from the constructor. It will also cast or parse TModelInstanceDetails[i].InstanceDetails[k].InstanceParms to the selected data type double, XMLGregorgian or Duration, using that as a basis for comparison. If a parsing error occurs, an exception will be thrown. @param lhs @param rhs @return less than 0 if lhs < rhs, greater than 0 if lhs > rhs. @throws IllegalArgumentException if the tModel key to search for ismissing, if either sides are null @throws ArrayIndexOutOfBoundsException if the values were found but couldnot be compared
• org.apache.ldap.server.jndi.ServerLdapContext.compare()
  Explicitly exposes an LDAP compare operation which JNDI does not directly provide. All normalization and schema checking etcetera is handled by this call. @param name the name of the entri @param oid the name or object identifier for the attribute to compare @param value the value to compare the attribute to @return true if the entry has the value for the attribute, false otherwise @throws NamingException if the backing store cannot be accessed, orpermission is not allowed for this operation or the oid is not recognized, or the attribute is not present in the entry ... you get the picture.
• org.apache.lucene.search.FieldComparator.compare()
  Compare hit at slot1 with hit at slot2. @param slot1 first slot to compare @param slot2 second slot to compare @return any N < 0 if slot2's value is sorted afterslot1, any N> 0 if the slot2's value is sorted before slot1 and 0 if they are equal
• org.apache.nutch.crawl.UrlWithScore.UrlScoreComparator.compare()
• org.apache.sis.test.XMLComparator.compare()
  Compares the XML document specified at construction time. Before to invoke this method, users may consider to add some values to the {@link #ignoredAttributes}set.
• org.apache.solr.request.compare.MergerDetailSelectDetailRowCompare.compare()
• org.apache.solr.request.compare.MergerGroupByGroupbyRowCompare.compare()
• org.apache.tajo.storage.TupleComparator.compare()
• org.apache.uima.cas.FSIndex.compare()
  Compare two feature structures according to the ordering relation of the index. If the input feature structures are not of the type of the index, the result is undefined. @param fs1 the first Feature Structure to compare @param fs2 the second Feature Structure to compare @return -1 if fs1 < fs2; 0 iffs1 = fs2; 1 else.
• org.apache.ws.commons.om.impl.llom.util.XMLComparator.compare()
• org.apache.xerces.impl.dv.xs.TypeValidator.compare()
• org.apache.xerces.validators.datatype.DatatypeValidator.compare()
  Compares content in the Domain value vs. lexical value. e.g. If type is a float then 1.0 may be equivalent to 1 even tough both are lexically different. @param value1 @param valu2 @return
• org.apache.xml.security.c14n.helper.AttrCompare.compare()
  Compares two attributes based on the C14n specification.

  • Namespace nodes have a lesser document order position than attribute nodes.
  • An element's namespace nodes are sorted lexicographically by local name (the default namespace node, if one exists, has no local name and is therefore lexicographically least).
  • An element's attribute nodes are sorted lexicographically with namespace URI as the primary key and local name as the secondary key (an empty namespace URI is lexicographically least).

  @param obj0 casted Attr @param obj1 casted Attr @return returns a negative integer, zero, or a positive integer as obj0 is less than, equal to, or greater than obj1
• org.araneaframework.backend.list.memorybased.ComparatorExpression.compare()
  Returns a negative integer, zero, or a positive integer as the first Variable is less than, equal to, or greater than the second. @param resolver1 Resolver that is used to evalute the first Variable. @param resolver2 Resolver that is used to evalute the second Variable. @return a negative integer, zero, or a positive integer as the firstVariable is less than, equal to, or greater than the second. @throws ExpressionEvaluationException when the comparation fails.
• org.aspectj.weaver.patterns.DeclarePrecedence.compare()
• org.blync.client.calendar.Day.compare()
• org.castor.xmlctf.xmldiff.XMLDiff.compare()
  Compares the two XML documents located at the given URL locations. Returns 0, if no differences are found, otherwise returns a positive number indicating the number of differences.

  This is the only public method in this class. @return 0, if no differences are found, otherwise a positive numberindicating the number of differences. @throws java.io.IOException an this occurs while reading

• org.chaidb.db.log.Lsn.compare()
  This method allows the caller to compare two Lsn objects, returning 0 if they are equal, 1 if lsn0 is less than this, and -1 if lsn0 is greater than this.
• org.cishell.testing.convertertester.core.tester2.graphcomparison.NewGraphComparer.compare()
• org.cmc.music.util.FileComparator.compare()
• org.databene.mad4db.compare.SchemaComparator.compare()
• org.dbunit.dataset.datatype.DataType.compare()
  Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

  The two values are typecast to this DataType before being compared. @throws TypeCastException if the arguments' types prevent them frombeing compared by this Comparator.

• org.dom4j.util.NodeComparator.compare()
• org.drools.planner.benchmark.core.ranking.SingleBenchmarkRankingComparator.compare()
• org.drools.spi.ConflictResolver.compare()
• org.dyno.visual.swing.types.editor.spinnermodels.SpinnerModelType.compare()
• org.eclipse.jface.viewers.ViewerSorter.compare()
• org.encog.ml.ea.sort.MaximizeAdjustedScoreComp.compare()
  {@inheritDoc}
• org.encog.ml.ea.sort.MaximizeScoreComp.compare()
  {@inheritDoc}
• org.encog.ml.ea.sort.MinimizeAdjustedScoreComp.compare()
  {@inheritDoc}
• org.encog.ml.ea.sort.MinimizeScoreComp.compare()
  {@inheritDoc}
• org.exoplatform.services.document.diff.DiffService.compare()
  Compares the two input sequences. @param orig The original sequence. @param rev The revised sequence. @return true if the sequences are identical. False otherwise.
• org.exoplatform.services.document.impl.diff.DiffServiceImpl.compare()
  Compares the two input sequences. @param orig The original sequence. @param rev The revised sequence. @return true if the sequences are identical. False otherwise.
• org.exoplatform.services.jcr.impl.core.nodetype.registration.NodeDefinitionComparator.compare()
• org.exoplatform.services.jcr.impl.core.nodetype.registration.PropertyDefinitionComparator.compare()
• org.fenixedu.academic.dto.comparators.CalendarDateComparator.compare()
• org.geotools.feature.FeatureComparators.Name.compare()
• org.geotools.gce.grassraster.core.color.ColorRule.compare()
• org.gitective.core.stat.EarliestComparator.compare()
• org.gitective.core.stat.LatestComparator.compare()
• org.gradle.api.plugins.buildcomparison.gradle.internal.GradleBuildComparison.compare()
• org.h2.engine.Database.compare()
  Compare two values with the current comparison mode. The values may not be of the same type. @param a the first value @param b the second value @return 0 if both values are equal, -1 if the first value is smaller, and1 otherwise
• org.h2.result.SortOrder.compare()
  Compare two expression lists. @param a the first expression list @param b the second expression list @return the result of the comparison
• org.hsqldb.types.Type.compare()
• org.iq80.leveldb.table.UserComparator.compare()
• org.jboss.aesh.comparators.PosixFileNameComparator.compare()
• org.jboss.classloading.spi.version.VersionComparatorRegistry.compare()
  Compare two version impls. @param < T> the first version type @param < U> the second version type @param t the first version @param u the second version @return the compare result
• org.jboss.ejb3.packagemanager.PackageVersionComparator.compare()
  @see java.util.Comparator#compare(java.lang.Object,java.lang.Object)
• org.jboss.metatype.api.values.SimpleValueComparator.compare()
• org.jfree.formula.typing.ExtendedComparator.compare()
  Returns null, if the types are not comparable and are not convertible at all. @param type1 @param value1 @param type2 @param value2 @return
• org.jibx.extras.DocumentComparator.compare()
  Compares a pair of documents by reading them in parallel from a pair of parsers. The comparison ignores differences in whitespace separating elements, but treats whitespace as significant within elements with only character data content. @param rdra reader for first document to be compared @param rdrb reader for second document to be compared @return true if the documents are the same,false if they're different
• org.joda.time.DateTimeComparator.compare()
  Compare two objects against only the range of date time fields as specified in the constructor. @param lhsObj the first object,logically on the left of a < comparison, null means now @param rhsObj the second object,logically on the right of a < comparison, null means now @return zero if order does not matter,negative value if lhsObj < rhsObj, positive value otherwise. @throws IllegalArgumentException if either argument is not supported
• org.jruby.RubyArray.compare()
• org.jruby.RubyHash.compare()
• org.lealone.engine.Database.compare()
  Compare two values with the current comparison mode. The values may not be of the same type. @param a the first value @param b the second value @return 0 if both values are equal, -1 if the first value is smaller, and1 otherwise
• org.lealone.result.SortOrder.compare()
  Compare two expression lists. @param a the first expression list @param b the second expression list @return the result of the comparison
• org.ocpsoft.prettytime.units.TimeUnitComparator.compare()
• org.olat.core.commons.modules.bc.meta.MetaTitleComparator.compare()
• org.openbravo.erpCommon.modules.VersionUtility.VersionComparator.compare()
• org.openpixi.pixi.physics.util.ParticleComparator.compare()
• org.openpixi.pixi.physics.util.ResultsComparator.compare()
• org.openstreetmap.josm.data.osm.NodePositionComparator.compare()
• org.openstreetmap.osmosis.core.sort.v0_6.EntityContainerComparator.compare()
  {@inheritDoc}
• org.optaplanner.benchmark.impl.ranking.SingleBenchmarkRankingComparator.compare()
• org.pdf4j.saxon.sort.GlobalOrderComparer.compare()
• org.pdf4j.saxon.sort.LocalOrderComparer.compare()
• org.pentaho.platform.engine.services.solution.SolutionCompare.compare()
• org.pentaho.reporting.libraries.formula.typing.ExtendedComparator.compare()
  Returns null, if the types are not comparable and are not convertible at all. @param type1 @param value1 @param type2 @param value2 @return
• org.pomizer.comparator.RawClassInfoComparator.compare()
• org.python.pydev.parser.visitors.comparator.SimpleNodeComparator.compare()
• org.rhq.core.domain.drift.DriftDefinitionComparator.compare()
• org.rhq.core.domain.util.OSGiVersionComparator.compare()
• org.richfaces.model.impl.expressive.WrappedBeanComparator2.compare()
• org.rococoa.cocoa.foundation.NSNumber.compare()
• org.springframework.beans.support.PropertyComparator.compare()
• org.springframework.expression.TypeComparator.compare()
  Compare two objects. @param firstObject the first object @param secondObject the second object @return 0 if they are equal, <0 if the first is smaller than the second, or>0 if the first is larger than thesecond @throws EvaluationException if a problem occurs during comparison (or they are not comparable)
• org.springframework.expression.spel.support.StandardTypeComparator.compare()
• org.springframework.ide.eclipse.quickfix.processors.NameSuggestionComparator.compare()
• org.springframework.security.ldap.SpringSecurityLdapTemplate.compare()
  Performs an LDAP compare operation of the value of an attribute for a particular directory entry. @param dn the entry who's attribute is to be used @param attributeName the attribute who's value we want to compare @param value the value to be checked against the directory value @return true if the supplied value matches that in the directory
• org.syncany.database.FileVersionComparator.compare()
  Compares two {@link FileVersion}s to each other and returns a {@link FileVersionComparison} object. @param expectedFileVersion The expected file version (that is compared to the actual file version) @param actualFileVersion The actual file version (that is compared to the expected file version) @return Returns a file version comparison object, indicating if there are differences between the file versions
• org.terrier.structures.indexing.singlepass.hadoop.SplitEmittedTerm.SETRawComparatorTerm.compare()
• org.terrier.structures.indexing.singlepass.hadoop.SplitEmittedTerm.SETRawComparatorTermSplitFlush.compare()
• org.tmatesoft.hg.internal.RepositoryComparator.compare()
• org.vietspider.html.renderer.NodeComparator.compare()
• org.wicketstuff.jamon.web.PropertyModelObjectComparator.compare()
• org.xmlBlaster.engine.runlevel.PluginConfigComparator.compare()
  Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second. Null objects are considered of different type and therefore will throw a runtime exception (ClassCastException).
• org.xwiki.test.ui.po.HistoryPane.compare()
• org.zkoss.ztl.util.image.Comparator.compare()
  Return whether the two images are the same. If null, the images are the same, otherwise, the returned image is the change indicator. @param b1 the source of the base image @param b2 the compared image.
• sun.security.util.ByteArrayLexOrder.compare()
  Perform lexicographical comparison of two byte arrays, regarding each byte as unsigned. That is, compare array entries in order until they differ--the array with the smaller entry is "smaller". If array entries are equal till one array ends, then the longer array is "bigger". @param bytes1 first byte array to compare. @param bytes2 second byte array to compare. @return negative number if bytes1 < bytes2, 0 if bytes1== bytes2,positive number if bytes1> bytes2. @exception ClassCastExceptionif either argument is not a byte array.
• test.interop.util.XMLComparatorInterop.compare()
• ucar.nc2.util.CompareNetcdf2.compare()
• voldemort.versioning.VectorClock.compare()
• voldemort.versioning.Version.compare()
  Return whether or not the given version preceeded this one, succeeded it, or is concurrant with it @param v The other version
• xbird.xquery.expr.flwr.OrderSpec.compare()
• xdoclet.retest.util.ClassComparator.compare()
• xdoclet.retest.util.InterfaceComparator.compare()
• xdoclet.retest.util.XMLComparator.compare()
  Start the comparison @return a xdoclet.retest.utilComparisonResultSet containingpotential differences.

Examples of voldemort.versioning.Version.compare()

Examples of xbird.xquery.expr.flwr.OrderSpec.compare()

Examples of xdoclet.retest.util.ClassComparator.compare()

Examples of xdoclet.retest.util.InterfaceComparator.compare()

Examples of xdoclet.retest.util.XMLComparator.compare()