this.notifyInformation.add(i);
        }

        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.NotifyResponse#getNotifyInformation()
     */
    @Override
    public List<FileNotifyInformation> getNotifyInformation() {
        return this.notifyInformation;
    }

    /**
     * {@inheritDoc}
     *

    }

    /**
     */
    public static class MyBean {
        /**
         * @return String
         */
        public String foo() {
            return "hoge";
        }

        /**
         * @param arg
         * @return String
         */
        public static String bar(final String arg) {
            return arg;
        }
    }

            final List<AnalyzeToken> termTokenList = termResponse.getTokens();
            if (termTokenList.isEmpty()) {
                return text;
            }

            return termTokenList.get(0).getTerm();
        }
    }

                return returnedResultData;
            }

            // Create default ResultData
            ResultData resultData = new ResultData();
            resultData.setTransformerName(getName());
            return resultData;
        }

        @Override
        public Object getData(AccessResultData<?> accessResultData) {

        return escapeSlow(s, i);
      }
    }
    return s;
  }

  /**
   * Escapes a single character using the replacement array and safe range values. If the given
   * character does not have an explicit replacement and lies outside the safe range then {@link
   * #escapeUnsafe} is called.
   *

     *
     * @return the protocol type
     */
    ProtocolType protocolType();

    /**
     * The validation error message.
     *
     * @return the error message
     */
    String message() default "{org.lastaflute.validator.constraints.UriType.message}";

    /**
     * The validation groups.
     *
     * @return the validation groups
     */

fun parseIanaCsvRow(s: String): SuiteId? {
  if (s.contains("Reserved") || s.contains("Unassigned")) return null
  val matcher = IANA_CSV_PATTERN.matchEntire(s) ?: return null
  val id = (matcher.groupValues[1] + matcher.groupValues[2]).decodeHex()
  return SuiteId(id, matcher.groupValues[3])
}

class IanaSuites(
  val name: String,
  val suites: List<SuiteId>,
) {

     * @return {@link JarInputStream}
     * @throws IORuntimeException if an {@link IOException} occurs
     * @see JarInputStream#JarInputStream(InputStream)
     */
    public static JarInputStream create(final InputStream is) throws IORuntimeException {
        assertArgumentNotNull("is", is);

        try {
            return new JarInputStream(is);
        } catch (final IOException e) {

                  @Override
                  protected Set<String> create(String[] elements) {
                    return new SafeTreeSet<>(asList(elements));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {
                    return new ArrayList<>(Sets.newTreeSet(insertionOrder));
                  }
                })
            .withFeatures(

 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)