org.camunda.bpm.engine.impl.util.CompareUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of camunda-engine Show documentation
There is a newer version: 7.23.0-alpha2
/*
 * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
 * under one or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership. Camunda licenses this file to you under the Apache License,
 * Version 2.0; 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 org.camunda.bpm.engine.impl.util;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * Util class for comparisons.
 *
 * @author Filip Hrisafov
 */
public class CompareUtil {

  /**
   * Checks if any of the values are not in an ascending order. The check is done based on the {@link Comparable#compareTo(Object)} method.
   *
   * E.g. if we have {@code minPriority = 10}, {@code priority = 13} and {@code maxPriority = 5} and
   * {@code Integer[] values = {minPriority, priority, maxPriority}}. Then a call to {@link CompareUtil#areNotInAscendingOrder(Comparable[] values)}
   * will return {@code true}
   *
   * @param values to validate
   * @param  the type of the comparable
   * @return {@code false} if the not null values are in an ascending order or all the values are null, {@code true} otherwise
   */
  public static > boolean areNotInAscendingOrder(T... values) {
    boolean excluding = false;
    if (values != null) {
      excluding = areNotInAscendingOrder(Arrays.asList(values));
    }
    return excluding;
  }

  /**
   * Checks if any of the values are not in an ascending order. The check is done based on the {@link Comparable#compareTo(Object)} method.
   *
   * E.g. if we have {@code minPriority = 10}, {@code priority = 13} and {@code maxPriority = 5} and
   * {@code List values = {minPriority, priority, maxPriority}}. Then a call to {@link CompareUtil#areNotInAscendingOrder(List values)}
   * will return {@code true}
   *
   * @param values to validate
   * @param  the type of the comparable
   * @return {@code false} if the not null values are in an ascending order or all the values are null, {@code true} otherwise
   */
  public static > boolean areNotInAscendingOrder(List values) {

    int lastNotNull = -1;
    for (int i = 0; i < values.size(); i++) {
      T value = values.get(i);

      if (value != null) {
        if (lastNotNull != -1 && values.get(lastNotNull).compareTo(value) > 0) {
          return true;
        }

        lastNotNull = i;
      }
    }

    return false;
  }

  /**
   * Checks if the element is not contained within the list of values. If the element, or the list are null then true is returned.
   *
   * @param element to check
   * @param values to check in
   * @param  the type of the element
   * @return {@code true} if the element and values are not {@code null} and the values does not contain the element, {@code false} otherwise
   */
  public static  boolean elementIsNotContainedInList(T element, Collection values) {
    if (element != null && values != null) {
      return !values.contains(element);
    }
    else {
      return false;
    }
  }

  /**
   * Checks if the element is contained within the list of values. If the element, or the list are null then true is returned.
   *
   * @param element to check
   * @param values to check in
   * @param  the type of the element
   * @return {@code true} if the element and values are not {@code null} and the values does not contain the element, {@code false} otherwise
   */
  public static  boolean elementIsNotContainedInArray(T element, T... values) {
    if (element != null && values != null) {
      return elementIsNotContainedInList(element, Arrays.asList(values));
    }
    else {
      return false;
    }
  }

  /**
   * Checks if the element is contained within the list of values.
   *
   * @param element to check
   * @param values to check in
   * @param  the type of the element
   * @return {@code true} if the element and values are not {@code null} and the values contain the element,
   *   {@code false} otherwise
   */
  public static  boolean elementIsContainedInList(T element, Collection values) {
    if (element != null && values != null) {
      return values.contains(element);
    }
    else {
      return false;
    }
  }

  /**
   * Checks if the element is contained within the list of values.
   *
   * @param element to check
   * @param values to check in
   * @param  the type of the element
   * @return {@code true} if the element and values are not {@code null} and the values contain the element,
   *   {@code false} otherwise
   */
  public static  boolean elementIsContainedInArray(T element, T... values) {
    if (element != null && values != null) {
      return elementIsContainedInList(element, Arrays.asList(values));
    }
    else {
      return false;
    }
  }

  /**
   * Returns any element if obj1.compareTo(obj2) == 0
   */
  public static > T min(T obj1, T obj2) {
    return obj1.compareTo(obj2) <= 0 ? obj1 : obj2;
  }

  /**
   * Returns any element if obj1.compareTo(obj2) == 0
   */
  public static > T max(T obj1, T obj2) {
    return obj1.compareTo(obj2) >= 0 ? obj1 : obj2;
  }
}