*/
    public boolean isEmpty() {
        return this.sub_authority_count == 0;
    }

    /**
     * Checks whether the SID is blank (all sub-authorities zero).
     *
     * @return whether the SID is blank (all sub-authorities zero)
     */
    public boolean isBlank() {
        boolean blank = true;
        for (final int sub : this.sub_authority) {

                return Short.valueOf(new SimpleDateFormat(pattern).format(o));
            }
            return (short) ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? (short) 1 : (short) 0;
        } else {
            return toShort(o.toString());
        }
    }

    private static Short toShort(final String s) {
        if (StringUtil.isEmpty(s)) {

        }

        File f = new File(path);

        if (!f.isAbsolute()) {
            return false;
        }

        boolean fileExists = f.exists();

        return missing ? !fileExists : fileExists;
    }

    @Override
    public boolean presentInConfig(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        Activation activation = profile.getActivation();

    }

    private boolean isPublicApi(CtMethod method) {
        return Modifier.isPublic(method.modifiers) || Modifier.isProtected(method.modifiers)
    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }

    private boolean isFirstPublicClassInHierarchy(CtMethod method, CtClass c) {

 */
public class UnicodeString extends rpc.unicode_string {

    boolean zterm;

    /**
     * Constructs a UnicodeString with zero termination option.
     *
     * @param zterm whether the string should be zero terminated
     */
    public UnicodeString(final boolean zterm) {
        this.zterm = zterm;
    }

    /**

    }
    return x;
  }

  static void checkRoundingUnnecessary(boolean condition) {
    if (!condition) {
      throw new ArithmeticException("mode was UNNECESSARY, but rounding was necessary");
    }
  }

  static void checkInRangeForRoundingInputs(boolean condition, double input, RoundingMode mode) {
    if (!condition) {
      throw new ArithmeticException(

        new ListenableFuture<String>() {
          @Override
          public boolean cancel(boolean interrupt) {
            return false;
          }

          @Override
          public boolean isDone() {
            return true;
          }

          @Override
          public boolean isCancelled() {
            return true; // BAD!!
          }

          @Override

    protected String encoding = Constants.UTF_8;

    /** Whether to extract front matter as metadata. */
    protected boolean extractFrontMatter = true;

    /** Whether to extract headings as metadata. */
    protected boolean extractHeadings = true;

    /** Whether to extract link URLs as metadata. */
    protected boolean extractLinks = false;

    /** Markdown parser with extensions. */
    protected Parser parser;

     */
    private int allPageCount;

    /**
     * Indicates whether a previous page exists for pagination.
     */
    private boolean existPrePage;

    /**
     * Indicates whether a next page exists for pagination.
     */
    private boolean existNextPage;

    /**
     * The list of page numbers to display for pagination navigation.
     */
    private List<Integer> pageNumberList;

   *
   * Using this as [MockResponse.onResponseEnd] is the default for HTTP/1.0.
   */
  public class CloseSocket(
    public val closeSocket: Boolean = true,
    public val shutdownInput: Boolean = false,
    public val shutdownOutput: Boolean = false,
  ) : SocketEffect

  /**
   * On HTTP/2, send a [GOAWAY frame](https://tools.ietf.org/html/rfc7540#section-6.8) immediately