content: package io.github.tapcard.emvnfccard.model;
  
  /**
   * Some methods from Apache Commons library
   */
  
  @SuppressWarnings("JavadocReference")
  class CommonsUtils {
      /**
       * <p>The maximum size to which the padding constant(s) can expand.</p>
       */
      private static final int PAD_LIMIT = 8192;
  
      /**
       * <p>Returns padding using the specified delimiter repeated
       * to a given length.</p>
       * <p>
       * <pre>
       * StringUtils.repeat(0, 'e')  = ""
       * StringUtils.repeat(3, 'e')  = "eee"
       * StringUtils.repeat(-2, 'e') = ""
       * </pre>
       * <p>
       * <p>Note: this method doesn't not support padding with
       * <a href="http://www.unicode.org/glossary/#supplementary_character">Unicode Supplementary Characters</a>
       * as they require a pair of {@code char}s to be represented.
       * If you are needing to support full I18N of your applications
       * consider using {@link #repeat(String, int)} instead.
       * </p>
       *
       * @param ch     character to repeat
       * @param repeat number of times to repeat char, negative treated as zero
       * @return String with repeated character
       * @see #repeat(String, int)
       */
      private static String repeat(char ch, int repeat) {
          char[] buf = new char[repeat];
          for (int i = repeat - 1; i >= 0; i--) {
              buf[i] = ch;
          }
          return new String(buf);
      }
  
      /**
       * <p>Right pad a String with a specified character.</p>
       * <p>
       * <p>The String is padded to the size of {@code size}.</p>
       * <p>
       * <pre>
       * StringUtils.rightPad(null, *, *)     = null
       * StringUtils.rightPad("", 3, 'z')     = "zzz"
       * StringUtils.rightPad("bat", 3, 'z')  = "bat"
       * StringUtils.rightPad("bat", 5, 'z')  = "batzz"
       * StringUtils.rightPad("bat", 1, 'z')  = "bat"
       * StringUtils.rightPad("bat", -1, 'z') = "bat"
       * </pre>
       *
       * @param str     the String to pad out, may be null
       * @param size    the size to pad to
       * @param padChar the character to pad with
       * @return right padded String or original String if no padding is necessary,
       * {@code null} if null String input
       * @since 2.0
       */
      private static String rightPad(String str, int size, char padChar) {
          if (str == null) {
              return null;
          }
          int pads = size - str.length();
          if (pads <= 0) {
              return str; // returns original String when possible
          }
          if (pads > PAD_LIMIT) {
              return rightPad(str, size, String.valueOf(padChar));
          }
          return str.concat(repeat(padChar, pads));
      }
  
      /**
       * <p>Right pad a String with a specified String.</p>
       * <p>
       * <p>The String is padded to the size of {@code size}.</p>
       * <p>
       * <pre>
       * StringUtils.rightPad(null, *, *)      = null
       * StringUtils.rightPad("", 3, "z")      = "zzz"
       * StringUtils.rightPad("bat", 3, "yz")  = "bat"
       * StringUtils.rightPad("bat", 5, "yz")  = "batyz"
       * StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
       * StringUtils.rightPad("bat", 1, "yz")  = "bat"
       * StringUtils.rightPad("bat", -1, "yz") = "bat"
       * StringUtils.rightPad("bat", 5, null)  = "bat  "
       * StringUtils.rightPad("bat", 5, "")    = "bat  "
       * </pre>
       *
       * @param str    the String to pad out, may be null
       * @param size   the size to pad to
       * @param padStr the String to pad with, null or empty treated as single space
       * @return right padded String or original String if no padding is necessary,
       * {@code null} if null String input
       */
      static String rightPad(String str, int size, String padStr) {
          if (str == null) {
              return null;
          }
          if (isEmpty(padStr)) {
              padStr = " ";
          }
          int padLen = padStr.length();
          int strLen = str.length();
          int pads = size - strLen;
          if (pads <= 0) {
              return str; // returns original String when possible
          }
          if (padLen == 1 && pads <= PAD_LIMIT) {
              return rightPad(str, size, padStr.charAt(0));
          }
  
          if (pads == padLen) {
              return str.concat(padStr);
          } else if (pads < padLen) {
              return str.concat(padStr.substring(0, pads));
          } else {
              char[] padding = new char[pads];
              char[] padChars = padStr.toCharArray();
              for (int i = 0; i < pads; i++) {
                  padding[i] = padChars[i % padLen];
              }
              return str.concat(new String(padding));
          }
      }
  
      /**
       * <p>Checks if a CharSequence is empty ("") or null.</p>
       * <p>
       * <pre>
       * StringUtils.isEmpty(null)      = true
       * StringUtils.isEmpty("")        = true
       * StringUtils.isEmpty(" ")       = false
       * StringUtils.isEmpty("bob")     = false
       * StringUtils.isEmpty("  bob  ") = false
       * </pre>
       * <p>
       * <p>NOTE: This method changed in Lang version 2.0.
       * It no longer trims the CharSequence.
       * That functionality is available in isBlank().</p>
       *
       * @param cs the CharSequence to check, may be null
       * @return {@code true} if the CharSequence is empty or null
       * @since 3.0 Changed signature from isEmpty(String) to isEmpty(CharSequence)
       */
      private static boolean isEmpty(CharSequence cs) {
          return cs == null || cs.length() == 0;
      }
  
  }
  