drv.Comparators.drv Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of fastutil Show documentation

fastutil extends the Java Collections Framework by providing type-specific maps, sets, lists and priority queues with a small memory footprint and fast access and insertion; provides also big (64-bit) arrays, sets and lists, and fast, practical I/O classes for binary and text files.

There is a newer version: 8.5.15

Show newest version

/*		 
 * Copyright (C) 2003-2016 Paolo Boldi and Sebastiano Vigna
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */


package PACKAGE;

#if KEYS_REFERENCE
import java.util.Comparator;
#endif

/** A class providing static methods and objects that do useful things with comparators.
 */

public class COMPARATORS {

	private COMPARATORS() {}

	/** A type-specific comparator mimicking the natural order. */
#if KEYS_REFERENCE
	SUPPRESS_WARNINGS_KEY_UNCHECKED_RAWTYPES
	protected static class NaturalImplicitComparator implements Comparator, java.io.Serializable {
#else
	protected static class NaturalImplicitComparator extends KEY_ABSTRACT_COMPARATOR KEY_GENERIC implements java.io.Serializable {
#endif
		private static final long serialVersionUID = 1L;

		public final int compare( final KEY_TYPE a, final KEY_TYPE b ) {
#if KEYS_PRIMITIVE
			return KEY_CMP( a, b );
#else
			return ((Comparable)a).compareTo(b);
#endif
		}
        private Object readResolve() { return NATURAL_COMPARATOR; }
	};
	
	SUPPRESS_WARNINGS_KEY_RAWTYPES
	public static final KEY_COMPARATOR NATURAL_COMPARATOR = new NaturalImplicitComparator();

	/** A type-specific comparator mimicking the opposite of the natural order. */	
#if KEYS_REFERENCE
	SUPPRESS_WARNINGS_KEY_UNCHECKED_RAWTYPES
	protected static class OppositeImplicitComparator implements Comparator, java.io.Serializable {
#else
	protected static class OppositeImplicitComparator extends KEY_ABSTRACT_COMPARATOR KEY_GENERIC implements java.io.Serializable {
#endif
		private static final long serialVersionUID = 1L;

		public final int compare( final KEY_TYPE a, final KEY_TYPE b ) {
#if KEYS_PRIMITIVE
			return - KEY_CMP( a, b );
#else
			return ((Comparable)b).compareTo(a);
#endif
		}
        private Object readResolve() { return OPPOSITE_COMPARATOR; }
	};

	SUPPRESS_WARNINGS_KEY_RAWTYPES
	public static final KEY_COMPARATOR OPPOSITE_COMPARATOR = new OppositeImplicitComparator();
	

#if KEYS_REFERENCE
	protected static class OppositeComparator KEY_GENERIC implements Comparator KEY_GENERIC, java.io.Serializable {
#else
	protected static class OppositeComparator KEY_GENERIC extends KEY_ABSTRACT_COMPARATOR KEY_GENERIC implements java.io.Serializable {
#endif
		private static final long serialVersionUID = 1L;

		private final KEY_COMPARATOR KEY_GENERIC comparator;
		
		protected OppositeComparator( final KEY_COMPARATOR KEY_GENERIC c ) {
			comparator = c;
		}
		
		public final int compare( final KEY_GENERIC_TYPE a, final KEY_GENERIC_TYPE b ) {
			return comparator.compare( b, a );
		}
	};

	/** Returns a comparator representing the opposite order of the given comparator. 
	 *
	 * @param c a comparator.
	 * @return a comparator representing the opposite order of c.
	 */
	public static KEY_GENERIC KEY_COMPARATOR KEY_GENERIC oppositeComparator( final KEY_COMPARATOR KEY_GENERIC c ) {
		return new OppositeComparator KEY_GENERIC ( c );
	}
}