/*
 * Copyright (C) 2020-2022 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;

/**  A type-specific immutable {@link it.unimi.dsi.fastutil.SortedPair SortedPair}; provides some additional methods that use polymorphism to avoid (un)boxing. */

#if KEYS_PRIMITIVE
public class IMMUTABLE_SORTED_PAIR extends IMMUTABLE_PAIR implements SORTED_PAIR, java.io.Serializable {
#else
public class IMMUTABLE_SORTED_PAIR <K extends Comparable<K>> extends IMMUTABLE_PAIR <K, K> implements it.unimi.dsi.fastutil.SortedPair<K>, java.io.Serializable {
#endif
	private static final long serialVersionUID = 0L;

	private IMMUTABLE_SORTED_PAIR(final KEY_GENERIC_TYPE left, final KEY_GENERIC_TYPE right) {
		super(left, right);
	}

	/** Returns a new type-specific immutable {@link it.unimi.dsi.fastutil.SortedPair SortedPair} with given left and right value. 
	 *
	 * <p>Note that if {@code left} and {@code right} are in the wrong order, they will be exchanged.
	 *
	 * @param left the left value.
	 * @param right the right value.
	 *
	 * @implSpec This factory method delegates to the constructor.
	 */
#if KEYS_PRIMITIVE
	public static IMMUTABLE_SORTED_PAIR of(final KEY_GENERIC_TYPE left, final KEY_GENERIC_TYPE right) {
		if (left <= right) return new IMMUTABLE_SORTED_PAIR(left, right);
		else return new IMMUTABLE_SORTED_PAIR(right, left);
#else
	public static <K extends Comparable<K>> IMMUTABLE_SORTED_PAIR <K> of(final KEY_GENERIC_TYPE left, final KEY_GENERIC_TYPE right) {
		if (left.compareTo(right) <= 0) return new IMMUTABLE_SORTED_PAIR <K>(left, right);
		else return new IMMUTABLE_SORTED_PAIR <K>(right, left);
#endif
	}

	@Override
	@SuppressWarnings("rawtypes")
	public boolean equals(Object other) {
		if (other == null) return false;

#if KEYS_PRIMITIVE || VALUES_PRIMITIVE
		if (other instanceof SORTED_PAIR) {
			return

#if KEY_CLASS_Object
	java.util.Objects.equals(left, ((SORTED_PAIR)other).PAIR_LEFT())
#else
	left == ((SORTED_PAIR)other).PAIR_LEFT()
#endif
#if VALUE_CLASS_Object
	&& java.util.Objects.equals(right, ((SORTED_PAIR)other).PAIR_RIGHT());
#else
	&& right == ((SORTED_PAIR)other).PAIR_RIGHT();
#endif
		}
#endif

		if (other instanceof it.unimi.dsi.fastutil.SortedPair) {
			return
#if KEYS_USE_REFERENCE_EQUALITY
	left == ((it.unimi.dsi.fastutil.SortedPair)other).left()
#else
	java.util.Objects.equals(KEY2OBJ(left), ((it.unimi.dsi.fastutil.SortedPair)other).left())
#endif
#if VALUES_USE_REFERENCE_EQUALITY
	&& right == ((it.unimi.dsi.fastutil.SortedPair)other).right();
#else
	&& java.util.Objects.equals(VALUE2OBJ(right), ((it.unimi.dsi.fastutil.SortedPair)other).right());
#endif
		}

		return false;
	}

	/** Returns a string representation of this sorted pair in the form {<var>l</var>,<var>r</var>}.
	 *
	 * @return a string representation of this pair sorted in the form {<var>l</var>,<var>r</var>}.
	 */
	@Override
	public String toString() {
		return "{" + PAIR_LEFT() + "," + PAIR_RIGHT() + "}";
	}
}