FormatUtil.java

package com.hypixel.hytale.common.util;

import com.hypixel.hytale.metrics.metric.Metric;
import java.util.EnumMap;
import java.util.Formatter;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.DoubleUnaryOperator;
import javax.annotation.Nonnull;

public class FormatUtil {
   private static final String[] NUMBER_SUFFIXES = new String[]{"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"};
   private static final EnumMap<TimeUnit, String> timeUnitToShortString = new EnumMap<TimeUnit, String>(TimeUnit.class) {
      {
         this.put(TimeUnit.DAYS, "days");
         this.put(TimeUnit.HOURS, "hours");
         this.put(TimeUnit.MINUTES, "min");
         this.put(TimeUnit.SECONDS, "s");
         this.put(TimeUnit.MILLISECONDS, );
         .put(TimeUnit.MICROSECONDS, );
         .put(TimeUnit.NANOSECONDS, );
      }
   };
       DAY_AS_NANOS;
       HOUR_AS_NANOS;
       MINUTE_AS_NANOS;
       SECOND_AS_NANOS;
       MILLISECOND_AS_NANOS;
       MICOSECOND_AS_NANOS;

     {
   }

   
     TimeUnit  {
         unit.toNanos(value);
       (nanos > DAY_AS_NANOS) {
          TimeUnit.DAYS;
      }   (nanos > HOUR_AS_NANOS) {
          TimeUnit.HOURS;
      }   (nanos > MINUTE_AS_NANOS) {
          TimeUnit.MINUTES;
      }   (nanos > SECOND_AS_NANOS) {
          TimeUnit.SECONDS;
      }   (nanos > MILLISECOND_AS_NANOS) {
          TimeUnit.MILLISECONDS;
      }  {
          nanos > MICOSECOND_AS_NANOS ? TimeUnit.MICROSECONDS : TimeUnit.NANOSECONDS;
      }
   }

   
     String  {
         largestUnit(Math.round(metric.getAverage()), timeUnit);
       simpleTimeUnitFormat(metric, timeUnit, largestUnit, rounding);
   }

   
     String  {
         metric.getMin();
         metric.getAverage();
         metric.getMax();
       simpleTimeUnitFormat(min, average, max, timeUnit, largestUnit, rounding);
   }

   
     String  {
         ()Math.pow(, ()rounding);
         Math.round(Math.max(Math.abs(average - ()min), Math.abs(()max - average)));
         largestUnit.convert(Math.round(average * ()roundValue), timeUnit);
         largestUnit.convert(range * ()roundValue, timeUnit);
         (String)timeUnitToShortString.get(largestUnit);
       ()averageNanos / ()roundValue + unitStr +  + ()rangeNanos / ()roundValue + unitStr;
   }

   
     String  {
         ()Math.pow(, ()rounding);
         largestUnit(value, timeUnit);
         largestUnit.convert(value * ()roundValue, timeUnit);
         (String)timeUnitToShortString.get(largestUnit);
       ()averageNanos / ()roundValue + unitStr;
   }

   
     String  {
         doubleFunction.applyAsDouble(average1);
         Math.abs(average - doubleFunction.applyAsDouble(()min1));
         Math.abs(doubleFunction.applyAsDouble(()max1) - average);
         Math.max(min, max);
       simpleFormat(rounding, average, range);
   }

   
     String  {
       simpleFormat(metric, );
   }

   
     String  {
         metric.getAverage();
         Math.abs(average - ()metric.getMin());
         Math.abs(()metric.getMax() - average);
         Math.max(min, max);
       simpleFormat(rounding, average, range);
   }

   
     String  {
         ()Math.pow(, ()rounding);
       ()(()(average * ()roundValue)) / ()roundValue +  + ()(()(range * ()roundValue)) / ()roundValue;
   }

   
     String  {
         Math.abs(metric.getAverage() - ()metric.getMin());
         Math.abs(()metric.getMax() - metric.getAverage());
         Math.round(Math.max(min, max));
         timeUnitToString(Math.round(metric.getAverage()), timeUnit);
       var10000 +  + timeUnitToString(range, timeUnit);
   }

   
     String  {
       timeUnitToString(value, timeUnit, );
   }

   
     String  {
         ;
          ();
          (value);
      p |= timeToStringPart(time, sb, p, timeUnit, TimeUnit.DAYS, , , paddingBetween);
         timeToStringPart(time, sb, p, timeUnit, TimeUnit.HOURS, , , paddingBetween);
      p |= hasHours;
      p |= timeToStringPart(time, sb, p, timeUnit, TimeUnit.MINUTES, hasHours ?  : , , paddingBetween);
      p |= timeToStringPart(time, sb, p, timeUnit, TimeUnit.SECONDS, hasHours ?  : , !hasHours, paddingBetween);
      p |= timeToStringPart(time, sb, p, timeUnit, TimeUnit.MILLISECONDS, , , paddingBetween);
      p |= timeToStringPart(time, sb, p, timeUnit, TimeUnit.MICROSECONDS, , , paddingBetween);
         p | timeToStringPart(time, sb, p, timeUnit, TimeUnit.NANOSECONDS, , , paddingBetween);
       sb.toString();
   }

   
     String  {
       timeUnitToString(nanos, TimeUnit.NANOSECONDS);
   }

       {
       (timeUnitFrom.ordinal() > timeUnitTo.ordinal()) {
          ;
      }  {
            timeUnitTo.convert(time.get(), timeUnitFrom);
         time.getAndAdd(-timeUnitFrom.convert(timeInUnitTo, timeUnitTo));
          (timeInUnitTo >  || previous && time.get() >  || !previous && timeUnitFrom == timeUnitTo) {
             (paddingBefore && previous) {
               sb.append();
            }

            sb.append(timeInUnitTo);
             (paddingBetween) {
               sb.append();
            }

            sb.append(after);
             ;
         }  {
             ;
         }
      }
   }

   
     String  {
       bytesToString(bytes, );
   }

   
     String  {
         si ?  : ;
       (bytes < ()unit) {
          bytes + ;
      }  {
            ()(Math.log(()bytes) / Math.log(()unit));
         Object[] var10001 =  []{()bytes / Math.pow(()unit, ()exp), };
            (si ?  : ).charAt(exp - );
         var10001[] = var10004 + (si ?  : );
          String.format(, var10001);
      }
   }

   
     String  {
      String var10000;
       (i % ) {
          :
          :
          :
            var10000 = i + ;
            ;
         :
            var10000 = i + NUMBER_SUFFIXES[i % ];
      }

       var10000;
   }

       {
      (Object arg : args) {
         formatter.format(format, arg);
      }

   }

       {
      formatArray(formatter, format, args);
   }

    {
      DAY_AS_NANOS = TimeUnit.DAYS.toNanos();
      HOUR_AS_NANOS = TimeUnit.HOURS.toNanos();
      MINUTE_AS_NANOS = TimeUnit.MINUTES.toNanos();
      SECOND_AS_NANOS = TimeUnit.SECONDS.toNanos();
      MILLISECOND_AS_NANOS = TimeUnit.MILLISECONDS.toNanos();
      MICOSECOND_AS_NANOS = TimeUnit.MICROSECONDS.toNanos();
   }
}