IndexGeneratorHelper.java

  1. /*
  2.  * The coLAB project
  3.  * Copyright (C) 2021-2023 AlbaSim, MEI, HEIG-VD, HES-SO
  4.  *
  5.  * Licensed under the MIT License
  6.  */
  7. package ch.colabproject.colab.api.controller.document;

  9. import ch.colabproject.colab.api.model.WithIndex;
  10. import ch.colabproject.colab.generator.model.exceptions.HttpErrorMessage;
  11. import ch.colabproject.colab.generator.model.exceptions.MessageI18nKey;
  12. import java.util.ArrayList;
  13. import java.util.Collection;
  14. import java.util.Comparator;
  15. import java.util.List;
  16. import javax.ejb.LocalBean;
  17. import javax.ejb.Stateless;

  19. /**
  20.  * Deal with assigning index in a collection. The index is a field of the object and not the
  21.  * built-in index of a list.
  22.  * <p>
  23.  * The indexes are progressive (from small to big) but the size of the room between two neighboring
  24.  * indexes is not minimal nor has to be regular. In other words two neighboring indexes do not need
  25.  * to be two just-following numbers.
  26.  * <p>
  27.  * The purpose is to be able to easily add an object between others without having to adjust other
  28.  * indexes. In order to do that, we set a room between two neighboring indexes.
  29.  *
  30.  * @author sandra
  31.  * @author maxence
  32.  *
  33.  * @param <T> Type of the items
  34.  */
  35. @Stateless
  36. @LocalBean
  37. public class IndexGeneratorHelper<T extends WithIndex> {

  39.     /**
  40.      * The default value of the smallest index that is suitable
  41.      */
  42.     private final int DEFAULT_MIN_INDEX = 0;

  44.     /**
  45.      * The default value of the biggest index that is suitable
  46.      */
  47.     private final int DEFAULT_MAX_INDEX = Integer.MAX_VALUE;

  49.     /**
  50.      * Default room between two neighboring indexes
  51.      */
  52.     private final int DEFAULT_INDEX_INC = 1000;

  54.     /**
  55.      * Value of the smallest index that is suitable
  56.      */
  57.     private final int minIndex;

  59.     /**
  60.      * Value of the biggest index that is suitable
  61.      */
  62.     private final int maxIndex;

  64.     /**
  65.      * Initial room between two neighboring indexes
  66.      */
  67.     private final int indexIncrement;

  69.     /**
  70.      * Index for the first item in the list
  71.      */
  72.     private final int soloIndex;

  74.     /**
  75.      * Default constructor
  76.      */
  77.     public IndexGeneratorHelper() {
  78.         minIndex = DEFAULT_MIN_INDEX;
  79.         maxIndex = DEFAULT_MAX_INDEX;
  80.         indexIncrement = DEFAULT_INDEX_INC;

  82.         soloIndex = minIndex + indexIncrement;
  83.     }

  85.     /**
  86.      * Constructor with parameters
  87.      *
  88.      * @param minIndex       The value of the smallest index that is suitable
  89.      * @param maxIndex       The value of the biggest index that is suitable
  90.      * @param indexIncrement The initial room between two neighboring indexes
  91.      */
  92.     public IndexGeneratorHelper(int minIndex, int maxIndex, int indexIncrement) {
  93.         this.minIndex = minIndex;
  94.         this.maxIndex = maxIndex;
  95.         this.indexIncrement = indexIncrement;

  97.         soloIndex = minIndex + indexIncrement;
  98.     }

  100.     // *********************************************************************************************
  101.     //
  102.     // *********************************************************************************************

  104.     /**
  105.      * Move (or set) the given item at the beginning of the collection.
  106.      * <p>
  107.      * That means setting an index to the item so that it is the first when sorting by index.
  108.      *
  109.      * @param item       the item waiting for an index to be set
  110.      * @param collection the collection of items
  111.      *
  112.      * @throws HttpErrorMessage if the collection is too big
  113.      */
  114.     public void moveItemToBeginning(T item, Collection<T> collection) {
  115.         if (collection.isEmpty()) {
  116.             item.setIndex(soloIndex);
  117.         } else {
  118.             List<T> sortedList = sortCollection(collection);

  120.             T baseItem = sortedList.get(0);

  122.             int justTooLow = minIndex - 1;

  124.             if (!hasEnoughSpaceBetween(justTooLow, baseItem.getIndex())) {
  125.                 reorderIndexes(sortedList);
  126.             }

  128.             int wantedIndex = computeInBetweenIndex(justTooLow, baseItem.getIndex());

  130.             item.setIndex(wantedIndex);
  131.         }
  132.     }

  134.     /**
  135.      * Move the given item one step ahead from where it is now.
  136.      *
  137.      * @param item       the item waiting for a new index
  138.      * @param collection the collection of items
  139.      *
  140.      * @throws HttpErrorMessage if the item is not in the collection
  141.      */
  142.     public void moveOneStepAhead(T item, Collection<T> collection) {
  143.         if (!collection.contains(item)) {
  144.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  145.         }

  147.         List<T> sortedList = sortCollection(collection);

  149.         T item1 = getItemBefore(item, sortedList);

  151.         if (item1 == null) {
  152.             // already at the beginning
  153.             return;
  154.         }

  156.         int itemIndex = item.getIndex();
  157.         item.setIndex(item1.getIndex());
  158.         item1.setIndex(itemIndex);
  159.     }

  161.     /**
  162.      * Move (or set) the given item before the baseItem.
  163.      *
  164.      * @param item       the item waiting for a new index
  165.      * @param baseItem   the item of reference
  166.      * @param collection the collection of items
  167.      *
  168.      * @throws HttpErrorMessage if the baseItem is not in the collection or if the collection is too
  169.      *                          big
  170.      */
  171.     public void moveItemBefore(T item, T baseItem, Collection<T> collection) {
  172.         if (!collection.contains(baseItem)) {
  173.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  174.         }

  176.         List<T> sortedList = sortCollection(collection);

  178.         T item1 = baseItem;
  179.         T item2 = getItemBefore(baseItem, sortedList);

  181.         if (item2 == null) {
  182.             // set before item1 which is the first item
  183.             moveItemToBeginning(item, collection);

  185.         } else {
  186.             // between two items
  187.             if (!hasEnoughSpaceBetween(item1.getIndex(), item2.getIndex())) {
  188.                 reorderIndexes(sortedList);
  189.             }

  191.             int wantedIndex = computeInBetweenIndex(item1.getIndex(), item2.getIndex());

  193.             item.setIndex(wantedIndex);
  194.         }
  195.     }

  197.     /**
  198.      * Move an item one step behind from where it is now.
  199.      *
  200.      * @param item       the item waiting for a new index
  201.      * @param collection the collection of items
  202.      *
  203.      * @throws HttpErrorMessage if the item is not in the collection
  204.      */
  205.     public void moveOneStepBehind(T item, Collection<T> collection) {
  206.         if (!collection.contains(item)) {
  207.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  208.         }

  210.         List<T> sortedList = sortCollection(collection);

  212.         T item1 = getItemAfter(item, sortedList);

  214.         if (item1 == null) {
  215.             // already at the end
  216.             return;
  217.         }

  219.         int itemIndex = item.getIndex();
  220.         item.setIndex(item1.getIndex());
  221.         item1.setIndex(itemIndex);
  222.     }

  224.     /**
  225.      * Move (or set) the given item after the baseItem.
  226.      *
  227.      * @param item       the item waiting for a new index
  228.      * @param baseItem   the item of reference
  229.      * @param collection the collection of items
  230.      *
  231.      * @throws HttpErrorMessage if the baseItem is not in the collection or if the collection is too
  232.      *                          big
  233.      */
  234.     public void moveItemAfter(T item, T baseItem, Collection<T> collection) {
  235.         if (!collection.contains(baseItem)) {
  236.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  237.         }

  239.         List<T> sortedList = sortCollection(collection);

  241.         T item1 = baseItem;
  242.         T item2 = getItemAfter(baseItem, sortedList);

  244.         if (item2 == null) {
  245.             // set after item1 which is the last item
  246.             moveItemToEnd(item, collection);

  248.         } else {
  249.             if (!hasEnoughSpaceBetween(item1.getIndex(), item2.getIndex())) {
  250.                 reorderIndexes(sortedList);
  251.             }

  253.             int wantedIndex = computeInBetweenIndex(item1.getIndex(), item2.getIndex());

  255.             item.setIndex(wantedIndex);
  256.         }
  257.     }

  259.     /**
  260.      * Move (or set) the given item at the end of the collection.
  261.      * <p>
  262.      * That means setting an index to the item so that it is the last when sorting by index.
  263.      *
  264.      * @param item       the item waiting for an index to be set
  265.      * @param collection the collection of items
  266.      *
  267.      * @throws HttpErrorMessage if the collection is too big
  268.      */
  269.     public void moveItemToEnd(T item, Collection<T> collection) {
  270.         if (collection.isEmpty()) {
  271.             item.setIndex(soloIndex);
  272.         } else {
  273.             List<T> sortedList = sortCollection(collection);

  275.             T baseItem = sortedList.get(sortedList.size() - 1);

  277.             int justTooBigIndex = maxIndex + 1;

  279.             if (!hasEnoughSpaceBetween(baseItem.getIndex(), justTooBigIndex)) {
  280.                 reorderIndexes(sortedList);
  281.             }

  283.             int wantedIndex;
  284.             if ((justTooBigIndex - baseItem.getIndex()) > indexIncrement) {
  285.                 wantedIndex = baseItem.getIndex() + indexIncrement;
  286.             } else {
  287.                 wantedIndex = computeInBetweenIndex(baseItem.getIndex(), justTooBigIndex);
  288.             }

  290.             item.setIndex(wantedIndex);
  291.         }
  292.     }

  294.     // *********************************************************************************************
  295.     //
  296.     // *********************************************************************************************

  298.     /**
  299.      * Reorder the list so that each neighboring items have items separated by
  300.      * {@link #indexIncrement}.
  301.      * <p>
  302.      * The first item also has a room of {@link #indexIncrement} before it.
  303.      *
  304.      * @param sortedCollection The sorted collection to index again
  305.      *
  306.      * @throws HttpErrorMessage if the collection is too big to be reorder
  307.      */
  308.     private void reorderIndexes(List<T> sortedCollection) {
  309.         if (!canBeReordered(sortedCollection)) {
  310.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  311.         }

  313.         int index = minIndex + indexIncrement;

  315.         for (WithIndex obj : sortedCollection) {
  316.             obj.setIndex(index);
  317.             index += indexIncrement;
  318.         }
  319.     }

  321.     /**
  322.      * Compute if the collection size fits into items indexes separated by {@link #indexIncrement}
  323.      * between {@link #minIndex} and {@link #maxIndex}
  324.      *
  325.      * @param collection
  326.      *
  327.      * @return True if the collection size fits into
  328.      */
  329.     private boolean canBeReordered(Collection<T> collection) {
  330.         return Math.floor(((float) (maxIndex - minIndex)) / indexIncrement) - 1 >= collection
  331.             .size();
  332.     }

  334.     // *********************************************************************************************
  335.     //
  336.     // *********************************************************************************************

  338.     /**
  339.      * Sort the collection by the items index field.
  340.      *
  341.      * @param collection the collection of items to sort
  342.      *
  343.      * @return a list of sorted items by index
  344.      */
  345.     private List<T> sortCollection(Collection<T> collection) {
  346.         List<T> sortedList = new ArrayList<>(collection);

  348.         sortedList.sort(Comparator.comparingInt(obj -> obj.getIndex()));

  350.         // TODO sandra ask Maxence if the old way was more suitable
  351. //      sortedList.sort((a, b) -> {
  352. //      if (a != null) {
  353. //          if (b != null) {
  354. //              return Math.max(a.getIndex(), b.getIndex());
  355. //          } else {
  356. //              // a is not null, b is null
  357. //              return -1;
  358. //          }
  359. //      } else if (b != null) {
  360. //          // a is null, not b
  361. //          return 1;
  362. //      }
  363. //      //both are null
  364. //      return 0;

  366.         return sortedList;
  367.     }

  369.     // *********************************************************************************************
  370.     //
  371.     // *********************************************************************************************

  373.     /**
  374.      * Determine if there is enough space between two indexes so that we can insert something new.
  375.      *
  376.      * @param indexA an index
  377.      * @param indexB another index
  378.      *
  379.      * @return True if there is at least 1 room left between the two indexes
  380.      */
  381.     private boolean hasEnoughSpaceBetween(int indexA, int indexB) {
  382.         return Math.abs(indexB - indexA) > 1;
  383.     }

  385.     /**
  386.      * Determine the new index which will take place between the two given indexes.
  387.      *
  388.      * @param indexA an index
  389.      * @param indexB another index
  390.      *
  391.      * @return An index that fits between the two given indexes
  392.      */
  393.     private int computeInBetweenIndex(int indexA, int indexB) {
  394.         int baseIndex = indexA;

  396.         int delta = indexB - baseIndex;
  397.         int increment = (int) Math.floor(delta / 2.0);

  399.         return baseIndex + increment;
  400.     }

  402.     /**
  403.      * Fetch the item which is just before the given baseItem in the sortedList.
  404.      *
  405.      * @param baseItem   the reference item
  406.      * @param sortedList the sorted list of items
  407.      *
  408.      * @return the item just before baseItem
  409.      *
  410.      * @throws HttpErrorMessage if the sorted list does not contain the baseItem
  411.      */
  412.     private T getItemBefore(T baseItem, List<T> sortedList) {
  413.         if (!sortedList.contains(baseItem)) {
  414.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  415.         }

  417.         int baseIndexInList = sortedList.indexOf(baseItem);

  419.         if (baseIndexInList > 0) {
  420.             return sortedList.get(baseIndexInList - 1);
  421.         } else {
  422.             // nothing before baseItem
  423.             return null;
  424.         }
  425.     }

  427.     /**
  428.      * Fetch the item which is just after the given baseItem in the sortedList.
  429.      *
  430.      * @param baseItem   the reference item
  431.      * @param sortedList the sorted list of items
  432.      *
  433.      * @return the item just after baseItem
  434.      *
  435.      * @throws HttpErrorMessage if the sorted list does not contain the baseItem
  436.      */
  437.     private T getItemAfter(T baseItem, List<T> sortedList) {
  438.         if (!sortedList.contains(baseItem)) {
  439.             throw HttpErrorMessage.dataError(MessageI18nKey.DATA_INTEGRITY_FAILURE);
  440.         }

  442.         int baseIndexInList = sortedList.indexOf(baseItem);

  444.         if (baseIndexInList < sortedList.size() - 1) {
  445.             return sortedList.get(baseIndexInList + 1);
  446.         } else {
  447.             // nothing after baseItem
  448.             return null;
  449.         }
  450.     }
  451. }
Created with JaCoCo 0.8.8.202204050719