TieredList.java

package com.hypixel.hytale.builtin.hytalegenerator.datastructures;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import javax.annotation.Nonnull;

public class TieredList<E> {
   @Nonnull
   private final Map<Integer, ArrayList<E>> elements;
   private final int tiers;
   private List<Integer> sortedTierList;

   public TieredList() {
      this(0);
   }

   public TieredList(int tiers) {
      if (tiers < 0) {
         throw new IllegalArgumentException("negative number of tiers");
      } else {
         this.tiers = tiers;
         this.elements = new HashMap();

         (   ; tier < tiers; ++tier) {
            .elements.put(tier,  ());
         }

         .updateSortedTierList();
      }
   }

   
    TieredList<E>  {
       (.tierExists(tier)) {
           ( + tier);
      }  {
         .elements.put(tier,  ());
         .updateSortedTierList();
          ;
      }
   }

   
    TieredList<E>  {
       (!.tierExists(tier)) {
          ;
      }  {
         .elements.remove(tier);
         .updateSortedTierList();
          ;
      }
   }

      {
       (element == ) {
           ();
      }  {
          (!.tierExists(tier)) {
            .addTier(tier);
         }

         ((ArrayList).elements.get(tier)).add(element);
      }
   }

      {
      (List<E> list : .elements.values()) {
          (!list.isEmpty()) {
             ;
         }
      }

       ;
   }

    E  {
      (   ; tier < .tiers; ++tier) {
         List<E> tierElements = (List).elements.get(tier);
          (!tierElements.isEmpty()) {
             (E)tierElements.getFirst();
         }
      }

        ();
   }

    E  {
      (   ; tier < .tiers; ++tier) {
         List<E> tierElements = (List).elements.get(tier);
          (!tierElements.isEmpty()) {
             (E)tierElements.removeFirst();
         }
      }

        ();
   }

      {
         ;

      (List<E> list : .elements.values()) {
         size += list.size();
      }

       size;
   }

      {
       !.tierExists(tier) ?  : ((ArrayList).elements.get(tier)).size();
   }

   
    TieredList<E>  {
       (!.tierExists(tier)) {
          ;
      }  {
         ((ArrayList).elements.get(tier)).forEach(consumer);
          ;
      }
   }

   
    TieredList<E>  {
       (!.tierExists(tier)) {
          ;
      }  {
         (E e : (List).elements.get(tier)) {
            consumer.accept(e);
         }

          ();
          ;
      }
   }

   
    TieredList<E>  {
      ArrayList<Integer> tiers =  (.getTiers());
      tiers.sort(Comparator.naturalOrder());

      ( tier : tiers) {
         .forEach(tier, consumer);
      }

       ;
   }

   
    TieredList<E>  {
      ( tier : .getTiers()) {
         .removeEach(tier, consumer);
      }

       ;
   }

   
    Iterator<E>  {
       (!.tierExists(tier)) {
           ();
      }  {
          ((ArrayList).elements.get(tier)).iterator();
      }
   }

   
    List<E>  {
       (!.tierExists(tier)) {
           ();
      }  {
          Collections.unmodifiableList((List).elements.get(tier));
      }
   }

      {
       .elements.containsKey(tier);
   }

    List<Integer>  {
       .sortedTierList;
   }

      {
      List<Integer> tierList =  (.elements.keySet());
      tierList.sort(Comparator.naturalOrder());
      tierList = Collections.unmodifiableList(tierList);
      .sortedTierList = tierList;
   }

   
    String  {
         String.valueOf(.elements);
        + var10000 +  + .tiers +  + String.valueOf(.sortedTierList) + ;
   }
}